refactor: ♻️ Handle channel rendering in a separate module

src/args.rs

@@ -11,6 +11,9 @@ pub struct Args {
 
     #[clap(short, long, default_value_t = false)]
     pub pretty: bool,
+
+    #[clap(long, default_value_t = 4)]
+    pub indentation: u16,
 }
 
 pub fn parse_args()-> Args {

src/channel_lib.rs

@@ -2,9 +2,9 @@ use std::fs::File;
 use std::io::{BufReader, Cursor};
 
 use log::{error, info};
-use rss::Channel;
+pub use rss::Channel;
 
-pub fn build_channel(input: String) -> Channel {
+pub fn build_channel(input: &String) -> Channel {
     let channel: Channel;
 
     if input.starts_with("http://") || input.starts_with("https://") {

src/json_lib.rs

@@ -1,9 +1,10 @@
 use chrono::DateTime;
-use json::{object, JsonValue};
+pub use json::{object, JsonValue};
 use log::error;
 use rss::Channel;
 
-pub fn build_json(channel: Channel) -> JsonValue {
+// Build a JsonValue object reflecting a Channel instance
+pub fn build_json(channel: &Channel) -> JsonValue {
     // Initialize root object with channel informations, using object macro from json crate
     let mut data = object! {
         channel: object!{
@@ -64,5 +65,6 @@ pub fn build_json(channel: Channel) -> JsonValue {
 
     // attach the items to the json data root
     data["items"] = items_data;
+    
     return data;
 }

src/main.rs

@@ -4,54 +4,29 @@
 // TODO refactor and unit tests to improve code while knowledge grows !
 // TODO handle remote http feed discovery by parsing index and search for the feed link
 // TODO serialize to local document database CRUD
-use std::fs;
-
-use json::JsonValue;
-use rss::Channel;
 
 // use log::{debug, info, warn, error };
-use log::{error, info};
-
+// use log::{error, info};
 mod args;
 use crate::args::parse_args;
 
 mod channel_lib;
-use crate::channel_lib::build_channel;
+use crate::channel_lib::{build_channel, Channel};
 
 mod json_lib;
-use crate::json_lib::build_json;
+use crate::json_lib::{build_json, JsonValue};
 
-fn main() -> std::io::Result<()> {
+mod render;
+use crate::render::render_json;
+
+fn main() {
     env_logger::init();
 
     let args = parse_args();
 
-    let channel: Channel = build_channel(args.input);
+    let channel: Channel = build_channel(&args.input);
 
-    let data: JsonValue = build_json(channel);
+    let data: JsonValue = build_json(&channel);
 
-    // output result
-    let output_string: String = if args.pretty {
-        data.pretty(4)
-    } else {
-        data.dump()
-    };
-
-    if args.output.len() > 0 {
-        let output_length = output_string.len();
-        let filename = args.output.to_string();
-        match fs::write(filename, output_string) {
-            Ok(_) => {
-                info!("saving {} characters to {}", output_length, args.output);
-            }
-            Err(e) => {
-                error!("{:?}", e);
-            }
-        }
-        Ok(())
-    } else {
-        // no file name specified, dump json to stdout
-        println!("{}", output_string);
-        Ok(())
-    }
+    render_json(&data, args.pretty, args.indentation, &args.output);
 }

src/render.rs

@@ -0,0 +1,28 @@
+use json::JsonValue;
+use log::{error, info};
+use std::fs;
+
+pub fn render_json(value: &JsonValue, pretty: bool, spaces: u16, output: &String) {
+    // output result
+    let output_string: String = if pretty {
+        value.pretty(spaces)
+    } else {
+        value.dump()
+    };
+
+    if output.len() > 0 {
+        let output_length = output_string.len();
+        let filename = output.to_string();
+        match fs::write(filename, output_string) {
+            Ok(_) => {
+                info!("saved {} characters to {}", output_length, output);
+            }
+            Err(e) => {
+                error!("{:?}", e);
+            }
+        }
+    } else {
+        // no file name specified, dump json to stdout
+        println!("{}", output_string);
+    }
+}