Adding metals

src/actions.rs

@@ -25,6 +25,12 @@ pub enum Action {
     AdjectiveAdd(String),
     /// Delete an adjective
     AdjectiveRm(String),
+    /// List metals
+    MetalList,
+    /// Add a new metal
+    MetalAdd(String),
+    /// Remove a metal
+    MetalRm(String),
     /// Generate a name from the description.
     Generate(String),
 }

src/args.rs

@@ -34,6 +34,7 @@ pub enum ParseError {
     UnknownCommand,
     MissingDescription,
     MissingAdjective,
+    MissingMetal,
 }
 
 pub fn parse() -> ParseResult {
@@ -84,6 +85,7 @@ pub fn parse() -> ParseResult {
     match matches.subcommand() {
         ("generate", Some(arguments)) => parse_generate(arguments),
         ("adjectives", Some(arguments)) => parse_adjectives(arguments),
+        ("metals", Some(arguments)) => parse_metals(arguments),
         _ => Err(ParseError::UnknownCommand),
     }
 }
@@ -117,3 +119,26 @@ fn parse_adjectives_rm(arguments: &ArgMatches) -> ParseResult {
         .ok_or(ParseError::MissingAdjective)?;
     Ok(Action::AdjectiveRm(adjective.to_string()))
 }
+
+fn parse_metals(arguments: &ArgMatches) -> ParseResult {
+    match arguments.subcommand() {
+        ("list", _) => Ok(Action::MetalList),
+        ("add", Some(arguments)) => parse_metal_add(arguments),
+        ("rm", Some(arguments)) => parse_metal_rm(arguments),
+        (_, _) => Err(ParseError::UnknownCommand),
+    }
+}
+
+fn parse_metal_add(arguments: &ArgMatches) -> ParseResult {
+    let metal = arguments
+        .value_of("metal")
+        .ok_or(ParseError::MissingMetal)?;
+    Ok(Action::MetalAdd(metal.to_string()))
+}
+
+fn parse_metal_rm(arguments: &ArgMatches) -> ParseResult {
+    let metal = arguments
+        .value_of("metal")
+        .ok_or(ParseError::MissingMetal)?;
+    Ok(Action::MetalRm(metal.to_string()))
+}

src/main.rs

@@ -24,8 +24,9 @@ fn main() {
     match args::parse() {
         Ok(x) => match x {
             actions::Action::AdjectiveAdd(word) => {
-                repository::WordList::insert_adjective(&word).unwrap();
+                repository::WordList::insert_adjective(&word).unwrap()
             }
+            actions::Action::MetalAdd(word) => repository::WordList::insert_metal(&word).unwrap(),
             _ => unimplemented!(),
         },
         Err(x) => println!("Error {:?}", x),

src/repository.rs

@@ -73,24 +73,37 @@ impl WordList {
     /// add an adjective to the word list
     pub fn insert_adjective(adjective: &str) -> Result<(), WordListError> {
         let mut repo = Self::load()?;
-        let initial = adjective
+        Self::insert_word(adjective, &mut repo.adjectives)?;
+        repo.save()
+    }
+
+    /// Add a metal to the word list
+    pub fn insert_metal(metal: &str) -> Result<(), WordListError> {
+        let mut repo = Self::load()?;
+        Self::insert_word(metal, &mut repo.metals)?;
+        repo.save()
+    }
+
+    /// Generic function to insert words in the storage; the target points in which of the lists
+    /// the word should be inserted.
+    fn insert_word(word: &str, target: &mut WordStorage) -> Result<(), WordListError> {
+        let initial = word
             .chars()
             .nth(0)
             .ok_or(WordListError::InvalidWord)?
             .to_string();
-        let mut list = if !repo.adjectives.contains_key(&initial) {
+        let mut list = if !target.contains_key(&initial) {
             let empty_list = LinkedList::new();
             empty_list
         } else {
-            repo.adjectives.get(&initial).unwrap().to_owned()
+            target.get(&initial).unwrap().to_owned()
         };
 
-        if list.contains(&adjective.to_string()) {
+        if list.contains(&word.to_string()) {
             Err(WordListError::WordAlreadyExists)
         } else {
-            list.push_back(adjective.to_string());
-            repo.adjectives.insert(initial, list);
-            repo.save()?;
+            list.push_back(word.to_string());
+            target.insert(initial, list);
             Ok(())
         }
     }