jscpd-rs 0.1.0

package/src/report/xcode.rs

@@ -0,0 +1,90 @@
+use super::source::absolute_report_path;
+use crate::cli::Options;
+use crate::detector::{CloneMatch, DetectionResult};
+
+pub(super) fn write(result: &DetectionResult, options: &Options) {
+    for clone in &result.clones {
+        println!("{}", XcodeWarning::from_clone(clone, options));
+    }
+    println!("Found {} clones.", result.clones.len());
+}
+
+struct XcodeWarning {
+    message: String,
+}
+
+impl XcodeWarning {
+    fn from_clone(clone: &CloneMatch, options: &Options) -> Self {
+        let start_line_a = clone.duplication_a.start.line;
+        let end_line_a = clone.duplication_a.end.line;
+        let path_a = absolute_report_path(&clone.duplication_a.source_id);
+        let path_b = if options.absolute {
+            absolute_report_path(&clone.duplication_b.source_id)
+        } else {
+            clone.duplication_b.source_id.clone()
+        };
+
+        Self {
+            message: format!(
+                "{}:{}:{}: warning: Found {} lines ({}-{}) duplicated on file {} ({}-{})",
+                path_a,
+                start_line_a,
+                clone.duplication_a.start.column,
+                end_line_a.saturating_sub(start_line_a),
+                start_line_a,
+                end_line_a,
+                path_b,
+                clone.duplication_b.start.line,
+                clone.duplication_b.end.line,
+            ),
+        }
+    }
+}
+
+impl std::fmt::Display for XcodeWarning {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::report::test_support::make_test_clone;
+
+    #[test]
+    fn xcode_warning_matches_upstream_shape() {
+        let options = Options::default();
+        let clone = make_test_clone("src/a.js", "src/b.js");
+        let warning = XcodeWarning::from_clone(&clone, &options).to_string();
+        let expected_prefix = std::env::current_dir()
+            .unwrap()
+            .join("src/a.js")
+            .display()
+            .to_string();
+
+        assert_eq!(
+            warning,
+            format!(
+                "{expected_prefix}:2:3: warning: Found 3 lines (2-5) duplicated on file src/b.js (8-11)"
+            )
+        );
+    }
+
+    #[test]
+    fn xcode_warning_respects_absolute_second_path() {
+        let options = Options {
+            absolute: true,
+            ..Options::default()
+        };
+        let clone = make_test_clone("src/a.js", "src/b.js");
+        let warning = XcodeWarning::from_clone(&clone, &options).to_string();
+        let expected_second = std::env::current_dir()
+            .unwrap()
+            .join("src/b.js")
+            .display()
+            .to_string();
+
+        assert!(warning.ends_with(&format!("duplicated on file {expected_second} (8-11)")));
+    }
+}

package/src/report/xml.rs

