Merge pull request #9 from Julien-R44/feat/volume-pane

Julien-R44 · web-flow · commit 07d9e1b8b2ed · 2021-11-16T03:21:42.000+01:00
Feat/volume pane + basic documentation
diff --git a/README.md b/README.md
@@ -60,7 +60,12 @@ fn main() {
     // Set customs colors
     chart.set_bear_color(1, 205, 254);
     chart.set_bull_color(255, 107, 153);
+    chart.set_vol_bull_color(1, 205, 254);
+    chart.set_vol_bear_color(255, 107, 153);
 
+    chart.set_volume_pane_height(6);
+    chart.set_volume_pane_enabled(false);
+    
     chart.draw();
 }
 ```
diff --git a/examples/fetch-from-binance.rs b/examples/fetch-from-binance.rs
@@ -21,7 +21,7 @@ struct BinanceKlinesItem {
 
 fn main() -> Result<(), Box<dyn Error>> {
     let candles =
-        reqwest::blocking::get("https://api.binance.com/api/v1/klines?symbol=BTCUSDT&interval=1h")?
+        reqwest::blocking::get("https://api.binance.com/api/v1/klines?symbol=CHZUSDT&interval=1h")?
             .json::<Vec<BinanceKlinesItem>>()?
             .iter()
             .map(|candle| {
@@ -30,18 +30,22 @@ fn main() -> Result<(), Box<dyn Error>> {
                     candle.high.parse::<f64>().unwrap(),
                     candle.low.parse::<f64>().unwrap(),
                     candle.close.parse::<f64>().unwrap(),
+                    Some(candle.volume.parse::<f64>().unwrap()),
+                    Some(candle.open_time as i64),
                 )
             })
             .collect::<Vec<Candle>>();
 
     let mut chart = Chart::new(&candles);
 
-    // Set the chart title
-    chart.set_name(String::from("BTC/USDT"));
-
-    // Set customs colors
-    chart.set_bear_color(1, 205, 254);
-    chart.set_bull_color(255, 107, 153);
+    chart.set_name(String::from("CHZ/USDT"));
+    chart.set_bull_color(1, 205, 254);
+    chart.set_bear_color(255, 107, 153);
+    chart.set_vol_bull_color(1, 205, 254);
+    chart.set_vol_bear_color(255, 107, 153);
+    chart.set_volume_pane_height(4);
+    chart.set_volume_pane_enabled(true);
+    // chart.set_volume_pane_unicode_fill(true);
 
     chart.draw();
 
diff --git a/src/bin/cli/yahoo_api.rs b/src/bin/cli/yahoo_api.rs
@@ -34,10 +34,11 @@ pub fn get_yahoo_klines(symbol: &str, interval: &str) -> Vec<Candle> {
     let client = reqwest::blocking::get(url.as_str()).unwrap();
     let value: serde_json::Value = serde_json::from_str(client.text().unwrap().as_str()).unwrap();
 
-    let nb_candles = value["chart"]["result"][0]["timestamp"]
+    let timestamps = value["chart"]["result"][0]["timestamp"]
         .as_array()
-        .expect("Ticker seems to be invalid.")
-        .len();
+        .expect("Tickers seems to be invalid.");
+
+    let nb_candles = timestamps.len();
 
     let mut candles: Vec<Candle> = Vec::new();
     for i in 0..nb_candles {
@@ -47,12 +48,16 @@ pub fn get_yahoo_klines(symbol: &str, interval: &str) -> Vec<Candle> {
         let high = base["high"][i].as_f64().unwrap();
         let low = base["low"][i].as_f64().unwrap();
         let close = base["close"][i].as_f64().unwrap();
+        let volume = base["volume"][i].as_f64().unwrap();
+        let timestamp = timestamps[i].as_i64().unwrap();
 
         let candle = Candle::new(
             open.to_owned(),
             high.to_owned(),
             low.to_owned(),
             close.to_owned(),
+            Some(volume.to_owned()),
+            Some(timestamp.to_owned()),
         );
         candles.push(candle);
     }
diff --git a/src/candle_set.rs b/src/candle_set.rs
@@ -3,22 +3,31 @@ use crate::Candle;
 #[derive(Debug, Clone)]
 pub struct CandleSet {
     pub candles: Vec<Candle>,
-    pub min_value: f64,
-    pub max_value: f64,
+
+    pub min_price: f64,
+    pub max_price: f64,
+
+    pub min_volume: f64,
+    pub max_volume: f64,
+
     pub variation: f64,
     pub average: f64,
     pub last_price: f64,
+    pub cumulative_volume: f64,
 }
 
 impl CandleSet {
     pub fn new(candles: Vec<Candle>) -> CandleSet {
         let mut cs = CandleSet {
             candles: Vec::new(),
-            min_value: 0.0,
-            max_value: 0.0,
+            min_price: 0.0,
+            max_price: 0.0,
+            min_volume: 0.0,
+            max_volume: 0.0,
             variation: 0.0,
             average: 0.0,
             last_price: 0.0,
+            cumulative_volume: 0.0,
         };
 
         cs.set_candles(candles);
@@ -37,6 +46,14 @@ impl CandleSet {
         self.compute_variation();
         self.compute_average();
         self.compute_last_price();
+        self.compute_cumulative_volume();
+    }
+
+    fn compute_cumulative_volume(&mut self) {
+        self.cumulative_volume = self
+            .candles
+            .iter()
+            .fold(0.0, |acc, candle| acc + candle.volume.unwrap_or_default());
     }
 
     fn compute_last_price(&mut self) {
@@ -57,11 +74,20 @@ impl CandleSet {
     }
 
     fn compute_min_and_max_values(&mut self) {
-        self.max_value = self
+        self.max_price = self
             .candles
             .iter()
             .fold(f64::NEG_INFINITY, |a, b| a.max(b.high));
 
-        self.min_value = self.candles.iter().fold(f64::INFINITY, |a, b| a.min(b.low));
+        self.min_price = self.candles.iter().fold(f64::INFINITY, |a, b| a.min(b.low));
+
+        self.max_volume = self.candles.iter().fold(f64::NEG_INFINITY, |a, b| {
+            a.max(b.volume.unwrap_or_default())
+        });
+
+        self.min_volume = self
+            .candles
+            .iter()
+            .fold(f64::INFINITY, |a, b| a.min(b.volume.unwrap_or_default()));
     }
 }
diff --git a/src/chart.rs b/src/chart.rs
@@ -1,8 +1,9 @@
-use std::{cell::RefCell, rc::Rc};
-
 use crate::{
-    chart_data::ChartData, chart_renderer::ChartRenderer, info_bar::InfoBar, y_axis::YAxis,
+    chart_data::ChartData, chart_renderer::ChartRenderer, info_bar::InfoBar,
+    volume_pane::VolumePane, y_axis::YAxis,
 };
+use std::cell::RefCell;
+use std::rc::Rc;
 
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize))]
@@ -11,25 +12,36 @@ pub struct Candle {
     pub high: f64,
     pub low: f64,
     pub close: f64,
+    pub volume: Option<f64>,
+    pub timestamp: Option<i64>,
 }
 
-pub enum CandleType {
+pub(crate) enum CandleType {
     Bearish,
     Bullish,
 }
 
 impl Candle {
     #[allow(dead_code)]
-    pub fn new(open: f64, high: f64, low: f64, close: f64) -> Candle {
+    pub fn new(
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: Option<f64>,
+        timestamp: Option<i64>,
+    ) -> Candle {
         Candle {
             open,
             high,
             low,
             close,
+            volume,
+            timestamp,
         }
     }
 
-    pub fn get_type(&self) -> CandleType {
+    pub(crate) fn get_type(&self) -> CandleType {
         match self.open < self.close {
             true => CandleType::Bullish,
             false => CandleType::Bearish,
@@ -42,6 +54,7 @@ pub struct Chart {
     pub(crate) y_axis: YAxis,
     pub(crate) chart_data: Rc<RefCell<ChartData>>,
     pub(crate) info_bar: InfoBar,
+    pub(crate) volume_pane: VolumePane,
 }
 
 impl Chart {
@@ -51,27 +64,69 @@ impl Chart {
         let y_axis = YAxis::new(chart_data.clone());
         let info_bar = InfoBar::new("APPLE".to_string(), chart_data.clone());
 
+        let volume_pane = VolumePane::new(
+            chart_data.clone(),
+            (chart_data.borrow().terminal_size.1 / 6) as i64,
+        );
+
+        chart_data.borrow_mut().compute_height(&volume_pane);
+
         Chart {
             renderer,
             y_axis,
             chart_data,
             info_bar,
+            volume_pane,
         }
     }
 
+    /// Draws the chart by outputting multiples strings in the terminal.
     pub fn draw(&self) {
         self.renderer.render(self);
     }
 
+    /// Set the name of the chart in the info bar.
     pub fn set_name(&mut self, name: String) {
         self.info_bar.name = name;
     }
 
+    /// Set the color of the bearish candle
+    /// The default color is  (234, 74, 90).
     pub fn set_bear_color(&mut self, r: u8, g: u8, b: u8) {
         self.renderer.bearish_color = (r, g, b);
     }
 
+    /// Set the color of the bullish candle
+    /// The default color is  (52, 208, 88).
     pub fn set_bull_color(&mut self, r: u8, g: u8, b: u8) {
         self.renderer.bullish_color = (r, g, b);
     }
+
+    /// Sets the color of the volume when the candle is bearish.
+    /// The default color is  (234, 74, 90).
+    pub fn set_vol_bear_color(&mut self, r: u8, g: u8, b: u8) {
+        self.volume_pane.bearish_color = (r, g, b);
+    }
+
+    /// Sets the color of the volume when the candle is bullish.
+    /// The default color is  (52, 208, 88).
+    pub fn set_vol_bull_color(&mut self, r: u8, g: u8, b: u8) {
+        self.volume_pane.bullish_color = (r, g, b);
+    }
+
+    /// Hide or show the volume pane.
+    pub fn set_volume_pane_enabled(&mut self, enabled: bool) {
+        self.volume_pane.enabled = enabled;
+    }
+
+    /// Set the character for drawing the volume bars.
+    pub fn set_volume_pane_unicode_fill(&mut self, unicode_fill: char) {
+        self.volume_pane.unicode_fill = unicode_fill;
+    }
+
+    /// Set the volume pane height.
+    /// Default is 1/6 of the terminal height.
+    pub fn set_volume_pane_height(&mut self, height: i64) {
+        self.volume_pane.height = height;
+    }
 }
diff --git a/src/chart_data.rs b/src/chart_data.rs
@@ -1,6 +1,6 @@
 use crate::{
     candle_set::CandleSet, chart::Candle, chart_renderer::ChartRenderer, info_bar::InfoBar,
-    y_axis::YAxis,
+    volume_pane::VolumePane, y_axis::YAxis,
 };
 use terminal_size::terminal_size;
 
@@ -20,13 +20,26 @@ impl ChartData {
             main_candle_set: CandleSet::new(candles),
             visible_candle_set: CandleSet::new(Vec::new()),
             terminal_size: (w.0, h.0),
-            height: h.0 as i64 - ChartRenderer::MARGIN_TOP - InfoBar::HEIGHT,
+            height: h.0 as i64,
         };
 
         chart_data.compute_visible_candles();
         chart_data
     }
 
+    pub fn compute_height(&mut self, volume_pane: &VolumePane) {
+        let volume_pane_height = if volume_pane.enabled {
+            volume_pane.height
+        } else {
+            0
+        };
+
+        self.height = self.terminal_size.1 as i64
+            - ChartRenderer::MARGIN_TOP
+            - InfoBar::HEIGHT
+            - volume_pane_height;
+    }
+
     pub fn compute_visible_candles(&mut self) {
         let term_width = self.terminal_size.0 as usize as i64;
         let nb_candles = self.main_candle_set.candles.len();
diff --git a/src/chart_renderer.rs b/src/chart_renderer.rs
@@ -24,8 +24,8 @@ impl ChartRenderer {
         control::set_virtual_terminal(true).unwrap();
 
         ChartRenderer {
-            bearish_color: (52, 208, 88),
-            bullish_color: (234, 74, 90),
+            bullish_color: (52, 208, 88),
+            bearish_color: (234, 74, 90),
         }
     }
 
@@ -88,6 +88,10 @@ impl ChartRenderer {
     pub fn render(&self, chart: &Chart) {
         let mut output_str = "".to_owned();
 
+        let mut chart_data = chart.chart_data.borrow_mut();
+        chart_data.compute_height(&chart.volume_pane);
+        drop(chart_data);
+
         let chart_data = chart.chart_data.borrow();
 
         for y in (1..chart_data.height as u16).rev() {
@@ -100,6 +104,18 @@ impl ChartRenderer {
             }
         }
 
+        if chart.volume_pane.enabled {
+            for y in (1..chart.volume_pane.height + 1).rev() {
+                output_str += "\n";
+
+                output_str += &chart.y_axis.render_empty();
+
+                for candle in chart_data.visible_candle_set.candles.iter() {
+                    output_str += &chart.volume_pane.render(candle, y);
+                }
+            }
+        }
+
         output_str += &chart.info_bar.render();
 
         println!("{}", output_str)
diff --git a/src/info_bar.rs b/src/info_bar.rs
@@ -36,15 +36,22 @@ impl InfoBar {
         }
         .to_string();
 
+        let variation_output = if main_set.variation > 0.0 {
+            ("↖", "green")
+        } else {
+            ("↙", "red")
+        };
+
         output_str += &format!(
-            "{:>width$} | Price: {price} | Highest: {high} | Lowest: {low} | Var.: {var} | Avg.: {avg} │",
+            "{:>width$} | Price: {price} | Highest: {high} | Lowest: {low} | Var.: {var} | Avg.: {avg} │ Cum. Vol: {vol}",
             &self.name,
             width = YAxis::WIDTH as usize + 3,
-            high = format!("{:.2}", main_set.max_value).green().bold(),
-            low = format!("{:.2}", main_set.min_value).red().bold(),
-            var = format!("↗ {:>+.2}%", main_set.variation).green().bold(),
+            high = format!("{:.2}", main_set.max_price).green().bold(),
+            low = format!("{:.2}", main_set.min_price).red().bold(),
+            var = format!("{} {:>+.2}%", variation_output.0, main_set.variation).color(variation_output.1).bold(),
             avg = avg_format,
             price = format!("{:.2}", main_set.last_price).green().bold(),
+            vol = format!("{:.0}", main_set.cumulative_volume).green().bold(),
         );
 
         output_str
diff --git a/src/lib.rs b/src/lib.rs
diff --git a/src/volume_pane.rs b/src/volume_pane.rs
diff --git a/src/y_axis.rs b/src/y_axis.rs
