Merge pull request #37 from snipsco/release/0.7.1

Release/0.7.1

Author: adrienball

CHANGELOG.md

@@ -1,6 +1,10 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## [0.7.1]
+### Added
+- Add a license file to the gazetteer entity parser [#36](https://github.com/snipsco/gazetteer-entity-parser/pull/36)
+
 ## [0.7.0] - 2019-04-16
 ### Added
 - Add API to prepend entity values [#31](https://github.com/snipsco/gazetteer-entity-parser/pull/31)
@@ -19,6 +23,7 @@ All notable changes to this project will be documented in this file.
 ### Changed
 - Clearer `ParserBuilder`'s API 
 
+[0.7.1]: https://github.com/snipsco/gazetteer-entity-parser/compare/0.7.0...0.7.1
 [0.7.0]: https://github.com/snipsco/gazetteer-entity-parser/compare/0.6.0...0.7.0
 [0.6.0]: https://github.com/snipsco/gazetteer-entity-parser/compare/0.5.1...0.6.0
 [0.5.1]: https://github.com/snipsco/gazetteer-entity-parser/compare/0.5.0...0.5.1

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gazetteer-entity-parser"
-version = "0.7.0"
+version = "0.7.1"
 authors = ["Alaa Saade <[email protected]>"]
 
 [profile.bench]

examples/interactive_parsing_cli.rs

@@ -1,31 +1,93 @@
 extern crate clap;
-extern crate serde_json;
 extern crate gazetteer_entity_parser;
+extern crate serde_json;
 
-use clap::{Arg, App};
-use std::io;
 use std::io::Write;
-use gazetteer_entity_parser::Parser;
+use std::{fs, io};
+
+use clap::{App, Arg};
+
+use gazetteer_entity_parser::{Gazetteer, Parser, ParserBuilder};
 
 fn main() {
-    let matches = App::new("gazetteer-entity-parser-demo")
+    let mut app = App::new("gazetteer-entity-parser-demo")
         .about("Interactive CLI for parsing gazetteer entities")
-        .arg(Arg::with_name("PARSER_DIR")
-            .required(true)
-            .takes_value(true)
-            .index(1)
-            .help("path to the parser directory"))
-        .get_matches();
-
-    let parser_dir = matches.value_of("PARSER_DIR").unwrap();
-    println!("\nLoading the parser...");
-    let parser = Parser::from_folder(parser_dir).unwrap();
-    loop {
-        print!("> ");
-        io::stdout().flush().unwrap();
-        let mut query = String::new();
-        io::stdin().read_line(&mut query).unwrap();
-        let result = parser.run(query.trim()).unwrap();
-        println!("{:?}", result);
+        .arg(
+            Arg::with_name("parser")
+                .short("p")
+                .long("--parser")
+                .takes_value(true)
+                .help("path to the parser directory"),
+        )
+        .arg(
+            Arg::with_name("gazetteer")
+                .short("g")
+                .long("--gazetteer")
+                .takes_value(true)
+                .help("path to the json gazetteer file"),
+        )
+        .arg(
+            Arg::with_name("opt_nb_stop_words")
+                .short("n")
+                .long("--nb-stop-words")
+                .takes_value(true)
+                .help("number of stop words to use"),
+        )
+        .arg(
+            Arg::with_name("opt_tokens_ratio")
+                .short("r")
+                .long("--ratio")
+                .takes_value(true)
+                .help("minimum tokens ratio for the parser"),
+        );
+    let matches = app.clone().get_matches();
+
+    let opt_nb_stop_words = matches
+        .value_of("opt_nb_stop_words")
+        .map(|nb_str| nb_str.to_string().parse::<usize>().unwrap());
+
+    let opt_tokens_ratio = matches
+        .value_of("opt_tokens_ratio")
+        .map(|ratio_str| ratio_str.to_string().parse::<f32>().unwrap());
+
+    if let Some(parser) = matches
+        .value_of("parser")
+        .map(|parser_dir| {
+            println!("\nLoading the parser...");
+            let mut parser = Parser::from_folder(parser_dir).unwrap();
+            if let Some(ratio) = opt_tokens_ratio {
+                parser.set_threshold(ratio);
+            };
+            if let Some(nb_stop_words) = opt_nb_stop_words {
+                parser.set_stop_words(nb_stop_words, None);
+            };
+            parser
+        })
+        .or_else(|| {
+            matches.value_of("gazetteer").map(|gazetteer_path| {
+                println!("\nLoading the gazetteer...");
+                let gazetteer_file = fs::File::open(&gazetteer_path).unwrap();
+                let gazetteer: Gazetteer = serde_json::from_reader(gazetteer_file).unwrap();
+
+                println!("\nBuilding the parser...");
+                ParserBuilder::default()
+                    .gazetteer(gazetteer)
+                    .n_stop_words(opt_nb_stop_words.unwrap_or(0))
+                    .minimum_tokens_ratio(opt_tokens_ratio.unwrap_or(1.0))
+                    .build()
+                    .unwrap()
+            })
+        })
+    {
+        loop {
+            print!("> ");
+            io::stdout().flush().unwrap();
+            let mut query = String::new();
+            io::stdin().read_line(&mut query).unwrap();
+            let result = parser.run(query.trim()).unwrap();
+            println!("{:?}", result);
+        }
+    } else {
+        app.print_long_help().unwrap();
     }
 }

src/parser.rs

@@ -43,6 +43,15 @@ pub struct Parser {
     injected_values: HashSet<String>,
     // Parsing threshold giving minimal fraction of tokens necessary to parse a value
     threshold: f32,
+    // License information associated to the parser's data
+    #[serde(default)]
+    license_info: Option<LicenseInfo>,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+pub struct LicenseInfo {
+    pub filename: String,
+    pub content: String,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -239,6 +248,11 @@ impl Parser {
             .collect();
     }
 
+    /// Set the license info
+    pub fn set_license_info<T: Into<Option<LicenseInfo>>>(&mut self, license_info: T) {
+        self.license_info = license_info.into();
+    }
+
     /// Get the set of stop words
     pub fn get_stop_words(&self) -> HashSet<String> {
         self.stop_words
@@ -370,6 +384,13 @@ impl Parser {
 
         self.serialize(&mut Serializer::new(&mut writer))
             .with_context(|_| format_err!("Error when serializing the parser"))?;
+
+        if let Some(license_info) = &self.license_info {
+            let license_path = folder_name.as_ref().join(&license_info.filename);
+            fs::write(license_path, &license_info.content)
+                .with_context(|_| format_err!("Error when writing the license"))?
+        }
+
         Ok(())
     }
 
@@ -813,6 +834,16 @@ mod tests {
     use parser_builder::ParserBuilder;
     use std::time::Instant;
 
+    fn get_license_info() -> LicenseInfo {
+        let license_content = "Some content here".to_string();
+        let license_filename = "LICENSE".to_string();
+        let license_info = LicenseInfo {
+            filename: license_filename,
+            content: license_content,
+        };
+        license_info
+    }
+
     #[test]
     fn test_serialization_deserialization() {
         let tdir = tempdir().unwrap();
@@ -829,14 +860,28 @@ mod tests {
             resolved_value: "The Rolling Stones".to_string(),
             raw_value: "the stones".to_string(),
         });
+
+        let license_info = get_license_info();
+
         let parser = ParserBuilder::default()
             .minimum_tokens_ratio(0.5)
             .gazetteer(gazetteer)
             .n_stop_words(2)
             .additional_stop_words(vec!["hello".to_string()])
+            .license_info(license_info)
             .build()
             .unwrap();
-        parser.dump(tdir.as_ref().join("parser")).unwrap();
+
+        let serialized_parser_path = tdir.as_ref().join("parser");
+        let license_path = serialized_parser_path.join("LICENSE");
+        parser.dump(serialized_parser_path).unwrap();
+
+        assert!(license_path.exists());
+
+        let expected_content = "Some content here".to_string();
+        let content = fs::read_to_string(license_path).unwrap();
+        assert_eq!(content, expected_content);
+
         let reloaded_parser = Parser::from_folder(tdir.as_ref().join("parser")).unwrap();
 
         assert_eq!(parser, reloaded_parser);