|
|
|
/*
|
|
|
|
NRP - Name Rust Program
|
|
|
|
Copyright (C) 2020 Julio Biason
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU Affero General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU Affero General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
use clap::crate_authors;
|
|
|
|
use clap::crate_description;
|
|
|
|
use clap::crate_name;
|
|
|
|
use clap::crate_version;
|
|
|
|
use clap::App;
|
|
|
|
use clap::Arg;
|
|
|
|
use clap::ArgMatches;
|
|
|
|
use clap::SubCommand;
|
|
|
|
|
|
|
|
use crate::actions::Action;
|
|
|
|
|
|
|
|
type ParseResult = Result<Action, ParseError>;
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub enum ParseError {
|
|
|
|
UnknownCommand,
|
|
|
|
MissingDescription,
|
|
|
|
MissingAdjective,
|
|
|
|
MissingMetal,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn parse() -> ParseResult {
|
|
|
|
let params = App::new(crate_name!())
|
|
|
|
.version(crate_version!())
|
|
|
|
.author(crate_authors!())
|
|
|
|
.about(crate_description!())
|
|
|
|
.subcommand(
|
|
|
|
SubCommand::with_name("generate")
|
|
|
|
.about("Generate a name")
|
|
|
|
.arg(
|
|
|
|
Arg::with_name("description")
|
|
|
|
.required(true)
|
|
|
|
.help("Short description of your application"),
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.subcommand(
|
|
|
|
SubCommand::with_name("adjectives")
|
|
|
|
.about("Manage the adjective list")
|
|
|
|
.subcommand(SubCommand::with_name("list").about("List current adjectives"))
|
|
|
|
.subcommand(
|
|
|
|
SubCommand::with_name("add")
|
|
|
|
.about("Add an adjective")
|
|
|
|
.arg(Arg::with_name("adjective").help("Adjecive to be added")),
|
|
|
|
)
|
|
|
|
.subcommand(
|
|
|
|
SubCommand::with_name("rm")
|
|
|
|
.about("Remove an adjective")
|
|
|
|
.arg(Arg::with_name("adjective").help("Adjective to be removed")),
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.subcommand(
|
|
|
|
SubCommand::with_name("metals")
|
|
|
|
.about("Manage the metal list")
|
|
|
|
.subcommand(SubCommand::with_name("list").about("List all metals"))
|
|
|
|
.subcommand(
|
|
|
|
SubCommand::with_name("add")
|
|
|
|
.about("Add a metal to the list")
|
|
|
|
.arg(Arg::with_name("metal").help("Metal name to be added")),
|
|
|
|
)
|
|
|
|
.subcommand(
|
|
|
|
SubCommand::with_name("rm")
|
|
|
|
.about("Remove a metal from the list")
|
|
|
|
.arg(Arg::with_name("metal").help("Metal name to be removed")),
|
|
|
|
),
|
|
|
|
);
|
|
|
|
let matches = params.get_matches();
|
|
|
|
match matches.subcommand() {
|
|
|
|
("generate", Some(arguments)) => parse_generate(arguments),
|
|
|
|
("adjectives", Some(arguments)) => parse_adjectives(arguments),
|
|
|
|
("metals", Some(arguments)) => parse_metals(arguments),
|
|
|
|
_ => 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()))
|
|
|
|
}
|
|
|
|
|
|
|
|
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()))
|
|
|
|
}
|