Parsing all adjectives commands now

src/actions.rs

@@ -19,6 +19,12 @@
 /// List of actions available
 #[derive(Debug)]
 pub enum Action {
+    /// List adjectives
+    AdjectiveList,
+    /// Add a new adjective
+    AdjectiveAdd(String),
+    /// Delete an adjective
+    AdjectiveRm(String),
     /// Generate a name from the description.
     Generate(String),
 }

src/args.rs

@@ -22,18 +22,21 @@ use clap::crate_name;
 use clap::crate_version;
 use clap::App;
 use clap::Arg;
-// use clap::ArgMatches;
+use clap::ArgMatches;
 use clap::SubCommand;
 
 use crate::actions::Action;
 
+type ParseResult = Result<Action, ParseError>;
+
 #[derive(Debug)]
 pub enum ParseError {
     UnknownCommand,
     MissingDescription,
+    MissingAdjective,
 }
 
-pub fn parse() -> Result<Action, ParseError> {
+pub fn parse() -> ParseResult {
     let params = App::new(crate_name!())
         .version(crate_version!())
         .author(crate_authors!())
@@ -79,12 +82,38 @@ pub fn parse() -> Result<Action, ParseError> {
         );
     let matches = params.get_matches();
     match matches.subcommand() {
-        ("generate", Some(arguments)) => {
+        ("generate", Some(arguments)) => parse_generate(arguments),
-            let description = arguments
+        ("adjectives", Some(arguments)) => parse_adjectives(arguments),
-                .value_of("description")
-                .ok_or(ParseError::MissingDescription)?;
-            Ok(Action::Generate(description.to_string()))
-        }
         _ => Err(ParseError::UnknownCommand),
     }
 }
+
+fn parse_generate(arguments: &ArgMatches) -> ParseResult {
+    let description = arguments
+        .value_of("description")
+        .ok_or(ParseError::MissingDescription)?;
+    Ok(Action::Generate(description.to_string()))
+}
+
+fn parse_adjectives(arguments: &ArgMatches) -> ParseResult {
+    match arguments.subcommand() {
+        ("list", _) => Ok(Action::AdjectiveList),
+        ("add", Some(arguments)) => parse_adjectives_add(arguments),
+        ("rm", Some(arguments)) => parse_adjectives_rm(arguments),
+        (_, _) => Err(ParseError::UnknownCommand),
+    }
+}
+
+fn parse_adjectives_add(arguments: &ArgMatches) -> ParseResult {
+    let adjective = arguments
+        .value_of("adjective")
+        .ok_or(ParseError::MissingAdjective)?;
+    Ok(Action::AdjectiveAdd(adjective.to_string()))
+}
+
+fn parse_adjectives_rm(arguments: &ArgMatches) -> ParseResult {
+    let adjective = arguments
+        .value_of("adjective")
+        .ok_or(ParseError::MissingAdjective)?;
+    Ok(Action::AdjectiveRm(adjective.to_string()))
+}

src/main.rs

@@ -18,13 +18,13 @@
 
 mod actions;
 mod args;
-mod database;
+mod repository;
 
 fn main() {
     match args::parse() {
         Ok(x) => {
             println!("Ok: {:?}", x);
-            if let Ok(_db) = database::Database::load() {
+            if let Ok(_db) = repository::WordList::load() {
                 println!("Has db");
             } else {
                 println!("Do not has db");

src/repository.rs

@@ -10,45 +10,45 @@ use toml;
 type WordStorage = BTreeMap<char, LinkedList<String>>;
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct Database {
+pub struct WordList {
     adjectives: WordStorage,
     metals: WordStorage,
 }
 
-pub enum DatabaseError {
+pub enum WordListError {
     InvalidFormat,
 }
 
-impl std::convert::From<std::io::Error> for DatabaseError {
+impl std::convert::From<std::io::Error> for WordListError {
-    fn from(_error: std::io::Error) -> DatabaseError {
+    fn from(_error: std::io::Error) -> WordListError {
-        DatabaseError::InvalidFormat
+        WordListError::InvalidFormat
     }
 }
 
-impl std::convert::From<toml::de::Error> for DatabaseError {
+impl std::convert::From<toml::de::Error> for WordListError {
-    fn from(_error: toml::de::Error) -> DatabaseError {
+    fn from(_error: toml::de::Error) -> WordListError {
-        DatabaseError::InvalidFormat
+        WordListError::InvalidFormat
     }
 }
 
-impl Database {
+impl WordList {
     /// Create an empty database
     fn empty() -> Self {
-        Database {
+        WordList {
             adjectives: WordStorage::new(),
             metals: WordStorage::new(),
         }
     }
 
     /// Load the database
-    pub fn load() -> Result<Self, DatabaseError> {
+    pub fn load() -> Result<Self, WordListError> {
         if let Ok(mut fp) = File::open("database.toml") {
             let mut content = String::new();
             fp.read_to_string(&mut content)?;
             let data = toml::from_str(&content)?;
             Ok(data)
         } else {
-            Ok(Database::empty())
+            Ok(WordList::empty())
         }
     }
 }