[Feat] add --highlight-range option (#35)

Author: mistricky

cli/src/code.rs

@@ -15,13 +15,15 @@ use crate::{range::Range, CLI, STDIN_CODE_DEFAULT_CHAR};
 
 pub fn create_code(cli: &CLI, config_code: Code) -> anyhow::Result<Code> {
     let range = Range::from_opt_string(cli.range.clone())?;
-    let code_snippet = range.cut_code_snippet(get_code_snippet(cli)?)?;
+    let code_snippet = get_code_snippet(cli)?;
+    let parsed_range = range.parse_range(&code_snippet)?;
+    let parsed_code_snippet = parsed_range.cut_code_snippet(&code_snippet)?;
     let mut code_builder = CodeBuilder::from_code(config_code.clone());
-    let mut code = code_builder.content(&code_snippet).build()?;
+    let mut code = code_builder.content(&parsed_code_snippet).build()?;
 
     code.line_number = cli.has_line_number.then(|| {
         LineNumberBuilder::default()
-            .start_number(range.0.parse::<u32>().unwrap_or(1))
+            .start_number(parsed_range.0 as u32)
             .color(cli.line_number_color.clone())
             .build()
             .unwrap()
@@ -34,22 +36,38 @@ pub fn create_code(cli: &CLI, config_code: Code) -> anyhow::Result<Code> {
     code.file_path = cli.from_file.clone().or(config_code.file_path);
     code.language = cli.language.clone().or(config_code.language);
     code.breadcrumbs = create_breadcrumbs(&cli).or(config_code.breadcrumbs);
-    code.highlight_lines = create_highlight_lines(&cli)?;
+    code.highlight_lines = create_highlight_lines(&cli, &code_snippet)?;
 
     Ok(code)
 }
 
-fn create_highlight_lines(cli: &CLI) -> Result<Vec<HighlightLine>, serde_json::Error> {
-    match cli.highlight_lines {
-        Some(ref highlight_lines) => serde_json::from_str::<Vec<HighlightLine>>(highlight_lines),
-        None => Ok(vec![]),
+fn create_highlight_lines(cli: &CLI, code_snippet: &str) -> anyhow::Result<Vec<HighlightLine>> {
+    if let Some(ref raw_highlight_lines) = cli.raw_highlight_lines {
+        let highlight_lines = serde_json::from_str::<Vec<HighlightLine>>(raw_highlight_lines)?;
+
+        return Ok(highlight_lines);
     }
+
+    let highlight_lines = match cli.highlight_range {
+        Some(ref highlight_range) => {
+            let Range(start, end) = Range::from_str(&highlight_range)?.parse_range(code_snippet)?;
+
+            vec![HighlightLine::Range(
+                start as u32,
+                end as u32,
+                cli.highlight_range_color.clone(),
+            )]
+        }
+        None => vec![],
+    };
+
+    Ok(highlight_lines)
 }
 
 fn create_breadcrumbs(cli: &CLI) -> Option<Breadcrumbs> {
     cli.has_breadcrumbs.then(|| Breadcrumbs {
         separator: cli.breadcrumbs_separator.clone(),
-        font_family: cli.breadcrumbs_font_family.clone(),
+        font_family: Some(cli.breadcrumbs_font_family.clone()),
         color: cli
             .breadcrumbs_color
             .clone()

cli/src/main.rs

@@ -86,8 +86,8 @@ struct CLI {
     breadcrumbs_separator: Option<String>,
 
     /// Breadcrumbs font family
-    #[arg(long)]
-    breadcrumbs_font_family: Option<String>,
+    #[arg(long, default_value = "CaskaydiaCove Nerd Font")]
+    breadcrumbs_font_family: String,
 
     /// Breadcrumbs font color
     #[arg(long)]
@@ -101,6 +101,15 @@ struct CLI {
     #[arg(long, default_value = "#495162")]
     line_number_color: String,
 
+    /// Convenient version of `--raw-highlight-lines` option, you can set the highlight range
+    /// with a simple syntax, for example, highlight the 3rd to 5th lines:
+    /// 3:5
+    #[arg(long)]
+    highlight_range: Option<String>,
+
+    #[arg(long, default_value = "#ffffff10")]
+    highlight_range_color: String,
+
     /// CodeSnap allows users to highlight multiple lines with custom highlight color in the code snippet
     /// The content of highlight_lines is JSON string, for example highlight the first line and the
     /// 3rd to 5th lines:
@@ -110,7 +119,7 @@ struct CLI {
     /// ]"
     ///
     #[arg(long)]
-    highlight_lines: Option<String>,
+    raw_highlight_lines: Option<String>,
 
     /// Set the language of the code snippet, If you using the `file` option, CodeSnap will
     /// automatically detect the language from the file extension.

cli/src/range.rs

@@ -5,9 +5,9 @@ use anyhow::bail;
 const RANGE_SEPARATOR: &'static str = ":";
 pub const DEFAULT_RANGE: &'static str = "start:end";
 
-pub struct Range(pub String, pub String);
+pub struct Range<T>(pub T, pub T);
 
-impl Range {
+impl Range<String> {
     // Prepare range string by following rules:
     //
     // If raw_range is equal to "n:", which means x:end
@@ -30,20 +30,22 @@ impl Range {
         let range = Range::prepare_range(range_str);
         let range_points = range.split(RANGE_SEPARATOR).collect::<Vec<_>>();
 
-        if range_points.len() != 2 {
+        // When range is in format "start:end", the length of range_points is 2
+        // When range is in format "line_number", the length of range_points is 1
+        if range_points.len() != 2 && range_points.len() != 1 {
             bail!("Invalid range format");
         }
 
-        Ok(Range(
-            range_points[0].to_string(),
-            range_points[1].to_string(),
-        ))
+        let start = range_points[0].to_string();
+        let end = range_points.get(1).unwrap_or(&start.as_str()).to_string();
+
+        Ok(Range(start, end))
     }
 
     // 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)> {
+    pub fn parse_range(&self, code_snippet: &str) -> anyhow::Result<Range<usize>> {
         let Range(start, end) = self;
-        let lines = code_snippet_lines.clone().collect::<Vec<&str>>();
+        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 {
@@ -52,15 +54,17 @@ impl Range {
             (start, end)
         };
 
-        Ok(points)
+        Ok(Range(points.0, points.1))
     }
+}
 
-    pub fn cut_code_snippet(&self, code_snippet: String) -> anyhow::Result<String> {
+impl Range<usize> {
+    pub fn cut_code_snippet(&self, code_snippet: &str) -> anyhow::Result<String> {
+        let Range(start, end) = self;
         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)
+            .skip(start - 1)
+            .take((end + 1) - start)
             .collect::<Vec<&str>>()
             .join("\n");