Updates to docs and revised metaphone function

Revised `double_metaphone` function to `encoding` to better reflect its
utility as well as to be consistent with the equivalent cmu function.

Update README to reflect the recent changes to the API.

Remove an unused variable in the error module.

Author: shnewto

.gitignore

@@ -18,4 +18,5 @@ Cargo.lock
 #**/*.rs.bk
 #Cargo.lock
 
-cmudict.test
+cmudict.test
+cmudict.json

README.md

@@ -29,32 +29,52 @@ talking to a wall, a piecemeal natural language processing library.
 extern crate ttaw;
 use ttaw;
 
-assert_eq!(Ok(true), ttaw::rhyme("far", "tar"));
-assert_eq!(Ok(false), ttaw::rhyme("shopping", "cart"));
+// Initialize the CmuDict with a path to the existing serialized CMU dictionary
+// or a directoy containing it. If the dictionary doesn't exisit, it will be
+// downloaded and serialized at the location specified by the path parameter.
+let cmudict = ttaw::cmu::CmuDict::new("cmudict.json").unwrap();
+
+assert_eq!(Ok(true), cmudict.rhyme("far", "tar"));
+assert_eq!(Ok(true), ttaw::metaphone::rhyme("far", "tar"));
+
+assert_eq!(Ok(false), cmudict.rhyme("shopping", "cart"));
+assert_eq!(Ok(false), ttaw::metaphone::rhyme("shopping", "cart"));
 
 // Deviations in cmu and metaphone
 assert_eq!(true, ttaw::metaphone::rhyme("hear", "near"));
-assert_eq!(Ok(false), ttaw::cmu::rhyme("hear", "near"));
+assert_eq!(Ok(false), cmudict.rhyme("hear", "near"));
 ```
 
 ## Alliteration
 ```rust
 extern crate ttaw;
 use ttaw;
-assert_eq!(Ok(true), ttaw::alliteration("bounding","bears"));
-assert_eq!(Ok(false), ttaw::alliteration("lazy", "dog"));
 
+// Initialize the CmuDict with a path to the existing serialized CMU dictionary
+// or a directoy containing it. If the dictionary doesn't exisit, it will be
+// downloaded and serialized at the location specified by the path parameter.
+let cmudict = ttaw::cmu::CmuDict::new("cmudict.json").unwrap();
+
+assert_eq!(Ok(true), cmudict.alliteration("bounding","bears"));
 assert_eq!(true, ttaw::metaphone::alliteration("bounding","bears"));
-assert_eq!(Ok(true), ttaw::cmu::alliteration("bounding","bears"));
+
+assert_eq!(Ok(false), cmudict.alliteration("lazy", "dog"));
+assert_eq!(false, ttaw::metaphone::alliteration("lazy", "dog"));
 ```
 
 
 ## CMUdict
 ```rust
 extern crate ttaw;
 use ttaw;
