jscpd-rs 0.1.0

package/src/report/badge.rs

@@ -0,0 +1,238 @@
+use std::path::PathBuf;
+
+use anyhow::Result;
+use serde_json::{Map, Value};
+
+use super::escape::escape_xml;
+use super::file_output::{ensure_output_dir, write_path};
+use crate::cli::Options;
+use crate::detector::DetectionResult;
+
+pub(super) fn write(result: &DetectionResult, options: &Options) -> Result<()> {
+    ensure_output_dir(options)?;
+    let path = badge_output_path(options);
+    let badge = BadgeReport::from_detection(result, options).to_string();
+    write_path(&path, "Badge", badge)
+}
+
+struct BadgeReport {
+    subject: String,
+    status: String,
+    color: String,
+}
+
+impl BadgeReport {
+    fn from_detection(result: &DetectionResult, options: &Options) -> Self {
+        let badge_options = badge_reporter_options(options);
+        Self {
+            subject: badge_option_str(badge_options, "subject")
+                .unwrap_or("Copy/Paste")
+                .to_string(),
+            status: badge_option_str(badge_options, "status")
+                .map(str::to_string)
+                .unwrap_or_else(|| format!("{}%", result.statistics.total.percentage)),
+            color: badge_option_color(badge_options)
+                .unwrap_or_else(|| badge_color(result, options).to_string()),
+        }
+    }
+}
+
+impl std::fmt::Display for BadgeReport {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let subject_width = text_width(&self.subject);
+        let status_width = text_width(&self.status);
+        let subject_rect_width = subject_width + 100;
+        let status_rect_width = status_width + 100;
+        let total_width = subject_rect_width + status_rect_width;
+        let display_width = total_width as f64 / 10.0;
+        let subject_text_x = 50;
+        let status_text_x = subject_rect_width + 45;
+        let subject_shadow_x = subject_text_x + 10;
+        let status_shadow_x = status_text_x + 10;
+        let subject = escape_xml(&self.subject);
+        let status = escape_xml(&self.status);
+        let color = escape_xml(&self.color);
+
+        write!(
+            f,
+            "<svg width=\"{display_width:.1}\" height=\"20\" viewBox=\"0 0 {total_width} 200\" xmlns=\"http://www.w3.org/2000/svg\" role=\"img\" aria-label=\"{subject}: {status}\">\n  <title>{subject}: {status}</title>\n  <linearGradient id=\"g\" x2=\"0\" y2=\"100%\">\n    <stop offset=\"0\" stop-opacity=\".1\" stop-color=\"#EEE\"/>\n    <stop offset=\"1\" stop-opacity=\".1\"/>\n  </linearGradient>\n  <mask id=\"m\"><rect width=\"{total_width}\" height=\"200\" rx=\"30\" fill=\"#FFF\"/></mask>\n  <g mask=\"url(#m)\">\n    <rect width=\"{subject_rect_width}\" height=\"200\" fill=\"#555\"/>\n    <rect width=\"{status_rect_width}\" height=\"200\" fill=\"{}\" x=\"{subject_rect_width}\"/>\n    <rect width=\"{total_width}\" height=\"200\" fill=\"url(#g)\"/>\n  </g>\n  <g aria-hidden=\"true\" fill=\"#fff\" text-anchor=\"start\" font-family=\"Verdana,DejaVu Sans,sans-serif\" font-size=\"110\">\n    <text x=\"{subject_shadow_x}\" y=\"148\" textLength=\"{subject_width}\" fill=\"#000\" opacity=\"0.25\">{subject}</text>\n    <text x=\"{subject_text_x}\" y=\"138\" textLength=\"{subject_width}\">{subject}</text>\n    <text x=\"{status_shadow_x}\" y=\"148\" textLength=\"{status_width}\" fill=\"#000\" opacity=\"0.25\">{status}</text>\n    <text x=\"{status_text_x}\" y=\"138\" textLength=\"{status_width}\">{status}</text>\n  </g>\n  \n</svg>",
+            color
+        )
+    }
+}
+
+fn badge_output_path(options: &Options) -> PathBuf {
+    badge_option_str(badge_reporter_options(options), "path")
+        .map(PathBuf::from)
+        .unwrap_or_else(|| options.output.join("jscpd-badge.svg"))
+}
+
+fn badge_reporter_options(options: &Options) -> Option<&Map<String, Value>> {
+    options
+        .reporters_options
+        .get("badge")
+        .and_then(Value::as_object)
+}
+
+fn badge_option_str<'a>(
+    badge_options: Option<&'a Map<String, Value>>,
+    key: &str,
+) -> Option<&'a str> {
+    badge_options?.get(key)?.as_str()
+}
+
+fn badge_option_color(badge_options: Option<&Map<String, Value>>) -> Option<String> {
+    let color = badge_option_str(badge_options, "color")?;
+    Some(
+        match color {
+            "green" => "#3C1",
+            "blue" => "#08C",
+            "red" => "#E43",
+            "yellow" => "#DB1",
+            "orange" => "#F73",
+            "purple" => "#94E",
+            "pink" => "#E5B",
+            "grey" | "gray" => "#999",
+            "cyan" => "#1BC",
+            "black" => "#2A2A2A",
+            _ => return Some(format!("#{color}")),
+        }
+        .to_string(),
+    )
+}
+
+fn badge_color(result: &DetectionResult, options: &Options) -> &'static str {
+    match options.threshold {
+        Some(threshold) if result.statistics.total.percentage < threshold => "#3C1",
+        Some(_) => "#E43",
+        None => "#999",
+    }
+}
+
+fn text_width(value: &str) -> usize {
+    value.chars().map(char_width).sum::<usize>() + 26
+}
+
+fn char_width(value: char) -> usize {
+    match value {
+        'A'..='Z' => 73,
+        'a'..='z' => 63,
+        '0'..='9' => 61,
+        '/' => 38,
+        '.' => 31,
+        '%' => 88,
+        ':' => 28,
+        ' ' => 35,
+        _ => 63,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::report::test_support::{make_test_result_with_clone, write_test_report};
+    use crate::report::write_reports;
+
+    #[test]
+    fn badge_color_matches_upstream_threshold_rules() {
+        let mut result = make_test_result_with_clone("src/a.js", "src/b.js");
+        result.statistics.total.percentage = 25.0;
+
+        assert_eq!(badge_color(&result, &Options::default()), "#999");
+        assert_eq!(
+            badge_color(
+                &result,
+                &Options {
+                    threshold: Some(25.1),
+                    ..Options::default()
+                }
+            ),
+            "#3C1"
+        );
+        assert_eq!(
+            badge_color(
+                &result,
+                &Options {
+                    threshold: Some(25.0),
+                    ..Options::default()
+                }
+            ),
+            "#E43"
+        );
+    }
+
+    #[test]
+    fn badge_report_matches_upstream_default_shape() {
+        let result = make_test_result_with_clone("src/a.js", "src/b.js");
+        let badge = BadgeReport::from_detection(&result, &Options::default()).to_string();
+
+        assert!(badge.starts_with("<svg "));
+        assert!(badge.contains(r#"role="img" aria-label="Copy/Paste: 25%""#));
+        assert!(badge.contains("<title>Copy/Paste: 25%</title>"));
+        assert!(badge.contains(r##"fill="#999""##));
+        assert!(badge.contains(">Copy/Paste</text>"));
+        assert!(badge.contains(">25%</text>"));
+    }
+
+    #[test]
+    fn badge_report_uses_reporter_options_like_upstream() {
+        let mut result = make_test_result_with_clone("src/a.js", "src/b.js");
+        result.statistics.total.percentage = 25.0;
+        let options = Options {
+            reporters_options: serde_json::json!({
+                "badge": {
+                    "subject": "Duplicates",
+                    "status": "blocked",
+                    "color": "purple"
+                }
+            })
+            .as_object()
+            .unwrap()
+            .clone(),
+            ..Options::default()
+        };
+
+        let badge = BadgeReport::from_detection(&result, &options).to_string();
+
+        assert!(badge.contains(r#"aria-label="Duplicates: blocked""#));
+        assert!(badge.contains(r##"fill="#94E""##));
+        assert!(badge.contains(">Duplicates</text>"));
+        assert!(badge.contains(">blocked</text>"));
+    }
+
+    #[test]
+    fn write_reports_writes_badge_report() {
+        let svg = write_test_report("badge", "badge-report", &["jscpd-badge.svg"]);
+
+        assert!(svg.contains("Copy/Paste"));
+        assert!(svg.contains("25%"));
+    }
+
+    #[test]
+    fn write_reports_uses_badge_reporter_path_option() {
+        let output = crate::report::test_support::temp_output("badge-path");
+        let badge_path = output.join("custom-badge.svg");
+        let options = Options {
+            output: output.clone(),
+            reporters: vec!["badge".to_string()],
+            reporters_options: serde_json::json!({
+                "badge": {
+                    "path": badge_path
+                }
+            })
+            .as_object()
+            .unwrap()
+            .clone(),
+            silent: true,
+            ..Options::default()
+        };
+        let result = make_test_result_with_clone("src/a.js", "src/b.js");
+
+        write_reports(&result, &options).unwrap();
+        let svg = std::fs::read_to_string(&badge_path).unwrap();
+        let _ = std::fs::remove_dir_all(output);
+
+        assert!(svg.contains("Copy/Paste"));
+        assert!(svg.contains("25%"));
+    }
+}

package/src/report/console.rs

@@ -0,0 +1,180 @@
+use super::console_common::{BOLD, GREY, RED, RESET_BOLD, RESET_COLOR};
+use super::summary::statistic_to_summary_row;
+use crate::cli::Options;
+use crate::detector::DetectionResult;
+
+const HEADERS: [&str; 7] = [
+    "Format",
+    "Files analyzed",
+    "Total lines",
+    "Total tokens",
+    "Clones found",
+    "Duplicated lines",
+    "Duplicated tokens",
+];
+
+pub(super) fn write(result: &DetectionResult, options: &Options) {
+    print!("{}", console_report(result, options));
+}
+
+fn console_report(result: &DetectionResult, _options: &Options) -> String {
+    let mut output = String::new();
+    output.push_str(&summary_table(result));
+    output.push_str(&format!(
+        "{GREY}Found {} clones.{RESET_COLOR}\n",
+        result.clones.len()
+    ));
+    output
+}
+
+fn summary_table(result: &DetectionResult) -> String {
+    let mut rows = Vec::new();
+    let mut formats = result.statistics.formats.iter().collect::<Vec<_>>();
+    formats.sort_by_key(|(format, _)| *format);
+
+    for (format, statistic) in formats {
+        rows.push(statistic_to_summary_row(format, &statistic.total));
+    }
+    rows.push(statistic_to_summary_row("Total:", &result.statistics.total));
+
+    let widths = column_widths(&rows);
+    let mut table = String::new();
+    table.push_str(&divider('┌', '┬', '┐', &widths));
+    table.push_str(&row(
+        &HEADERS.map(str::to_string),
+        &widths,
+        RowStyle::Header,
+    ));
+    table.push_str(&divider('├', '┼', '┤', &widths));
+    for (index, row_cells) in rows.iter().enumerate() {
+        let is_total = index + 1 == rows.len();
+        if is_total && index > 0 {
+            table.push_str(&divider('├', '┼', '┤', &widths));
+        }
+        table.push_str(&row(
+            row_cells,
+            &widths,
+            if is_total {
+                RowStyle::Total
+            } else {
+                RowStyle::Body
+            },
+        ));
+    }
+    table.push_str(&divider('└', '┴', '┘', &widths));
+    table
+}
+
+fn column_widths(rows: &[[String; 7]]) -> [usize; 7] {
+    let mut widths = HEADERS.map(str::len);
+    for row in rows {
+        for (idx, cell) in row.iter().enumerate() {
+            widths[idx] = widths[idx].max(cell.len());
+        }
+    }
+    widths
+}
+
+fn divider(left: char, middle: char, right: char, widths: &[usize; 7]) -> String {
+    let mut line = String::new();
+    line.push_str(GREY);
+    line.push(left);
+    for (idx, width) in widths.iter().enumerate() {
+        line.push_str(&"─".repeat(width + 2));
+        if idx + 1 == widths.len() {
+            line.push(right);
+        } else {
+            line.push(middle);
+        }
+    }
+    line.push_str(RESET_COLOR);
+    line.push('\n');
+    line
+}
+
+#[derive(Clone, Copy)]
+enum RowStyle {
+    Header,
+    Body,
+    Total,
+}
+
+fn row(cells: &[String; 7], widths: &[usize; 7], style: RowStyle) -> String {
+    let mut line = String::new();
+    line.push_str(GREY);
+    line.push('│');
+    line.push_str(RESET_COLOR);
+
+    for (idx, cell) in cells.iter().enumerate() {
+        let padded = format!(" {cell:<width$} ", width = widths[idx]);
+        match style {
+            RowStyle::Header => {
+                line.push_str(RED);
+                line.push_str(&padded);
+                line.push_str(RESET_COLOR);
+            }
+            RowStyle::Total if idx == 0 => {
+                line.push_str(BOLD);
+                line.push_str(&padded);
+                line.push_str(RESET_BOLD);
+            }
+            RowStyle::Total | RowStyle::Body => line.push_str(&padded),
+        }
+        line.push_str(GREY);
+        line.push('│');
+        line.push_str(RESET_COLOR);
+    }
+
+    line.push('\n');
+    line
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::report::test_support::{make_test_result_with_clone, make_test_statistics};
+
+    #[test]
+    fn console_report_matches_upstream_shape() {
+        let result = make_test_result_with_clone("src/a.js", "src/b.js");
+        let report = console_report(&result, &Options::default());
+
+        assert!(!report.contains("Clone found (javascript):"));
+        assert!(report.contains("Format"));
+        assert!(report.contains("Files analyzed"));
+        assert!(report.contains("javascript"));
+        assert!(report.contains("Total:"));
+        assert!(report.contains("Found 1 clones."));
+    }
+
+    #[test]
+    fn console_report_includes_zero_clone_table() {
+        let mut statistics = make_test_statistics();
+        statistics.total.clones = 0;
+        statistics.total.duplicated_lines = 0;
+        statistics.total.duplicated_tokens = 0;
+        statistics.total.percentage = 0.0;
+        statistics.total.percentage_tokens = 0.0;
+        for statistic in statistics.formats.values_mut() {
+            statistic.total.clones = 0;
+            statistic.total.duplicated_lines = 0;
+            statistic.total.duplicated_tokens = 0;
+            statistic.total.percentage = 0.0;
+            statistic.total.percentage_tokens = 0.0;
+        }
+        let result = DetectionResult {
+            clones: Vec::new(),
+            skipped_clones: Vec::new(),
+            statistics,
+            sources: Vec::new(),
+            source_contents: std::collections::HashMap::new(),
+        };
+
+        let report = console_report(&result, &Options::default());
+
+        assert!(!report.contains("Clone found ("));
+        assert!(report.contains("javascript"));
+        assert!(report.contains("0 (0%)"));
+        assert!(report.contains("Found 0 clones."));
+    }
+}

package/src/report/console_common.rs

@@ -0,0 +1,37 @@
+use super::source::source_location;
+use crate::cli::Options;
+use crate::detector::CloneMatch;
+
+pub(super) const BOLD: &str = "\x1b[1m";
+pub(super) const BOLD_GREEN: &str = "\x1b[1m\x1b[32m";
+pub(super) const GREY: &str = "\x1b[90m";
+pub(super) const RED: &str = "\x1b[31m";
+pub(super) const RESET_BOLD: &str = "\x1b[22m";
+pub(super) const RESET_COLOR: &str = "\x1b[39m";
+
+pub(super) fn clone_header(clone: &CloneMatch, _options: &Options) -> String {
+    let path_a = colored_path(&clone.duplication_a.source_id);
+    let path_b = colored_path(&clone.duplication_b.source_id);
+    format!(
+        "Clone found ({}):\n - {} [{}] ({} lines, {} tokens)\n   {} [{}]\n",
+        clone.format,
+        path_a,
+        source_location(&clone.duplication_a.start, &clone.duplication_a.end),
+        clone
+            .duplication_a
+            .end
+            .line
+            .saturating_sub(clone.duplication_a.start.line),
+        clone
+            .duplication_a
+            .end
+            .position
+            .saturating_sub(clone.duplication_a.start.position),
+        path_b,
+        source_location(&clone.duplication_b.start, &clone.duplication_b.end),
+    )
+}
+
+fn colored_path(path: &str) -> String {
+    format!("{BOLD_GREEN}{path}{RESET_COLOR}{RESET_BOLD}")
+}

package/src/report/console_full.rs

@@ -0,0 +1,139 @@
+use super::console_common::{GREY, RESET_COLOR, clone_header};
+use super::source::clone_fragment;
+use crate::cli::Options;
+use crate::detector::{CloneMatch, DetectionResult};
+
+pub(super) fn write(result: &DetectionResult, options: &Options) {
+    print!("{}", console_full_report(result, options));
+}
+
+fn console_full_report(result: &DetectionResult, options: &Options) -> String {
+    let mut output = String::new();
+    for clone in &result.clones {
+        output.push_str(&clone_header(clone, options));
+        output.push('\n');
+        output.push_str(&fragment_table(result, clone));
+        output.push('\n');
+    }
+    output.push_str(&format!(
+        "{GREY}Found {} clones.{RESET_COLOR}\n",
+        result.clones.len()
+    ));
+    output
+}
+
+fn fragment_table(result: &DetectionResult, clone: &CloneMatch) -> String {
+    let fragment = clone_fragment(result, &clone.duplication_a);
+    let lines = fragment.split('\n').collect::<Vec<_>>();
+    let max_line_a = clone.duplication_a.start.line + lines.len().saturating_sub(1);
+    let max_line_b = clone.duplication_b.start.line + lines.len().saturating_sub(1);
+    let width_a = max_line_a.to_string().len();
+    let width_b = max_line_b.to_string().len();
+    let mut output = String::new();
+
+    for (idx, line) in lines.iter().enumerate() {
+        if idx > 0 {
+            output.push('\n');
+        }
+        let line_a = clone.duplication_a.start.line + idx;
+        let line_b = clone.duplication_b.start.line + idx;
+        if let (Some(blame_a), Some(blame_b)) =
+            (&clone.duplication_a.blame, &clone.duplication_b.blame)
+        {
+            let key_a = line_a.to_string();
+            let key_b = line_b.to_string();
+            let author_a = blame_a
+                .get(&key_a)
+                .map(|line| line.author.as_str())
+                .unwrap_or("");
+            let author_b = blame_b
+                .get(&key_b)
+                .map(|line| line.author.as_str())
+                .unwrap_or("");
+            let date_cmp = blame_a
+                .get(&key_a)
+                .zip(blame_b.get(&key_b))
+                .map(|(left, right)| compare_dates(&left.date, &right.date))
+                .unwrap_or("");
+            output.push_str(&format!(
+                " {line_a:>width_a$} {GREY}│{RESET_COLOR} {author_a} {GREY}│{RESET_COLOR} {date_cmp} {GREY}│{RESET_COLOR} {line_b:<width_b$} {GREY}│{RESET_COLOR} {author_b} {GREY}│{RESET_COLOR} {GREY}{line}{RESET_COLOR} ",
+            ));
+        } else {
+            output.push_str(&format!(
+                " {line_a:>width_a$} {GREY}│{RESET_COLOR} {line_b:<width_b$} {GREY}│{RESET_COLOR} {GREY}{line}{RESET_COLOR} ",
+            ));
+        }
+    }
+
+    output.push('\n');
+    output
+}
+
+fn compare_dates(first: &str, second: &str) -> &'static str {
+    match first.cmp(second) {
+        std::cmp::Ordering::Less => "=>",
+        std::cmp::Ordering::Greater => "<=",
+        std::cmp::Ordering::Equal => "==",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::report::console_common::clone_header;
+    use crate::report::test_support::{make_test_result_with_clone, single_line_blame};
+
+    #[test]
+    fn console_full_header_matches_upstream_shape() {
+        let result = make_test_result_with_clone("src/a.js", "src/b.js");
+        let header = clone_header(&result.clones[0], &Options::default());
+
+        assert!(header.starts_with("Clone found (javascript):\n - "));
+        assert!(header.contains("src/a.js"));
+        assert!(header.contains("[2:3 - 5:1] (3 lines, 18 tokens)"));
+        assert!(header.contains("src/b.js"));
+        assert!(header.contains("[8:1 - 11:1]"));
+    }
+
+    #[test]
+    fn console_full_fragment_table_uses_source_fragment_lines() {
+        let result = make_test_result_with_clone("src/a.js", "src/b.js");
+        let table = fragment_table(&result, &result.clones[0]);
+
+        assert!(table.contains(" 2 "));
+        assert!(table.contains(" 8 "));
+        assert!(table.contains("alpha <beta> ]]>"));
+    }
+
+    #[test]
+    fn console_full_fragment_table_uses_blame_columns_when_available() {
+        let mut result = make_test_result_with_clone("src/a.js", "src/b.js");
+        result.clones[0].duplication_a.blame = Some(single_line_blame(
+            "2",
+            "a",
+            "Alice",
+            "2024-01-01 00:00:00 +0000",
+        ));
+        result.clones[0].duplication_b.blame = Some(single_line_blame(
+            "8",
+            "b",
+            "Bob",
+            "2024-01-02 00:00:00 +0000",
+        ));
+
+        let table = fragment_table(&result, &result.clones[0]);
+
+        assert!(table.contains("Alice"));
+        assert!(table.contains("Bob"));
+        assert!(table.contains("=>"));
+    }
+
+    #[test]
+    fn console_full_report_prints_final_clone_count() {
+        let result = make_test_result_with_clone("src/a.js", "src/b.js");
+        let report = console_full_report(&result, &Options::default());
+
+        assert!(report.contains("Clone found (javascript):"));
+        assert!(report.contains("Found 1 clones."));
+    }
+}

package/src/report/csv.rs

@@ -0,0 +1,65 @@
+use anyhow::Result;
+
+use super::file_output::write_file_report;
+use super::summary::summary_rows;
+use crate::cli::Options;
+use crate::detector::Statistics;
+
+pub(super) fn write(result: &crate::detector::DetectionResult, options: &Options) -> Result<()> {
+    let csv = CsvReport::from_statistics(&result.statistics).to_string();
+    write_file_report(options, "jscpd-report.csv", "CSV report", csv)
+}
+
+struct CsvReport {
+    rows: Vec<[String; 7]>,
+}
+
+impl CsvReport {
+    fn from_statistics(statistics: &Statistics) -> Self {
+        Self {
+            rows: summary_rows(statistics),
+        }
+    }
+}
+
+impl std::fmt::Display for CsvReport {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for (idx, row) in self.rows.iter().enumerate() {
+            if idx > 0 {
+                writeln!(f)?;
+            }
+            write!(f, "{}", row.join(","))?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::report::test_support::{make_test_statistics, write_test_report};
+
+    #[test]
+    fn csv_report_matches_upstream_summary_shape() {
+        let stats = make_test_statistics();
+        let report = CsvReport::from_statistics(&stats);
+        let csv = report.to_string();
+
+        assert_eq!(
+            csv,
+            [
+                "Format,Files analyzed,Total lines,Total tokens,Clones found,Duplicated lines,Duplicated tokens",
+                "javascript,2,20,100,1,5 (25%),30 (30%)",
+                "Total:,2,20,100,1,5 (25%),30 (30%)",
+            ]
+            .join("\n")
+        );
+    }
+
+    #[test]
+    fn write_reports_writes_csv_report() {
+        let csv = write_test_report("csv", "csv-report", &["jscpd-report.csv"]);
+
+        assert!(csv.starts_with("Format,Files analyzed,Total lines"));
+    }
+}

package/src/report/escape.rs

@@ -0,0 +1,8 @@
+pub(super) fn escape_xml(value: &str) -> String {
+    value
+        .replace('&', "&")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;")
+        .replace('\'', "&apos;")
+        .replace('"', "&quot;")
+}