refactor: user printer module

Author: azzamsa

src/lib.rs

@@ -2,4 +2,5 @@ pub mod cli;
 pub mod config;
 pub mod dns;
 pub mod error;
+pub mod output;
 pub mod utils;

src/main.rs

@@ -2,11 +2,9 @@ use std::process;
 use trust_dns_client::rr::RecordType;
 
 use clap::Parser;
-use colored::*;
-use log::trace;
 use miette::Result;
 
-use digs::{cli, cli::Opts, config, dns, utils};
+use digs::{cli, cli::Opts, output::Printer, utils};
 
 fn run() -> Result<()> {
     let opts = Opts::parse();
@@ -21,55 +19,9 @@ fn run() -> Result<()> {
         cli::RecordType::SOA => RecordType::SOA,
         cli::RecordType::TXT => RecordType::TXT,
     };
-    let config = config::read(&opts.config)?;
-
-    for server in config.servers {
-        let response = dns::query(&domain, record_type, &server.ip);
-        trace!("Response -> {:?}", response);
-
-        println!("{}", server.name);
-        match response {
-            Err(e) => {
-                println!("  {}", e.to_string().red());
-            }
-            Ok(res) => {
-                let print_output = |rr_type: String, name: String, rdata: String| {
-                    println!(
-                        "  {} {} {}",
-                        rr_type.green().bold(),
-                        name.blue(),
-                        rdata.bold()
-                    );
-                };
-
-                // FIXME
-                if !res.answers().is_empty() {
-                    for res in res.answers() {
-                        let rr_type = res.rr_type().to_string();
-                        print_output(
-                            rr_type,
-                            res.name().to_string(),
-                            res.data().expect("no `rdata` found").to_string(),
-                        );
-                    }
-                } else if res.answers().is_empty() && !res.name_servers().is_empty() {
-                    // if answers is empty, print default record (SOA)
-                    for res in res.name_servers() {
-                        let rr_type = res.rr_type().to_string();
-                        print_output(
-                            rr_type,
-                            res.name().to_string(),
-                            res.data().expect("no `rdata` found").to_string(),
-                        );
-                    }
-                } else {
-                    // if default doesn't exist
-                    println!("{}", "  No zone found".to_string().red());
-                }
-            }
-        }
-    }
 
+    let printer = Printer::new(domain, record_type, opts.config);
+    printer.print()?;
     Ok(())
 }
 

src/output.rs

@@ -0,0 +1,66 @@
+use std::path::PathBuf;
+
+use colored::Colorize;
+use log::trace;
+use trust_dns_client::rr::{Record, RecordType};
+
+use crate::error::Error;
+use crate::{config, dns};
+
+pub struct Printer {
+    domain: String,
+    record_type: RecordType,
+    config: PathBuf,
+}
+
+impl Printer {
+    pub fn new(domain: String, record_type: RecordType, config: PathBuf) -> Self {
+        Self {
+            domain,
+            record_type,
+            config,
+        }
+    }
+    pub fn print(&self) -> Result<(), Error> {
+        let config = config::read(&self.config)?;
+
+        for server in config.servers {
+            let response = dns::query(&self.domain, self.record_type, &server.ip);
+            trace!("Response -> {:?}", response);
+
+            println!("{}", server.name);
+            match response {
+                Err(e) => {
+                    println!("  {}", e.to_string().red());
+                }
+                Ok(res) => {
+                    if !res.answers().is_empty() {
+                        for record in res.answers() {
+                            Self::print_record(record);
+                        }
+                    } else if res.answers().is_empty() && !res.name_servers().is_empty() {
+                        // if answers is empty, print default record (SOA)
+                        for record in res.name_servers() {
+                            Self::print_record(record);
+                        }
+                    } else {
+                        // if default doesn't exist
+                        println!("{}", "  No zone found".to_string().red());
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+    fn print_record(record: &Record) {
+        let record_type = record.record_type().to_string();
+        let record_type = record_type.green().bold();
+        let name = record.name().to_string().blue();
+        let rdata = match record.data() {
+            Some(rdata) => rdata.to_string(),
+            None => "".to_string(),
+        };
+        let rdata = rdata.bold();
+        println!("  {} {} {}", record_type, name, rdata);
+    }
+}