@@ -0,0 +1,119 @@
+use anyhow::Result;
+
+use super::escape::escape_xml;
+use super::file_output::write_file_report;
+use super::source::clone_fragment;
+use crate::cli::Options;
+use crate::detector::{CloneMatch, DetectionResult};
+
+pub(super) fn write(result: &DetectionResult, options: &Options) -> Result<()> {
+    let xml = XmlReport::from_detection(result).to_string();
+    write_file_report(options, "jscpd-report.xml", "XML report", xml)
+}
+
+struct XmlReport {
+    duplications: Vec<XmlDuplication>,
+}
+
+struct XmlDuplication {
+    lines: usize,
+    first_file: XmlFile,
+    second_file: XmlFile,
+    fragment: String,
+}
+
+struct XmlFile {
+    path: String,
+    line: usize,
+    fragment: String,
+}
+
+impl XmlReport {
+    fn from_detection(result: &DetectionResult) -> Self {
+        Self {
+            duplications: result
+                .clones
+                .iter()
+                .map(|clone| XmlDuplication::from_clone(clone, result))
+                .collect(),
+        }
+    }
+}
+
+impl XmlDuplication {
+    fn from_clone(clone: &CloneMatch, result: &DetectionResult) -> Self {
+        let first_fragment = clone_fragment(result, &clone.duplication_a);
+        let second_fragment = clone_fragment(result, &clone.duplication_b);
+
+        Self {
+            lines: clone
+                .duplication_a
+                .end
+                .line
+                .saturating_sub(clone.duplication_a.start.line),
+            first_file: XmlFile {
+                path: escape_xml(&clone.duplication_a.source_id),
+                line: clone.duplication_a.start.line,
+                fragment: first_fragment.clone(),
+            },
+            second_file: XmlFile {
+                path: escape_xml(&clone.duplication_b.source_id),
+                line: clone.duplication_b.start.line,
+                fragment: second_fragment,
+            },
+            fragment: first_fragment,
+        }
+    }
+}
+
+impl std::fmt::Display for XmlReport {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, r#"<?xml version="1.0" encoding="UTF-8" ?><pmd-cpd>"#)?;
+        for duplication in &self.duplications {
+            write!(
+                f,
+                "\n      <duplication lines=\"{}\">\n            <file path=\"{}\" line=\"{}\">\n              <codefragment><![CDATA[{}]]></codefragment>\n            </file>\n            <file path=\"{}\" line=\"{}\">\n              <codefragment><![CDATA[{}]]></codefragment>\n            </file>\n            <codefragment><![CDATA[{}]]></codefragment>\n        </duplication>\n      ",
+                duplication.lines,
+                duplication.first_file.path,
+                duplication.first_file.line,
+                cdata_fragment(&duplication.first_file.fragment),
+                duplication.second_file.path,
+                duplication.second_file.line,
+                cdata_fragment(&duplication.second_file.fragment),
+                cdata_fragment(&duplication.fragment),
+            )?;
+        }
+        write!(f, "</pmd-cpd>")
+    }
+}
+
+fn cdata_fragment(value: &str) -> String {
+    value.replacen("]]>", "CDATA_END", 1)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::report::test_support::{make_test_result_with_clone, write_test_report};
+
+    #[test]
+    fn xml_report_matches_upstream_pmd_cpd_shape() {
+        let result = make_test_result_with_clone("src/a<&>.js", "src/b.js");
+        let xml = XmlReport::from_detection(&result).to_string();
+
+        assert!(xml.starts_with(r#"<?xml version="1.0" encoding="UTF-8" ?><pmd-cpd>"#));
+        assert!(xml.ends_with("</pmd-cpd>"));
+        assert!(xml.contains(r#"<duplication lines="3">"#));
+        assert!(xml.contains(r#"<file path="src/a&lt;&amp;&gt;.js" line="2">"#));
+        assert!(xml.contains("<![CDATA[alpha <beta> CDATA_END\n]]>"));
+        assert!(xml.contains(r#"<file path="src/b.js" line="8">"#));
+    }
+
+    #[test]
+    fn write_reports_writes_xml_report() {
+        let xml = write_test_report("xml", "xml-report", &["jscpd-report.xml"]);
+
+        assert!(xml.contains("<pmd-cpd>"));
+        assert!(xml.contains(r#"<file path="src/a.js" line="2">"#));
+    }
+}

package/src/report.rs

@@ -0,0 +1,250 @@
+use anyhow::{Result, bail};
+
+use crate::cli::Options;
+use crate::detector::DetectionResult;
+
+mod ai;
+mod badge;
+mod console;
+mod console_common;
+mod console_full;
+mod csv;
+mod escape;
+mod file_output;
+mod html;
+mod json;
+mod markdown;
+mod sarif;
+mod silent;
+mod source;
+mod summary;
+#[cfg(test)]
+mod test_support;
+mod threshold;
+mod xcode;
+mod xml;
+
+pub use threshold::ThresholdExceeded;
+
+pub fn write_reports(result: &DetectionResult, options: &Options) -> Result<()> {
+    for reporter in &options.reporters {
+        if options.output_is_bare
+            && let Some(message) = bare_output_error(reporter)
+        {
+            bail!("{message}");
+        }
+        match reporter.as_str() {
+            "console" if !options.silent => console::write(result, options),
+            "consoleFull" => console_full::write(result, options),
+            "ai" => ai::write(result, options),
+            "json" => json::write(result, options)?,
+            "csv" => csv::write(result, options)?,
+            "badge" => badge::write(result, options)?,
+            "html" => html::write(result, options)?,
+            "markdown" => markdown::write(result, options)?,
+            "xml" => xml::write(result, options)?,
+            "sarif" => sarif::write(result, options)?,
+            "xcode" => xcode::write(result, options),
+            "silent" => silent::write(result),
+            "threshold" => threshold::write(result, options)?,
+            _ => {}
+        }
+    }
+    Ok(())
+}
+
+pub fn write_unknown_reporter_warnings(options: &Options) {
+    for message in unknown_reporter_messages(options) {
+        println!("{message}");
+    }
+}
+
+pub fn write_progress(result: &DetectionResult, options: &Options) {
+    if !should_write_progress(options) {
+        return;
+    }
+    print!("{}", progress_output(result, options));
+}
+
+fn should_write_progress(options: &Options) -> bool {
+    !options.silent && !options.reporters.iter().any(|reporter| reporter == "ai")
+}
+
+fn progress_output(result: &DetectionResult, options: &Options) -> String {
+    let mut output = String::new();
+    for clone in &result.clones {
+        output.push_str(&console_common::clone_header(clone, options));
+        output.push('\n');
+    }
+    output
+}
+
+fn is_builtin_reporter(reporter: &str) -> bool {
+    matches!(
+        reporter,
+        "ai" | "xml"
+            | "json"
+            | "csv"
+            | "markdown"
+            | "consoleFull"
+            | "html"
+            | "console"
+            | "silent"
+            | "threshold"
+            | "xcode"
+            | "sarif"
+            | "badge"
+    )
+}
+
+fn bare_output_error(reporter: &str) -> Option<&'static str> {
+    match reporter {
+        "json" | "csv" | "markdown" | "xml" => Some(
+            "TypeError [ERR_INVALID_ARG_TYPE]: The \"path\" argument must be of type string or an instance of Buffer or URL. Received type boolean (true)",
+        ),
+        "sarif" | "badge" | "html" => Some(
+            "TypeError [ERR_INVALID_ARG_TYPE]: The \"path\" argument must be of type string. Received type boolean (true)",
+        ),
+        _ => None,
+    }
+}
+
+fn unknown_reporter_messages(options: &Options) -> Vec<String> {
+    options
+        .reporters
+        .iter()
+        .filter(|reporter| !is_builtin_reporter(reporter))
+        .flat_map(|reporter| {
+            [
+                format!(
+                    "warning: {reporter} not installed (install packages named @jscpd/{reporter}-reporter or jscpd-{reporter}-reporter)"
+                ),
+                format!("Cannot find module 'jscpd-{reporter}-reporter'"),
+            ]
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn recognizes_builtin_reporters() {
+        for reporter in [
+            "ai",
+            "xml",
+            "json",
+            "csv",
+            "markdown",
+            "consoleFull",
+            "html",
+            "console",
+            "silent",
+            "threshold",
+            "xcode",
+            "sarif",
+            "badge",
+        ] {
+            assert!(is_builtin_reporter(reporter), "{reporter}");
+        }
+        assert!(!is_builtin_reporter("badgezz"));
+    }
+
+    #[test]
+    fn warns_for_unknown_reporters_like_upstream() {
+        let options = Options {
+            reporters: vec![
+                "json".to_string(),
+                "badgezz".to_string(),
+                "console".to_string(),
+            ],
+            silent: true,
+            ..Options::default()
+        };
+
+        assert_eq!(
+            unknown_reporter_messages(&options),
+            vec![
+                "warning: badgezz not installed (install packages named @jscpd/badgezz-reporter or jscpd-badgezz-reporter)",
+                "Cannot find module 'jscpd-badgezz-reporter'",
+            ]
+        );
+    }
+
+    #[test]
+    fn bare_output_fails_for_file_reporters_like_upstream() {
+        let result = test_support::make_test_result_with_clone("src/a.js", "src/b.js");
+        for (reporter, expected) in [
+            (
+                "json",
+                "TypeError [ERR_INVALID_ARG_TYPE]: The \"path\" argument must be of type string or an instance of Buffer or URL. Received type boolean (true)",
+            ),
+            (
+                "sarif",
+                "TypeError [ERR_INVALID_ARG_TYPE]: The \"path\" argument must be of type string. Received type boolean (true)",
+            ),
+        ] {
+            let options = Options {
+                reporters: vec![reporter.to_string()],
+                output_is_bare: true,
+                ..Options::default()
+            };
+
+            let error = write_reports(&result, &options).unwrap_err();
+
+            assert_eq!(error.to_string(), expected, "{reporter}");
+        }
+    }
+
+    #[test]
+    fn warns_for_duplicate_unknown_reporters_in_order() {
+        let options = Options {
+            reporters: vec![
+                "badgezz".to_string(),
+                "myreport".to_string(),
+                "badgezz".to_string(),
+            ],
+            silent: true,
+            ..Options::default()
+        };
+
+        assert_eq!(
+            unknown_reporter_messages(&options),
+            vec![
+                "warning: badgezz not installed (install packages named @jscpd/badgezz-reporter or jscpd-badgezz-reporter)",
+                "Cannot find module 'jscpd-badgezz-reporter'",
+                "warning: myreport not installed (install packages named @jscpd/myreport-reporter or jscpd-myreport-reporter)",
+                "Cannot find module 'jscpd-myreport-reporter'",
+                "warning: badgezz not installed (install packages named @jscpd/badgezz-reporter or jscpd-badgezz-reporter)",
+                "Cannot find module 'jscpd-badgezz-reporter'",
+            ]
+        );
+    }
+
+    #[test]
+    fn progress_prints_clone_headers_when_not_silent_or_ai() {
+        let result = test_support::make_test_result_with_clone("src/a.js", "src/b.js");
+        let options = Options::default();
+
+        let output = progress_output(&result, &options);
+
+        assert!(output.contains("Clone found (javascript):"));
+        assert!(output.contains("src/a.js"));
+    }
+
+    #[test]
+    fn progress_is_suppressed_for_silent_and_ai_reports_like_upstream() {
+        let silent = Options {
+            silent: true,
+            ..Options::default()
+        };
+        let ai = Options {
+            reporters: vec!["ai".to_string()],
+            ..Options::default()
+        };
+
+        assert!(!should_write_progress(&silent));
+        assert!(!should_write_progress(&ai));
+    }
+}