Merge pull request #5 from blood-rogue/main

Performance improvements

Author: Axlefublr

README.md

@@ -32,10 +32,11 @@ By default, the random words are joined by a space.
 You can change that using `--joiner` or `-j`.
 It doesn't necessarily have to be a single character.
 
-If you specify `\n` in `--join`, it's treated as a newline character; `\t` is a tab character.
+If you specify `\n` in `--joiner`, it's treated as a newline character; `\t` is a tab character.
 Use `--raw` or `-r` to disable this functionality.
 
-`--caps` or `-c` will CAPITALIZE every word. `--title` or `-t` will Titlecase every word.
+Use `--case` or `-c` to specify the case of the words. Supported values are `caps` for Capitalized words, `title` for Title case words and `lower` for lower case letters which is a default.
+
 
 ## How do I install this?
 
@@ -45,9 +46,31 @@ Have git and rust installed
 
 ```
 cargo install --git https://github.com/Axlefublr/uclanr.git
-uclanr 5
+```
+
+## Usage
+
+```
+$ uclanr --help
+A word generator that specializes in useful words
+
+Usage: uclanr.exe [OPTIONS] [AMOUNT]
+
+Arguments:
+  [AMOUNT]
+          Amount of random words to print [default: 1]
+
+Options:
+  -j, --joiner <JOINER>
+          The string that joines the random words, if there are more than 1 [default: " "]
+  -c, --case <CASE>
+          Sets the case of every word [default: lower] [possible values: caps, title, lower]
+  -r, --raw
+          Disable interpreting \n as a newline and \t as a tab
+  -h, --help
+          Print help
 ```
 
 ## Contribution
 
-`git pull` the dev branch before any changes, please
+`git pull` the dev branch before any changes, please

src/args.rs

@@ -1,45 +1,66 @@
-use clap::Parser;
-use crate::Case;
+use clap::{Parser, ValueEnum};
 
-#[derive(Parser, Debug)]
-#[command(author, about, long_about = None)]
-#[command(next_line_help = true)]
+#[derive(Parser)]
+#[command(author, about, next_line_help = true)]
 pub struct Args {
 	/// The string that joines the random words, if there are more than 1
 	#[arg(short, long, default_value_t = String::from(" "))]
 	joiner: String,
-	/// Uppercase every word
-	#[arg(short, long)]
-	pub caps: bool,
-	/// Titlecase every word
-	#[arg(short, long)]
-	pub title: bool,
+
+	/// Sets the case of every word
+	#[arg(short, long, value_enum, default_value_t = Case::Lower)]
+	case: Case,
+
 	/// Disable interpreting \n as a newline and \t as a tab
-	#[arg(short, long, default_value_t = false)]
+	#[arg(short, long)]
 	raw: bool,
+
 	/// Amount of random words to print
 	#[arg(default_value_t = 1)]
 	pub amount: usize,
 }
 
 impl Args {
-	pub fn get_case(&self) -> Case {
-		if self.caps {
-			Case::Caps
-		} else if self.title {
-			Case::Title
+	pub fn get_joiner(&self) -> String {
+		if self.raw {
+			self.joiner.clone()
 		} else {
-			Case::Lower
+			self.joiner
+				.clone()
+				.replace("\\n", "\n")
+				.replace("\\t", "\t")
 		}
 	}
 
-	pub fn joiner(&self) -> String {
-		match self.raw {
-			false => self.joiner
-				.clone()
-				.replace("\\n", "\n")
-				.replace("\\t", "\t"),
-			true => self.joiner.clone(),
+	pub fn alter_case(&self, mut words: Vec<String>) -> Vec<String> {
+		self.case.alter_case(&mut words);
+		words.to_vec()
+	}
+}
+
+#[derive(ValueEnum, Clone, Copy)]
+pub enum Case {
+	Caps,
+	Title,
+	Lower,
+}
+
+impl Case {
+	fn alter_case(self, words: &mut [String]) {
+		match self {
+			Self::Caps => {
+				for x in words.iter_mut() {
+					x.make_ascii_uppercase();
+				}
+			}
+
+			Self::Title => {
+				for x in words.iter_mut() {
+					x[0..1].make_ascii_uppercase();
+				}
+			}
+
+			Self::Lower => {}
 		}
 	}
-}
+}

src/main.rs

@@ -1,50 +1,20 @@
-use rand::seq::SliceRandom;
-use std::io::BufRead;
 use clap::Parser;
+use rand::seq::SliceRandom;
+use words::WORDS;
 
 mod args;
+mod words;
 
 fn main() {
 	let args = args::Args::parse();
-	let bytes = include_bytes!("words.txt");
-	let words: Vec<String> = bytes
-		.lines()
-		.collect::<Result<_, _>>()
-		.expect("file parsed correctly");
-	let mut picked_words = get_random_words(&words, args.amount);
-	alter_case(&mut picked_words, args.get_case());
-	println!("{}", picked_words.join(&args.joiner()));
+	let picked_words = args.alter_case(get_random_words(args.amount));
+
+	println!("{}", picked_words.join(&args.get_joiner()));
 }
 
-fn get_random_words(words: &[String], amount: usize) -> Vec<String> {
-	words
+fn get_random_words(amount: usize) -> Vec<String> {
+	WORDS
 		.choose_multiple(&mut rand::thread_rng(), amount)
-		.cloned()
+		.map(|word| (*word).to_string())
 		.collect()
 }
-
-pub enum Case {
-	Caps,
-	Title,
-	Lower
-}
-
-fn alter_case(words: &mut [String], case: Case) {
-	match case {
-		Case::Caps => {
-			words
-				.iter_mut()
-				.for_each(|x| {
-					x.make_ascii_uppercase();
-				});
-		}
-		Case::Title => {
-			words
-				.iter_mut()
-				.for_each(|x| {
-					x[0..1].make_ascii_uppercase();
-				});
-		}
-		Case::Lower => ()
-	}
-}