[Code Quality]: default implementation for reader and writer (#461)

* misc tweaks

* changing commands except for completions to be public, so they can be used once built

* adding some new helper methods for reader, and writer to reduce verbosity

guard/src/commands/rulegen_tests.rs

@@ -1,8 +1,6 @@
 use crate::commands::rulegen;
-use crate::utils::writer::WriteBuffer;
 use crate::utils::writer::Writer;
 use pretty_assertions::assert_eq;
-use std::io::{stderr, stdout};
 
 #[test]
 fn test_rulegen() {
@@ -31,7 +29,7 @@ fn test_rulegen() {
         "#,
     );
 
-    let mut writer = Writer::new(WriteBuffer::Stdout(stdout()), WriteBuffer::Stderr(stderr()));
+    let mut writer = Writer::default();
     let generated_rules = rulegen::parse_template_and_call_gen(&data, &mut writer);
 
     assert_eq!(1, generated_rules.len());
@@ -62,7 +60,7 @@ fn test_rulegen_no_properties() {
         "#,
     );
 
-    let mut writer = Writer::new(WriteBuffer::Stdout(stdout()), WriteBuffer::Stderr(stderr()));
+    let mut writer = Writer::default();
     let generated_rules = rulegen::parse_template_and_call_gen(&data, &mut writer);
 
     assert_eq!(0, generated_rules.len());

guard/src/main.rs

@@ -5,7 +5,6 @@ mod utils;
 
 use crate::commands::{CfnGuard, Commands};
 use crate::utils::reader::{ReadBuffer, Reader};
-use crate::utils::writer::WriteBuffer::Stderr;
 use crate::utils::writer::{WriteBuffer::File as WBFile, WriteBuffer::Stdout, Writer};
 use clap::Parser;
 use rules::errors::Error;
@@ -16,14 +15,14 @@ fn main() -> Result<(), Error> {
 
     let mut writer = match &args.command {
         Commands::ParseTree(cmd) => match &cmd.output {
-            Some(path) => Writer::new(WBFile(File::create(path)?), Stderr(std::io::stderr())),
-            None => Writer::new(Stdout(std::io::stdout()), Stderr(std::io::stderr())),
+            Some(path) => Writer::new(WBFile(File::create(path)?)),
+            None => Writer::new(Stdout(std::io::stdout())),
         },
         Commands::Rulegen(cmd) => match &cmd.output {
-            Some(path) => Writer::new(WBFile(File::create(path)?), Stderr(std::io::stderr())),
-            None => Writer::new(Stdout(std::io::stdout()), Stderr(std::io::stderr())),
+            Some(path) => Writer::new(WBFile(File::create(path)?)),
+            None => Writer::new(Stdout(std::io::stdout())),
         },
-        _ => Writer::new(Stdout(std::io::stdout()), Stderr(std::io::stderr())),
+        _ => Writer::new(Stdout(std::io::stdout())),
     };
 
     let mut reader = Reader::new(ReadBuffer::Stdin(std::io::stdin()));

guard/src/rules/eval_tests.rs

@@ -3,11 +3,9 @@ use grep_searcher::SearcherBuilder;
 use indoc::formatdoc;
 use pretty_assertions::{assert_eq, assert_ne};
 use std::collections::HashMap;
-use std::io::{stderr, stdout};
 
 use crate::rules::eval_context::eval_context_tests::BasicQueryTesting;
 use crate::rules::eval_context::{root_scope, EventRecord, RecordTracker};
-use crate::utils::writer::WriteBuffer::{Stderr, Stdout};
 
 use super::*;
 
@@ -3892,7 +3890,7 @@ fn parameterized_evaluations() -> Result<()> {
     let mut eval = root_scope(&rules_files, Rc::new(template));
     let status = eval_rules_file(&rules_files, &mut eval, None)?;
     let top = eval.reset_recorder().extract();
-    let mut writer = Writer::new(Stdout(stdout()), Stderr(stderr()));
+    let mut writer = Writer::default();
     crate::commands::validate::print_verbose_tree(&top, &mut writer);
     assert_eq!(status, Status::FAIL);
 

guard/src/utils/reader.rs

@@ -5,6 +5,14 @@ pub struct Reader {
     inner: ReadBuffer,
 }
 
+impl Default for Reader {
+    fn default() -> Self {
+        Self {
+            inner: ReadBuffer::Stdin(std::io::stdin()),
+        }
+    }
+}
+
 impl Read for Reader {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         match &mut self.inner {

guard/src/utils/writer.rs

@@ -8,8 +8,28 @@ pub struct Writer {
     err: WriteBuffer,
 }
 
+impl Default for Writer {
+    fn default() -> Self {
+        Self {
+            buffer: WriteBuffer::Stdout(std::io::stdout()),
+            err: WriteBuffer::Stderr(std::io::stderr()),
+        }
+    }
+}
+
 impl Writer {
-    pub fn new(buffer: WriteBuffer, err: WriteBuffer) -> Self {
+    pub fn new(buffer: WriteBuffer) -> Self {
+        if let WriteBuffer::Stderr(_) = buffer {
+            panic!("unable to use stderr as regular buffer");
+        }
+
+        Self {
+            buffer,
+            err: WriteBuffer::Stderr(std::io::stderr()),
+        }
+    }
+
+    pub fn new_with_err(buffer: WriteBuffer, err: WriteBuffer) -> Self {
         if let WriteBuffer::Stderr(_) = buffer {
             panic!("unable to use stderr as regular buffer");
         }

guard/tests/parse_tree.rs

@@ -5,7 +5,6 @@ pub(crate) mod utils;
 #[cfg(test)]
 mod parse_tree_tests {
     use cfn_guard::commands::{PRINT_JSON, PRINT_YAML, RULES};
-    use cfn_guard::utils::reader::ReadBuffer::Stdin;
     use cfn_guard::utils::reader::Reader;
     use cfn_guard::utils::writer::{WriteBuffer::Vec as WBVec, Writer};
     use pretty_assertions::assert_eq;
@@ -72,8 +71,8 @@ mod parse_tree_tests {
 
     #[test]
     fn test_json_output() {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = ParseTreeTestRunner::default()
             .print_json()
             .rules("validate/rules-dir/s3_bucket_server_side_encryption_enabled.guard")
@@ -111,8 +110,8 @@ mod parse_tree_tests {
         #[case] expected_writer_output: &str,
         #[case] expected_status_code: i32,
     ) {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = ParseTreeTestRunner::default()
             .rules(rules_arg)
             .run(&mut writer, &mut reader);
@@ -131,8 +130,8 @@ mod parse_tree_tests {
         #[case] rules_arg: &str,
         #[case] expected_status_code: i32,
     ) {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new_with_err(WBVec(vec![]), WBVec(vec![]));
         let status_code = ParseTreeTestRunner::default()
             .rules(rules_arg)
             .run(&mut writer, &mut reader);
@@ -169,8 +168,8 @@ mod parse_tree_tests {
         #[case] expected_writer_output: &str,
         #[case] expected_status_code: i32,
     ) {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = ParseTreeTestRunner::default()
             .rules(rules_arg)
             .run(&mut writer, &mut reader);

guard/tests/rulegen.rs

@@ -6,9 +6,7 @@ pub(crate) mod utils;
 mod rulegen_tests {
     use crate::assert_output_from_file_eq;
     use cfn_guard::commands::{OUTPUT, TEMPLATE};
-    use cfn_guard::utils::reader::ReadBuffer::Stdin;
     use cfn_guard::utils::reader::Reader;
-    use cfn_guard::utils::writer::WriteBuffer::Stderr;
     use cfn_guard::utils::writer::{WriteBuffer::Vec as WBVec, Writer};
     use pretty_assertions::assert_eq;
 
@@ -67,8 +65,8 @@ mod rulegen_tests {
         #[case] expected_output_file_path: &str,
         #[case] expected_status_code: i32,
     ) {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), Stderr(std::io::stderr()));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = RulegenTestRunner::default()
             .template(template_arg)
             .run(&mut writer, &mut reader);

guard/tests/test_command.rs

@@ -12,7 +12,6 @@ mod test_command_tests {
         ALPHABETICAL, DIRECTORY, LAST_MODIFIED, OUTPUT_FORMAT, RULES_AND_TEST_FILE, RULES_FILE,
         TEST_DATA, VERBOSE,
     };
-    use cfn_guard::utils::reader::ReadBuffer::Stdin;
     use cfn_guard::utils::reader::Reader;
     use cfn_guard::utils::writer::{WriteBuffer::Vec as WBVec, Writer};
     use cfn_guard::Error;
@@ -134,8 +133,8 @@ mod test_command_tests {
     #[case("json")]
     #[case("yaml")]
     fn test_data_file_with_shorthand_reference(#[case] file_type: &str) -> Result<(), Error> {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = TestCommandTestRunner::default()
             .test_data(Some(&format!(
                 "resources/test-command/data-dir/s3_bucket_logging_enabled_tests.{}",
@@ -159,8 +158,8 @@ mod test_command_tests {
     #[case("json")]
     #[case("yaml")]
     fn test_data_file(#[case] file_type: &str) -> Result<(), Error> {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = TestCommandTestRunner::default()
             .test_data(Some(&format!(
                 "resources/test-command/data-dir/s3_bucket_server_side_encryption_enabled.{}",
@@ -182,8 +181,8 @@ mod test_command_tests {
 
     #[test]
     fn test_parse_error_when_guard_rule_has_syntax_error() {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = TestCommandTestRunner::default()
             .test_data(Some("resources/test-command/data-dir/test.yaml"))
             .rules(Some("resources/test-command/rule-dir/invalid_rule.guard"))
@@ -203,8 +202,8 @@ mod test_command_tests {
 
     #[test]
     fn test_parse_error_when_file_dne() {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new_with_err(WBVec(vec![]), WBVec(vec![]));
         let status_code = TestCommandTestRunner::default()
             .test_data(Some("resources/test-command/data-dir/test.yaml"))
             .rules(Some("/resources/test-command/data-dir/invalid_rule.guard"))
@@ -221,8 +220,8 @@ mod test_command_tests {
 
     #[test]
     fn test_data_file_verbose() -> Result<(), Error> {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = TestCommandTestRunner::default()
             .test_data(Some(
                 "resources/test-command/data-dir/s3_bucket_server_side_encryption_enabled.yaml",
@@ -244,8 +243,8 @@ mod test_command_tests {
 
     #[test]
     fn test_with_rules_dir_verbose() {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = TestCommandTestRunner::default()
             .directory(Option::from("resources/test-command/dir"))
             .directory_only()
@@ -264,8 +263,8 @@ mod test_command_tests {
     #[case("yaml")]
     #[case("junit")]
     fn test_structured_single_report(#[case] output: &str) {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = TestCommandTestRunner::default()
             .test_data(Option::from(
                 "resources/test-command/data-dir/s3_bucket_server_side_encryption_enabled.yaml",
@@ -295,8 +294,8 @@ mod test_command_tests {
     #[case("yaml")]
     #[case("junit")]
     fn test_structured_directory_report(#[case] output: &str) {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = TestCommandTestRunner::default()
             .directory(Option::from("resources/test-command/dir"))
             .output_format(output)
@@ -320,8 +319,8 @@ mod test_command_tests {
     #[case("json")]
     #[case("yaml")]
     fn test_structured_report_with_illegal_args(#[case] output: &str) {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = TestCommandTestRunner::default()
             .directory(Option::from("resources/test-command/dir"))
             .output_format(output)
@@ -333,8 +332,8 @@ mod test_command_tests {
 
     #[test]
     fn test_with_function_expr() {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = TestCommandTestRunner::default()
             .test_data(Option::from(
                 "resources/test-command/functions/data/template.yaml",
@@ -350,8 +349,8 @@ mod test_command_tests {
 
     #[test]
     fn test_with_failure() {
-        let mut reader = Reader::new(Stdin(std::io::stdin()));
-        let mut writer = Writer::new(WBVec(vec![]), WBVec(vec![]));
+        let mut reader = Reader::default();
+        let mut writer = Writer::new(WBVec(vec![]));
         let status_code = TestCommandTestRunner::default()
             .test_data(Option::from(
                 "resources/test-command/data-dir/failing_test.yaml",

guard/tests/utils.rs

@@ -73,7 +73,7 @@ pub fn sanitize_junit_writer(writer: Writer) -> Writer {
     let rgx = Regex::new(r#"time="\d+""#).unwrap();
     let res = rgx.replace_all(&buf, r#"time="0""#);
 
-    Writer::new(WBVec(res.as_bytes().to_vec()), WBVec(vec![]))
+    Writer::new(WBVec(res.as_bytes().to_vec()))
 }
 
 pub fn get_full_path_for_resource_file(path: &str) -> String {