jscpd-rs 0.1.0

package/src/report/sarif.rs

@@ -0,0 +1,302 @@
+use std::collections::HashMap;
+
+use anyhow::Result;
+use serde::Serialize;
+
+use super::file_output::write_file_report;
+use super::source::source_location;
+use crate::cli::Options;
+use crate::detector::DetectionResult;
+
+pub(super) fn write(result: &DetectionResult, options: &Options) -> Result<()> {
+    let sarif = SarifReport::from_detection(result, options);
+    let json = serde_json::to_string(&sarif)?;
+    write_file_report(options, "jscpd-sarif.json", "SARIF report", json)
+}
+
+#[derive(Serialize)]
+struct SarifReport {
+    #[serde(rename = "$schema")]
+    schema: &'static str,
+    version: &'static str,
+    runs: Vec<SarifRun>,
+}
+
+#[derive(Serialize)]
+struct SarifRun {
+    tool: SarifTool,
+    results: Vec<SarifResult>,
+    artifacts: Vec<SarifArtifact>,
+}
+
+#[derive(Serialize)]
+struct SarifTool {
+    driver: SarifDriver,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct SarifDriver {
+    name: &'static str,
+    rules: Vec<SarifRule>,
+    version: &'static str,
+    information_uri: &'static str,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct SarifRule {
+    id: &'static str,
+    short_description: SarifMessage,
+    help_uri: &'static str,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct SarifResult {
+    level: &'static str,
+    message: SarifMessage,
+    rule_id: &'static str,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    locations: Vec<SarifLocation>,
+    rule_index: usize,
+}
+
+#[derive(Serialize)]
+struct SarifMessage {
+    text: String,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct SarifLocation {
+    physical_location: SarifPhysicalLocation,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct SarifPhysicalLocation {
+    artifact_location: SarifArtifactLocation,
+    region: SarifRegion,
+}
+
+#[derive(Serialize)]
+struct SarifArtifactLocation {
+    uri: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    index: Option<usize>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct SarifRegion {
+    start_line: usize,
+    start_column: usize,
+    end_line: usize,
+    end_column: usize,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct SarifArtifact {
+    source_language: String,
+    location: SarifArtifactLocation,
+}
+
+impl SarifReport {
+    fn from_detection(result: &DetectionResult, options: &Options) -> Self {
+        const URL: &str = "https://github.com/kucherenko/jscpd/";
+
+        let mut artifacts = Vec::new();
+        let mut artifact_indices = HashMap::new();
+        let mut results = Vec::new();
+
+        for clone in &result.clones {
+            let uri = clone.duplication_a.source_id.clone();
+            let artifact_index = *artifact_indices.entry(uri.clone()).or_insert_with(|| {
+                let index = artifacts.len();
+                artifacts.push(SarifArtifact {
+                    source_language: sarif_source_language(&clone.format),
+                    location: SarifArtifactLocation {
+                        uri: uri.clone(),
+                        index: None,
+                    },
+                });
+                index
+            });
+
+            results.push(SarifResult {
+                level: "warning",
+                message: SarifMessage {
+                    text: format!(
+                        "Clone detected in {}, - {}[{}] and {}[{}]",
+                        clone.format,
+                        clone.duplication_a.source_id,
+                        source_location(&clone.duplication_a.start, &clone.duplication_a.end),
+                        clone.duplication_b.source_id,
+                        source_location(&clone.duplication_b.start, &clone.duplication_b.end),
+                    ),
+                },
+                rule_id: "duplication",
+                locations: vec![SarifLocation {
+                    physical_location: SarifPhysicalLocation {
+                        artifact_location: SarifArtifactLocation {
+                            uri,
+                            index: Some(artifact_index),
+                        },
+                        region: SarifRegion {
+                            start_line: clone.duplication_a.start.line,
+                            start_column: clone.duplication_a.start.column,
+                            end_line: clone.duplication_a.end.line,
+                            end_column: clone.duplication_a.end.column,
+                        },
+                    },
+                }],
+                rule_index: 0,
+            });
+        }
+
+        if result.statistics.total.percentage >= options.threshold.unwrap_or(100.0) {
+            results.push(SarifResult {
+                level: "error",
+                message: SarifMessage {
+                    text: format!(
+                        "The duplication level ({}%) is bigger than threshold ({}%)",
+                        result.statistics.total.percentage,
+                        options
+                            .threshold
+                            .map(|threshold| threshold.to_string())
+                            .unwrap_or_else(|| "undefined".to_string()),
+                    ),
+                },
+                rule_id: "duplications-threshold",
+                locations: Vec::new(),
+                rule_index: 1,
+            });
+        }
+
+        Self {
+            schema: "http://json.schemastore.org/sarif-2.1.0.json",
+            version: "2.1.0",
+            runs: vec![SarifRun {
+                tool: SarifTool {
+                    driver: SarifDriver {
+                        name: "jscpd",
+                        rules: vec![
+                            SarifRule {
+                                id: "duplication",
+                                short_description: SarifMessage {
+                                    text: "Found code duplication".to_string(),
+                                },
+                                help_uri: URL,
+                            },
+                            SarifRule {
+                                id: "duplications-threshold",
+                                short_description: SarifMessage {
+                                    text: "Level of duplication is too high".to_string(),
+                                },
+                                help_uri: URL,
+                            },
+                        ],
+                        version: "4.2.4",
+                        information_uri: URL,
+                    },
+                },
+                results,
+                artifacts,
+            }],
+        }
+    }
+}
+
+fn sarif_source_language(format: &str) -> String {
+    match format {
+        "javascript" => "JavaScript".to_string(),
+        "typescript" => "TypeScript".to_string(),
+        "jsx" => "JSX".to_string(),
+        "tsx" => "TSX".to_string(),
+        "css" => "CSS".to_string(),
+        "html" | "markup" => "HTML".to_string(),
+        "json" => "JSON".to_string(),
+        "markdown" => "Markdown".to_string(),
+        "rust" => "Rust".to_string(),
+        "python" => "Python".to_string(),
+        "ruby" => "Ruby".to_string(),
+        "go" => "Go".to_string(),
+        "java" => "Java".to_string(),
+        "csharp" => "C#".to_string(),
+        "cpp" => "C++".to_string(),
+        "c" => "C".to_string(),
+        other => {
+            let mut chars = other.chars();
+            let Some(first) = chars.next() else {
+                return String::new();
+            };
+            format!("{}{}", first.to_uppercase(), chars.as_str())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::report::test_support::{make_test_result_with_clone, write_test_report};
+
+    #[test]
+    fn sarif_report_matches_upstream_shape() {
+        let result = make_test_result_with_clone("src/a.js", "src/b.js");
+        let report = SarifReport::from_detection(&result, &Options::default());
+        let json = serde_json::to_value(report).unwrap();
+
+        assert_eq!(
+            json["$schema"],
+            "http://json.schemastore.org/sarif-2.1.0.json"
+        );
+        assert_eq!(json["version"], "2.1.0");
+        assert_eq!(json["runs"][0]["tool"]["driver"]["name"], "jscpd");
+        assert_eq!(
+            json["runs"][0]["tool"]["driver"]["rules"][0]["id"],
+            "duplication"
+        );
+        assert_eq!(
+            json["runs"][0]["results"][0]["message"]["text"],
+            "Clone detected in javascript, - src/a.js[2:3 - 5:1] and src/b.js[8:1 - 11:1]"
+        );
+        assert_eq!(
+            json["runs"][0]["results"][0]["locations"][0]["physicalLocation"]["artifactLocation"]["index"],
+            0
+        );
+        assert_eq!(
+            json["runs"][0]["artifacts"][0]["sourceLanguage"],
+            "JavaScript"
+        );
+    }
+
+    #[test]
+    fn sarif_report_includes_threshold_result_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 {
+            threshold: Some(10.0),
+            ..Options::default()
+        };
+        let report = SarifReport::from_detection(&result, &options);
+        let json = serde_json::to_value(report).unwrap();
+
+        assert_eq!(json["runs"][0]["results"][1]["level"], "error");
+        assert_eq!(
+            json["runs"][0]["results"][1]["message"]["text"],
+            "The duplication level (25%) is bigger than threshold (10%)"
+        );
+        assert!(json["runs"][0]["results"][1]["locations"].is_null());
+    }
+
+    #[test]
+    fn write_reports_writes_sarif_report() {
+        let sarif = write_test_report("sarif", "sarif-report", &["jscpd-sarif.json"]);
+        let json: serde_json::Value = serde_json::from_str(&sarif).unwrap();
+
+        assert_eq!(json["version"], "2.1.0");
+        assert_eq!(json["runs"][0]["results"][0]["ruleId"], "duplication");
+    }
+}

package/src/report/silent.rs

@@ -0,0 +1,22 @@
+use super::summary::silent_summary;
+use crate::detector::DetectionResult;
+
+pub(super) fn write(result: &DetectionResult) {
+    println!("{}", silent_summary(result));
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::report::test_support::make_test_result_with_clone;
+
+    #[test]
+    fn silent_reporter_matches_upstream_summary_shape() {
+        let result = make_test_result_with_clone("src/a.js", "src/b.js");
+
+        assert_eq!(
+            silent_summary(&result),
+            "Duplications detection: Found 1 exact clones with 5(25%) duplicated lines in 2 (1 formats) files."
+        );
+    }
+}

package/src/report/source.rs

@@ -0,0 +1,38 @@
+use std::path::Path;
+
+use crate::detector::{DetectionResult, Fragment};
+use crate::tokenizer::Location;
+
+pub(super) fn slice_range(content: &str, range: [usize; 2]) -> String {
+    let start = range[0].min(content.len());
+    let end = range[1].min(content.len());
+    content.get(start..end).unwrap_or_default().to_string()
+}
+
+pub(super) fn clone_fragment(result: &DetectionResult, fragment: &Fragment) -> String {
+    result
+        .source_contents
+        .get(&fragment.source_id)
+        .map(|content| slice_range(content, fragment.range))
+        .unwrap_or_default()
+}
+
+pub(super) fn source_location(start: &Location, end: &Location) -> String {
+    format!(
+        "{}:{} - {}:{}",
+        start.line, start.column, end.line, end.column
+    )
+}
+
+pub(super) fn absolute_report_path(source_id: &str) -> String {
+    let path = Path::new(source_id);
+    if path.is_absolute() {
+        source_id.to_string()
+    } else {
+        std::env::current_dir()
+            .unwrap_or_else(|_| Path::new(".").to_path_buf())
+            .join(path)
+            .display()
+            .to_string()
+    }
+}

package/src/report/summary.rs

@@ -0,0 +1,50 @@
+use crate::detector::{DetectionResult, StatisticRow, Statistics};
+
+pub(super) fn summary_rows(statistics: &Statistics) -> Vec<[String; 7]> {
+    let mut rows = vec![summary_header_row()];
+    let mut formats = 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:", &statistics.total));
+    rows
+}
+
+fn summary_header_row() -> [String; 7] {
+    [
+        "Format".to_string(),
+        "Files analyzed".to_string(),
+        "Total lines".to_string(),
+        "Total tokens".to_string(),
+        "Clones found".to_string(),
+        "Duplicated lines".to_string(),
+        "Duplicated tokens".to_string(),
+    ]
+}
+
+pub(super) fn statistic_to_summary_row(format: &str, statistic: &StatisticRow) -> [String; 7] {
+    [
+        format.to_string(),
+        statistic.sources.to_string(),
+        statistic.lines.to_string(),
+        statistic.tokens.to_string(),
+        statistic.clones.to_string(),
+        format!("{} ({}%)", statistic.duplicated_lines, statistic.percentage),
+        format!(
+            "{} ({}%)",
+            statistic.duplicated_tokens, statistic.percentage_tokens
+        ),
+    ]
+}
+
+pub(super) fn silent_summary(result: &DetectionResult) -> String {
+    format!(
+        "Duplications detection: Found {} exact clones with {}({}%) duplicated lines in {} ({} formats) files.",
+        result.clones.len(),
+        result.statistics.total.duplicated_lines,
+        result.statistics.total.percentage,
+        result.statistics.total.sources,
+        result.statistics.formats.len(),
+    )
+}

package/src/report/test_support.rs

@@ -0,0 +1,133 @@
+use std::collections::{BTreeMap, HashMap};
+use std::path::PathBuf;
+
+use crate::cli::Options;
+use crate::detector::{
+    BlamedLine, CloneMatch, DetectionResult, FormatStatistic, Fragment, StatisticRow,
+};
+use crate::report::write_reports;
+use crate::tokenizer::Location;
+
+pub(super) fn make_test_statistics() -> crate::detector::Statistics {
+    let mut formats = HashMap::new();
+    formats.insert(
+        "javascript".to_string(),
+        FormatStatistic {
+            sources: HashMap::new(),
+            total: test_statistic_row(),
+        },
+    );
+    crate::detector::Statistics {
+        total: test_statistic_row(),
+        formats,
+    }
+}
+
+fn test_statistic_row() -> StatisticRow {
+    StatisticRow {
+        sources: 2,
+        lines: 20,
+        tokens: 100,
+        clones: 1,
+        duplicated_lines: 5,
+        duplicated_tokens: 30,
+        percentage: 25.0,
+        percentage_tokens: 30.0,
+        new_duplicated_lines: 0,
+        new_clones: 0,
+    }
+}
+
+pub(super) fn make_test_clone(source_a: &str, source_b: &str) -> CloneMatch {
+    CloneMatch {
+        format: "javascript".to_string(),
+        duplication_a: Fragment {
+            source_id: source_a.to_string(),
+            start: location(2, 3, 0),
+            end: location(5, 1, 18),
+            range: [0, 18],
+            blame: None,
+        },
+        duplication_b: Fragment {
+            source_id: source_b.to_string(),
+            start: location(8, 1, 0),
+            end: location(11, 1, 18),
+            range: [0, 18],
+            blame: None,
+        },
+        tokens: 6,
+    }
+}
+
+pub(super) fn make_test_result_with_clone(source_a: &str, source_b: &str) -> DetectionResult {
+    let mut source_contents = HashMap::new();
+    source_contents.insert(source_a.to_string(), "alpha <beta> ]]>\n".to_string());
+    source_contents.insert(source_b.to_string(), "alpha & beta\nxxxx\n".to_string());
+
+    DetectionResult {
+        clones: vec![make_test_clone(source_a, source_b)],
+        skipped_clones: Vec::new(),
+        statistics: make_test_statistics(),
+        sources: Vec::new(),
+        source_contents,
+    }
+}
+
+pub(super) fn temp_output(label: &str) -> PathBuf {
+    let nonce = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    std::env::temp_dir().join(format!("jscpd-rs-{label}-{}-{nonce}", std::process::id()))
+}
+
+pub(super) fn write_test_report(reporter: &str, label: &str, path: &[&str]) -> String {
+    let output = write_test_report_output(reporter, label);
+    let report_path = path
+        .iter()
+        .fold(output.clone(), |path, segment| path.join(segment));
+    let report = std::fs::read_to_string(report_path).unwrap();
+    let _ = std::fs::remove_dir_all(output);
+    report
+}
+
+pub(super) fn write_test_report_output(reporter: &str, label: &str) -> PathBuf {
+    let output = temp_output(label);
+    let options = Options {
+        output: output.clone(),
+        reporters: vec![reporter.to_string()],
+        silent: true,
+        ..Options::default()
+    };
+    let result = make_test_result_with_clone("src/a.js", "src/b.js");
+
+    write_reports(&result, &options).unwrap();
+    output
+}
+
+pub(super) fn single_line_blame(
+    line: &str,
+    rev: &str,
+    author: &str,
+    date: &str,
+) -> BTreeMap<String, BlamedLine> {
+    [(
+        line.to_string(),
+        BlamedLine {
+            rev: rev.to_string(),
+            author: author.to_string(),
+            date: date.to_string(),
+            line: line.to_string(),
+        },
+    )]
+    .into_iter()
+    .collect()
+}
+
+fn location(line: usize, column: usize, position: usize) -> Location {
+    Location {
+        line,
+        column,
+        position,
+    }
+}

package/src/report/threshold.rs

@@ -0,0 +1,76 @@
+use std::error::Error;
+use std::fmt;
+
+use anyhow::Result;
+
+use crate::cli::Options;
+use crate::detector::DetectionResult;
+
+pub(super) fn write(result: &DetectionResult, options: &Options) -> Result<()> {
+    let Some(threshold) = options.threshold else {
+        return Ok(());
+    };
+    if threshold < result.statistics.total.percentage {
+        return Err(ThresholdExceeded::new(format!(
+            "ERROR: jscpd found too many duplicates ({}%) over threshold ({}%)",
+            result.statistics.total.percentage, threshold,
+        ))
+        .into());
+    }
+    Ok(())
+}
+
+#[derive(Debug)]
+pub struct ThresholdExceeded {
+    message: String,
+}
+
+impl ThresholdExceeded {
+    fn new(message: String) -> Self {
+        Self { message }
+    }
+
+    pub fn message(&self) -> &str {
+        &self.message
+    }
+}
+
+impl fmt::Display for ThresholdExceeded {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str(&self.message)
+    }
+}
+
+impl Error for ThresholdExceeded {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::report::test_support::make_test_result_with_clone;
+    use crate::report::write_reports;
+
+    #[test]
+    fn threshold_reporter_uses_strictly_greater_percentage_like_upstream() {
+        let mut result = make_test_result_with_clone("src/a.js", "src/b.js");
+        result.statistics.total.percentage = 25.0;
+
+        let equal = Options {
+            threshold: Some(25.0),
+            reporters: vec!["threshold".to_string()],
+            ..Options::default()
+        };
+        assert!(write_reports(&result, &equal).is_ok());
+
+        let below = Options {
+            threshold: Some(24.9),
+            reporters: vec!["threshold".to_string()],
+            ..Options::default()
+        };
+        let error = write_reports(&result, &below).unwrap_err();
+        assert!(error.downcast_ref::<ThresholdExceeded>().is_some());
+        assert_eq!(
+            error.to_string(),
+            "ERROR: jscpd found too many duplicates (25%) over threshold (24.9%)"
+        );
+    }
+}