+
+// Initialize the CmuDict with a path to the existing serialized CMU dictionary
+// or a directoy containing it. If the dictionary doesn't exisit, it will be
+// downloaded and serialized at the location specified by the path parameter.
+let cmudict = ttaw::cmu::CmuDict::new("cmudict.json").unwrap();
+
 assert_eq!(
-    ttaw::cmu::cmu("unearthed"),
+    cmudict.encoding(("unearthed"),
     Ok(Some(vec![vec![
         "AH0".to_string(),
         "N".to_string(),
@@ -69,15 +89,15 @@ assert_eq!(
 ```rust
 extern crate ttaw;
 use ttaw;
-assert_eq!(ttaw::metaphone::double_metaphone("Arnow").primary, "ARN");
-assert_eq!(ttaw::metaphone::double_metaphone("Arnow").secondary, "ARNF");
+assert_eq!(ttaw::metaphone::encoding("Arnow").primary, "ARN");
+assert_eq!(ttaw::metaphone::encoding("Arnow").secondary, "ARNF");
 
 assert_eq!(
-    ttaw::metaphone::double_metaphone("detestable").primary,
+    ttaw::metaphone::encoding("detestable").primary,
     "TTSTPL"
 );
 assert_eq!(
-    ttaw::metaphone::double_metaphone("detestable").secondary,
+    ttaw::metaphone::encoding("detestable").secondary,
     "TTSTPL"
 );
 ```

src/cmu.rs

@@ -15,6 +15,9 @@ pub struct CmuDict {
 }
 
 impl CmuDict {
+    /// Initialize the CmuDict with a path to the existing serialized CMU dictionary
+    /// or a directoy containing it. If the dictionary doesn't exisit, it will be
+    /// downloaded and serialized at the location specified by the path parameter.
     pub fn new(path: &str) -> Result<CmuDict, Error> {
         match from_json_file(&Path::new(path)) {
             Ok(d) => Ok(CmuDict { dict: d }),
@@ -27,7 +30,7 @@ impl CmuDict {
     /// ```rust
     /// extern crate ttaw;
     /// use ttaw::cmu::CmuDict;
-    /// let cmudict = CmuDict::new("cmu.dict").unwrap();
+    /// let cmudict = CmuDict::new("cmudict.json").unwrap();
     /// assert_eq!(
     ///     cmudict.encoding("permeability"),
     ///     Ok(Some(vec![vec![
@@ -65,7 +68,7 @@ impl CmuDict {
     /// ```rust
     /// extern crate ttaw;
     /// use ttaw::cmu::CmuDict;
-    /// let cmudict = CmuDict::new("cmu.dict").unwrap();
+    /// let cmudict = CmuDict::new("cmudict.json").unwrap();
     /// // Does rhyme
     /// assert!(cmudict.rhyme("hissed", "mist").unwrap());
     /// assert!(cmudict.rhyme("tryst", "wrist").unwrap());
@@ -90,7 +93,7 @@ impl CmuDict {
     /// ```rust
     /// extern crate ttaw;
     /// use ttaw::cmu::CmuDict;
-    /// let cmudict = CmuDict::new("cmu.dict").unwrap();
+    /// let cmudict = CmuDict::new("cmudict.json").unwrap();
     // // Does alliterate
     /// assert!(cmudict.alliteration("bouncing", "bears").unwrap());
     /// assert!(cmudict.alliteration("snappy", "snails").unwrap());

src/error.rs

@@ -44,7 +44,6 @@ mod tests {
     fn display() {
         let input = "input error".to_string();
         let progam = "program error".to_string();
-        let path = "path error".to_string();
 
         assert_eq!(input, format!("{}", Error::InputError(input.clone())));
         assert_eq!(progam, format!("{}", Error::ProgramError(progam.clone())));

src/lib.rs

@@ -4,7 +4,7 @@ extern crate pest;
 /// ```rust
 /// extern crate ttaw;
 /// use ttaw;
-/// let cmudict = ttaw::cmu::CmuDict::new("cmudict.test").unwrap();
+/// let cmudict = ttaw::cmu::CmuDict::new("cmudict.json").unwrap();
 /// assert_eq!(
 ///     cmudict.encoding("permeability"),
 ///     Ok(Some(vec![vec![
@@ -38,11 +38,11 @@ extern crate pest;
 /// ```rust
 /// extern crate ttaw;
 /// use ttaw;
-///     assert_eq!(ttaw::metaphone::double_metaphone("Arnow").primary, "ARN");
-///     assert_eq!(ttaw::metaphone::double_metaphone("Arnow").secondary, "ARNF");
+///     assert_eq!(ttaw::metaphone::encoding("Arnow").primary, "ARN");
+///     assert_eq!(ttaw::metaphone::encoding("Arnow").secondary, "ARNF");
 ///
-///     assert_eq!(ttaw::metaphone::double_metaphone("detestable").primary, "TTSTPL");
-///     assert_eq!(ttaw::metaphone::double_metaphone("detestable").secondary, "TTSTPL");
+///     assert_eq!(ttaw::metaphone::encoding("detestable").primary, "TTSTPL");
+///     assert_eq!(ttaw::metaphone::encoding("detestable").secondary, "TTSTPL");
 /// ```
 #[macro_use]
 extern crate pest_derive;

src/metaphone.rs

@@ -51,16 +51,16 @@ pub fn rhyme(a: &str, b: &str) -> bool {
         return false;
     }
 
-    let a_phonetic = double_metaphone(a);
-    let b_phonetic = double_metaphone(b);
+    let a_phonetic = encoding(a);
+    let b_phonetic = encoding(b);
 
     log::info!(
         "|{: ^10} | {: ^10} | {: ^10} |",
         a,
         a_phonetic.primary,
         a_phonetic.secondary
     );
-    
+
     log::info!(
         "|{: ^10} | {: ^10} | {: ^10} |",
         b,
@@ -119,17 +119,21 @@ pub fn alliteration(a: &str, b: &str) -> bool {
         return false;
     }
 
-    let a_phonetic = double_metaphone(a);
-    let b_phonetic = double_metaphone(b);
+    let a_phonetic = encoding(a);
+    let b_phonetic = encoding(b);
 
     log::info!(
         "|{: ^10} | {: ^10} | {: ^10} |",
-        a, a_phonetic.primary, a_phonetic.secondary
+        a,
+        a_phonetic.primary,
+        a_phonetic.secondary
     );
 
     log::info!(
         "|{: ^10} | {: ^10} | {: ^10} |",
-        b, b_phonetic.primary, b_phonetic.secondary
+        b,
+        b_phonetic.primary,
+        b_phonetic.secondary
     );
 
     let mut a_phonetic_head_primary = a_phonetic.primary;
@@ -172,14 +176,14 @@ pub fn alliteration(a: &str, b: &str) -> bool {
 /// ```rust
 /// extern crate ttaw;
 /// use ttaw;
-/// assert_eq!(ttaw::metaphone::double_metaphone("Arnow").primary, "ARN");
-/// assert_eq!(ttaw::metaphone::double_metaphone("Arnow").secondary, "ARNF");
+/// assert_eq!(ttaw::metaphone::encoding("Arnow").primary, "ARN");
+/// assert_eq!(ttaw::metaphone::encoding("Arnow").secondary, "ARNF");
 ///
-/// assert_eq!(ttaw::metaphone::double_metaphone("detestable").primary, "TTSTPL");
-/// assert_eq!(ttaw::metaphone::double_metaphone("detestable").secondary, "TTSTPL");
+/// assert_eq!(ttaw::metaphone::encoding("detestable").primary, "TTSTPL");
+/// assert_eq!(ttaw::metaphone::encoding("detestable").secondary, "TTSTPL");
 /// ```
 ///
-pub fn double_metaphone(input: &str) -> DoubleMetaphone {
+pub fn encoding(input: &str) -> DoubleMetaphone {
     let mut state = State::new();
     let word: String = input.to_uppercase() + "     ";