Closer to a clean working refactor

Author: FaceFTW

src/cowsay.rs

@@ -1,10 +1,9 @@
 use crate::parser::{ParserIterator, TerminalCharacter};
 use owo_colors::{DynColor, OwoColorize, Style, XtermColors};
 use std::{collections::HashMap, error::Error, str::from_utf8};
-#[cfg(not(feature = "inline-cowsay"))]
 use std::{
     fs::{self, File},
-    io::{self, Read},
+    io::Read,
     path::PathBuf,
 };
 use strip_ansi_escapes::strip;
@@ -352,40 +351,39 @@ pub fn print_cowsay(
     println!("{msg_str}{cow_str}")
 }
 
-#[cfg(feature = "inline-cowsay")]
-pub fn choose_random_cow(rng: &mut impl Rand) -> String {
-    let chosen_idx = rng.next_lim_usize(COW_DATA.len());
-    COW_DATA[chosen_idx].1.to_string()
-}
-
 #[cfg(feature = "inline-cowsay")]
 pub fn get_cow_by_name(name: &str) -> Option<&str> {
     COW_DATA
         .into_iter()
         .find_map(|item| if item.0 == name { Some(item.1) } else { None })
 }
 
+fn get_external_cow(cow_list: &[String], rng: &mut impl Rand) -> String {
+    let chosen_idx = rng.next_lim_usize(cow_list.len());
+
+    let chosen_path = &cow_list[chosen_idx];
+    match fs::File::open(chosen_path) {
+        Ok(mut file) => {
+            let mut cow_str = String::new();
+            file.read_to_string(&mut cow_str)
+                .expect("Error reading cow string");
+            cow_str
+        }
+        Err(e) => panic!("{e}"),
+    }
+}
+
 pub fn choose_random_cow(cow_list: &[String], rng: &mut impl Rand) -> String {
     cfg_select! {
         feature = "inline-cowsay" => {
-             let chosen_idx = rng.next_lim_usize(cow_list.len());
-             cow_list[chosen_idx].1.to_string()
-        }
-        not(feature = "inline-cowsay") => {
-            let chosen_idx = rng.next_lim_usize(cow_list.len());
-
-            let chosen_path = &cow_list[chosen_idx];
-            match fs::File::open(chosen_path) {
-                Ok(mut file) => {
-                    let mut cow_str = String::new();
-                    file.read_to_string(&mut cow_str)
-                        .expect("Error reading cow string");
-                    cow_str
-                }
-                Err(e) => panic!("{e}"),
+            if !cow_list.is_empty() {
+                  get_external_cow(cow_list, rng)
+              } else {
+                 let chosen_idx = rng.next_lim_usize(COW_DATA.len());
+                 COW_DATA[chosen_idx].1.to_string()
             }
-
         }
+        not(feature = "inline-cowsay") => { get_external_cow(cow_list, rng) }
     }
 }
 
@@ -399,7 +397,7 @@ pub fn get_cow_string(cow_files: &[String], rng: &mut impl tinyrand::Rand) -> St
                 1 => get_cow_by_name(&cow_files[0].as_str())
                         .expect("Could not find a cow with the specified name in the inlined data")
                         .to_string(),
-                _ => choose_random_cow(&COW_DATA, rng)
+                _ => choose_random_cow(&[], rng)
             }
         }
         not(feature = "inline-cowsay") => {

src/fortune.rs

@@ -1,11 +1,5 @@
 use std::error::Error;
-#[cfg(not(feature = "inline-fortune"))]
-use std::{
-    ffi::OsStr,
-    fs::{self, File},
-    io::{self, Read},
-    path::PathBuf,
-};
+use std::{fs::File, io::Read};
 use tinyrand::Rand;
 
 fn check_fortune_constraints(
@@ -34,8 +28,42 @@ fn check_fortune_constraints(
     })
 }
 
+fn get_external_fortune(
+    rng: &mut impl Rand,
+    list: &[String],
+    include_off: bool,
+    max_width: Option<u64>,
+    max_lines: Option<u64>,
+) -> Result<String, Box<dyn Error>> {
+    let file_path = match include_off {
+        true => {
+            let idx = rng.next_lim_usize(list.len());
+            list[idx].clone()
+        }
+        false => {
+            let filtered: Vec<&String> = list.into_iter().filter(|x| !x.contains("off")).collect();
+            let idx = rng.next_lim_usize(filtered.len());
+            filtered[idx].clone()
+        }
+    };
+
+    match File::open(file_path) {
+        Ok(mut file) => {
+            let mut string_buf = String::new();
+            let _result = file.read_to_string(&mut string_buf)?;
+            let no_cr = string_buf.replace("\r", "");
+            let split: Vec<&str> = no_cr
+                .split("\n%\n")
+                .filter(|element| check_fortune_constraints(element, max_width, max_lines))
+                .collect();
+            let chosen_idx = rng.next_lim_usize(split.len());
+            Ok(split[chosen_idx].to_string())
+        }
+        Err(e) => panic!("Could not open Fortune file! {e}"),
+    }
+}
+
 ///default method of getting a fortune, without using the index file.
