[Feat] add line number option (#33)

Author: mistricky

cli/src/code.rs

@@ -7,25 +7,25 @@ use std::{
 use anyhow::bail;
 use clap::CommandFactory;
 use codesnap::{
-    config::{Breadcrumbs, Code, CodeBuilder, HighlightLine},
+    config::{Breadcrumbs, Code, CodeBuilder, HighlightLine, LineNumberBuilder},
     utils::clipboard::Clipboard,
 };
 
-use crate::{
-    range::{cut_code_snippet_by_range, prepare_range},
-    CLI, STDIN_CODE_DEFAULT_CHAR,
-};
+use crate::{range::Range, CLI, STDIN_CODE_DEFAULT_CHAR};
 
 pub fn create_code(cli: &CLI, config_code: Code) -> anyhow::Result<Code> {
-    let code_snippet = cut_code_snippet_by_range(
-        &get_code_snippet(cli)?,
-        &cli.range
-            .clone()
-            .and_then(|range| Some(prepare_range(&range))),
-    )?;
+    let range = Range::from_opt_string(cli.range.clone())?;
+    let code_snippet = range.cut_code_snippet(get_code_snippet(cli)?)?;
     let mut code_builder = CodeBuilder::from_code(config_code.clone());
     let mut code = code_builder.content(&code_snippet).build()?;
 
+    code.line_number = cli.has_line_number.then(|| {
+        LineNumberBuilder::default()
+            .start_number(range.0.parse::<u32>().unwrap_or(1))
+            .color(cli.line_number_color.clone())
+            .build()
+            .unwrap()
+    });
     code.theme = cli.code_theme.clone().unwrap_or(config_code.theme);
     code.font_family = cli
         .code_font_family

cli/src/main.rs

@@ -77,6 +77,9 @@ struct CLI {
     #[arg(long)]
     has_breadcrumbs: bool,
 
+    #[arg(long)]
+    has_line_number: bool,
+
     /// Breadcrumbs separator is the character to separate the path in breadcrumbs
     /// Default is `/`
     #[arg(long)]

cli/src/range.rs

@@ -3,67 +3,77 @@ use std::str::Lines;
 use anyhow::bail;
 
 const RANGE_SEPARATOR: &'static str = ":";
-const DEFAULT_RANGE: &'static str = "start:end";
+pub const DEFAULT_RANGE: &'static str = "start:end";
 
-fn parse_range_point(point: &str, lines: &Vec<&str>) -> anyhow::Result<usize> {
-    let point = match point {
-        "start" => 0,
-        "end" => lines.len(),
-        _ => point.parse::<usize>()?,
-    };
+pub struct Range(pub String, pub String);
 
-    Ok(point)
-}
+impl Range {
+    // Prepare range string by following rules:
+    //
+    // If raw_range is equal to "n:", which means x:end
+    // If raw_range is equal to ":n", which means start:n
+    fn prepare_range(raw_range: &str) -> String {
+        if raw_range.starts_with(RANGE_SEPARATOR) {
+            format!("{}{}", "start", raw_range)
+        } else if raw_range.ends_with(RANGE_SEPARATOR) {
+            format!("{}{}", raw_range, "end")
+        } else {
+            raw_range.to_string()
+        }
+    }
+
+    pub fn from_opt_string(opt_str: Option<String>) -> anyhow::Result<Self> {
+        Range::from_str(&opt_str.unwrap_or(String::from(DEFAULT_RANGE)))
+    }
 
-pub fn cut_code_snippet_by_range(
-    code_snippet: &str,
-    range: &Option<String>,
-) -> anyhow::Result<String> {
-    let range = range.clone().unwrap_or(String::from(DEFAULT_RANGE));
-    let range_points = range.split(RANGE_SEPARATOR).collect::<Vec<_>>();
+    pub fn from_str(range_str: &str) -> anyhow::Result<Self> {
+        let range = Range::prepare_range(range_str);
+        let range_points = range.split(RANGE_SEPARATOR).collect::<Vec<_>>();
 
-    if range_points.len() != 2 {
-        bail!("Invalid range format");
+        if range_points.len() != 2 {
+            bail!("Invalid range format");
+        }
+
+        Ok(Range(
+            range_points[0].to_string(),
+            range_points[1].to_string(),
+        ))
     }
 
-    let code_snippet_lines = code_snippet.lines();
-    let (start, end) = parse_range(&range_points, &code_snippet_lines)?;
-    let code_snippet = code_snippet_lines
-        .skip(start)
-        .take(end - start)
-        .collect::<Vec<&str>>()
-        .join("\n");
+    // Parse "start" to 0, "end" to lines.len(), and other values to usize
+    fn parse_range(&self, code_snippet_lines: &Lines) -> anyhow::Result<(usize, usize)> {
+        let Range(start, end) = self;
+        let lines = code_snippet_lines.clone().collect::<Vec<&str>>();
+        let start = parse_range_point(&start, &lines)?;
+        let end = parse_range_point(&end, &lines)?;
+        let points = if start > end {
+            (end, start)
+        } else {
+            (start, end)
+        };
 
-    Ok(code_snippet)
-}
+        Ok(points)
+    }
 
-// Prepare range string by following rules:
-//
-// If raw_range is equal to "n:", which means x:end
-// If raw_range is equal to ":n", which means start:n
-pub fn prepare_range(raw_range: &str) -> String {
-    if raw_range.starts_with(RANGE_SEPARATOR) {
-        format!("{}{}", "start", raw_range)
-    } else if raw_range.ends_with(RANGE_SEPARATOR) {
-        format!("{}{}", raw_range, "end")
-    } else {
-        raw_range.to_string()
+    pub fn cut_code_snippet(&self, code_snippet: String) -> anyhow::Result<String> {
+        let code_snippet_lines = code_snippet.lines();
+        let (start, end) = self.parse_range(&code_snippet_lines)?;
+        let code_snippet = code_snippet_lines
+            .skip(start)
+            .take(end - start)
+            .collect::<Vec<&str>>()
+            .join("\n");
+
+        Ok(code_snippet)
     }
 }
 
-// Parse "start" to 0, "end" to lines.len(), and other values to usize
-pub fn parse_range(
-    range_points: &Vec<&str>,
-    code_snippet_lines: &Lines,
-) -> anyhow::Result<(usize, usize)> {
-    let lines = code_snippet_lines.clone().collect::<Vec<&str>>();
-    let start = parse_range_point(range_points[0], &lines)?;
-    let end = parse_range_point(range_points[1], &lines)?;
-    let points = if start > end {
-        (end, start)
-    } else {
-        (start, end)
+fn parse_range_point(point: &str, lines: &Vec<&str>) -> anyhow::Result<usize> {
+    let point = match point {
+        "start" => 1,
+        "end" => lines.len(),
+        _ => point.parse::<usize>()?,
     };
 
-    Ok(points)
+    Ok(point)
 }