✨ addd cli-candlestick-chart binary usage

Author: Julien-R44

Cargo.lock

@@ -14,14 +14,21 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-serde = { version = "1", features = ["derive"], optional = true }
 terminal_size = "0.1.17"
 colored = "2"
+serde = { version = "1", features = ["derive"], optional = true }
+clap = { version = "2.33.3", optional = true }
+serde_json = { version = "1.0.1", optional = true }
+csv = { version = "1.1", optional = true }
 
 [dev-dependencies]
-csv = "1.1"
 reqwest = { version = "0.11", features = ["blocking", "json"] }
 
+[[bin]]
+name = "cli-candlestick-chart"
+path = "src/bin/cli/main.rs"
+required-features = ["serde", "serde_json", "csv", "clap"]
+
 [[example]]
 name = "basic-with-csv-parsing"
 required-features = ["serde"]

Cargo.toml

@@ -0,0 +1,80 @@
+use clap::{App, Arg};
+use std::str::FromStr;
+
+pub enum ReadingMode {
+    Stdin,
+    CsvFile,
+}
+
+impl FromStr for ReadingMode {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "Stdin" => Ok(ReadingMode::Stdin),
+            "CsvFile" => Ok(ReadingMode::CsvFile),
+            _ => Err("no match"),
+        }
+    }
+}
+
+pub struct CliOptions {
+    pub reading_mode: ReadingMode,
+    pub file_path: Option<String>,
+    pub chart_name: Option<String>,
+    pub bear_color: Option<String>,
+    pub bull_color: Option<String>,
+}
+
+pub fn get_args() -> CliOptions {
+    let matches = App::new(env!("CARGO_PKG_NAME"))
+        .version(env!("CARGO_PKG_VERSION"))
+        .author(env!("CARGO_PKG_AUTHORS"))
+        .arg(
+            Arg::with_name("READING_MODE")
+                .short("r")
+                .long("reading-mode")
+                .help("Make the program reads and parse candles from stdin.")
+                .possible_values(&["stdin", "csv-file", "json-file"])
+                .takes_value(true)
+                .required(true),
+        )
+        .arg(
+            Arg::with_name("FILE")
+                .short("f")
+                .long("file")
+                .help("File to read candles from, if reading-mode is `*-file.`")
+                .takes_value(true),
+        )
+        .arg(
+            Arg::with_name("CHART_NAME")
+                .long("chart-name")
+                .help("Sets the chart name.")
+                .takes_value(true),
+        )
+        .arg(
+            Arg::with_name("BEAR_COLOR")
+                .long("bear-color")
+                .help("Sets the descending candles color in hexadecimal.")
+                .takes_value(true),
+        )
+        .arg(
+            Arg::with_name("BULL_COLOR")
+                .long("bull-color")
+                .help("Sets the ascending candles color in hexadecimal.")
+                .takes_value(true),
+        )
+        .get_matches();
+
+    return CliOptions {
+        reading_mode: match matches.value_of("READING_MODE").unwrap() {
+            "stdin" => ReadingMode::Stdin,
+            "csv-file" => ReadingMode::CsvFile,
+            _ => panic!("Invalid reading mode."),
+        },
+        file_path: matches.value_of("FILE").map(|s| s.to_string()),
+        chart_name: matches.value_of("CHART_NAME").map(|s| s.to_string()),
+        bear_color: matches.value_of("BEAR_COLOR").map(|s| s.to_string()),
+        bull_color: matches.value_of("BULL_COLOR").map(|s| s.to_string()),
+    };
+}

src/bin/cli/get_args.rs

@@ -0,0 +1,68 @@
+use clap::{App, Arg};
+use cli_candlestick_chart::{Candle, Chart};
+use std::error::Error;
+use std::io::{self, BufRead};
+
+mod utils;
+use utils::hexa_to_rgb;
+
+mod get_args;
+use get_args::{get_args, ReadingMode};
+
+fn parse_candles_from_stdin() -> Vec<Candle> {
+    let stdin = io::stdin();
+
+    let mut stdin_lines = String::new();
+    for line in stdin.lock().lines() {
+        let line = line.expect("Could not read line from standard in");
+        stdin_lines.push_str(&line);
+    }
+
+    let candles: Vec<Candle> = serde_json::from_str(&stdin_lines).expect("Could not parse json");
+    candles
+}
+
+fn parse_candles_from_csv(filepath: &str) -> Result<Vec<Candle>, Box<dyn Error>> {
+    let mut rdr = csv::Reader::from_path(filepath)?;
+    let mut candles: Vec<Candle> = Vec::new();
+
+    for result in rdr.deserialize() {
+        let candle: Candle = result?;
+        candles.push(candle);
+    }
+
+    Ok(candles)
+}
+
+fn main() {
+    let options = get_args();
+    let mut candles: Vec<Candle> = Vec::new();
+
+    match options.reading_mode {
+        ReadingMode::Stdin => {
+            candles = parse_candles_from_stdin();
+        }
+        ReadingMode::CsvFile => {
+            let filepath = options.file_path.expect("No file path provided.");
+            candles = parse_candles_from_csv(&filepath).unwrap();
+        }
+    };
+
+    let mut chart = Chart::new(&candles);
+
+    if let Some(chart_name) = options.chart_name {
+        chart.set_name(chart_name);
+    }
+
+    if let Some(bear_color) = options.bear_color {
+        let (r, g, b) = hexa_to_rgb(bear_color);
+        chart.set_bear_color(r, g, b);
+    }
+
+    if let Some(bull_color) = options.bull_color {
+        let (r, g, b) = hexa_to_rgb(bull_color);
+        chart.set_bull_color(r, g, b);
+    }
+
+    chart.draw();
+}

src/bin/cli/main.rs

@@ -0,0 +1,7 @@
+pub fn hexa_to_rgb(hex_code: String) -> (u8, u8, u8) {
+    let hex_code = hex_code.trim_start_matches('#');
+    let r = u8::from_str_radix(&hex_code[0..2], 16).unwrap();
+    let g = u8::from_str_radix(&hex_code[2..4], 16).unwrap();
+    let b = u8::from_str_radix(&hex_code[4..6], 16).unwrap();
+    (r, g, b)
+}