-#[cfg(not(feature = "inline-fortune"))]
 pub fn get_fortune(
     _fortune_files: &[String],
     rng: &mut impl Rand,
@@ -45,55 +73,52 @@ pub fn get_fortune(
 ) -> Result<String, Box<dyn Error>> {
     cfg_select! {
         feature = "inline-fortune" => {
-            macro_rules! choose_inline_fortune {
-                ($rng_ident:ident, $list_ident:ident, $max_wid_ident:ident, $max_lines_ident:ident) => {{
-                    let list_iter: Vec<&'static str> = $list_ident
-                        .into_iter()
-                        .filter(|element| {
-                            check_fortune_constraints(element, $max_wid_ident, $max_lines_ident)
-                        })
-                        .collect();
-                    let chosen_idx = $rng_ident.next_lim_usize(list_iter.len());
-                    Ok($list_ident[chosen_idx].to_string())
-                }};
-            }
-
-            cfg_if::cfg_if! {
-                if #[cfg(feature="inline-off-fortune")]{
-                    if include_offensive {
-                        let weight_off:f64 = OFF_FORTUNE_LIST.len() as f64/(FORTUNE_LIST.len() as f64 + OFF_FORTUNE_LIST.len() as f64);
-                        match rng.next_bool(weight_off.into()){
-                            true => choose_inline_fortune!(rng, OFF_FORTUNE_LIST, max_width, max_lines),
-                            false => choose_inline_fortune!(rng, FORTUNE_LIST, max_width, max_lines),
-                        }
-                    } else {
-                        choose_inline_fortune!(rng, FORTUNE_LIST, max_width, max_lines)
+            if !_fortune_files.is_empty(){
+                get_external_fortune(
+                     rng,
+                     _fortune_files,
+                     include_offensive,
+                     max_width,
+                     max_lines
+                )
+            } else {
+                let list = match include_offensive {
+                    true => {
+                        cfg_select! {
+                             feature = "inline-off-fortune" => {
+                                 if include_offensive {
+                                     let weight_off:f64 = OFF_FORTUNE_LIST.len() as f64/(FORTUNE_LIST.len() as f64 + OFF_FORTUNE_LIST.len() as f64);
+                                     match rng.next_bool(weight_off.into()){
+                                         true => OFF_FORTUNE_LIST,
+                                         false => FORTUNE_LIST,
+                                     }
+                                 } else {
+                                     FORTUNE_LIST
+                                 }
+                             }
+                             not(feature = "inline-off-fortune") => { FORTUNE_LIST }
+                         }
                     }
-                } else {
-                    let _ = include_offensive;
-                    choose_inline_fortune!(rng, FORTUNE_LIST, max_width, max_lines)
-                }
+                    false => FORTUNE_LIST,
+                };
+
+                let list_iter: Vec<&'static str> = list
+                    .into_iter()
+                    .filter(|element| check_fortune_constraints(element, max_width, max_lines))
+                    .collect();
+                let chosen_idx = rng.next_lim_usize(list_iter.len());
+                Ok(list[chosen_idx].to_string())
             }
 
         }
         not(feature = "inline-fortune") => {
-            // TODO Choose the file to open, exclude offensive as necessary
-
-            match File::open(file_path) {
-                Ok(mut file) => {
-                    let mut string_buf = String::new();
-                    let _result = file.read_to_string(&mut string_buf)?;
-                    let no_cr = string_buf.replace("\r", "");
-                    let split: Vec<&str> = no_cr
-                        .split("\n%\n")
-                        .filter(|element| check_fortune_constraints(element, max_width, max_lines))
-                        .collect();
-                    let chosen_idx = rng.next_lim_usize(split.len());
-                    Ok(split[chosen_idx].to_string())
-                }
-                Err(e) => panic!("Could not open Fortune file! {e}"),
-            }
-
+           get_external_fortune(
+                rng,
+                _fortune_files,
+                include_offensive,
+                max_width,
+                max_lines
+            )
         }
     }
 }

src/main.rs

@@ -4,9 +4,7 @@ mod fortune;
 mod parser;
 
 use cli::Options;
-use cowsay::{
-    CowVariant, SpeechBubble, get_cow_names, get_cow_string, print_cowsay, random_cow_variant,
-};
+use cowsay::{CowVariant, SpeechBubble, get_cow_string, print_cowsay, random_cow_variant};
 
 use tinyrand::{Seeded, StdRand};
 
@@ -44,6 +42,7 @@ fn main() {
         _ => options.cow_variant,
     };
 
+    //TODO why did I do this
     let max_width = match options.max_width {
         Some(val) => val as usize,
         None => 64usize,