jscpd-rs 0.1.0

package/src/report/file_output.rs

@@ -0,0 +1,28 @@
+use std::fs;
+use std::path::Path;
+
+use anyhow::{Context, Result};
+
+use crate::cli::Options;
+
+pub(super) fn ensure_output_dir(options: &Options) -> Result<()> {
+    fs::create_dir_all(&options.output)
+        .with_context(|| format!("failed to create output dir `{}`", options.output.display()))
+}
+
+pub(super) fn write_path(path: &Path, saved_prefix: &str, content: impl AsRef<[u8]>) -> Result<()> {
+    fs::write(path, content).with_context(|| format!("failed to write `{}`", path.display()))?;
+    println!("{saved_prefix} saved to {}", path.display());
+    Ok(())
+}
+
+pub(super) fn write_file_report(
+    options: &Options,
+    file_name: &str,
+    saved_prefix: &str,
+    content: impl AsRef<[u8]>,
+) -> Result<()> {
+    ensure_output_dir(options)?;
+    let path = options.output.join(file_name);
+    write_path(&path, saved_prefix, content)
+}

package/src/report/html/assets.rs

@@ -0,0 +1,47 @@
+pub(super) const TAILWIND_CSS: &str = r#"
+body { margin: 0; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: #f3f4f6; color: #1f2937; }
+.container { max-width: 1200px; margin: 0 auto; padding-left: 1rem; padding-right: 1rem; }
+header { background: #fff; box-shadow: 0 1px 3px rgb(0 0 0 / 0.12); padding: 1rem 0; }
+main { background: #fff; margin-top: 2rem; margin-bottom: 2rem; padding: 1rem; box-shadow: 0 1px 3px rgb(0 0 0 / 0.12); border-radius: 0.25rem; }
+h1 { margin: 0; font-size: 1.875rem; line-height: 2.25rem; font-weight: 600; }
+h2 { margin: 0 0 1rem; font-size: 1.5rem; line-height: 2rem; font-weight: 600; color: #374151; }
+h3 { margin: 0 0 0.5rem; font-size: 1.125rem; line-height: 1.75rem; font-weight: 600; }
+section { margin-bottom: 2rem; }
+table { width: 100%; border-collapse: collapse; }
+th { background: #e5e7eb; color: #4b5563; font-size: 0.875rem; line-height: 1.25rem; padding: 0.75rem 1.5rem; text-align: left; text-transform: uppercase; }
+td { border-bottom: 1px solid #e5e7eb; color: #1f2937; font-size: 0.875rem; line-height: 1.25rem; padding: 0.75rem 1.5rem; }
+a { color: #2563eb; text-decoration: none; }
+a:hover { text-decoration: underline; }
+button { background: #6b7280; border: 0; border-radius: 0.25rem; color: #fff; cursor: pointer; font-size: 0.75rem; line-height: 1rem; margin-left: 0.5rem; padding: 0.125rem 0.25rem; }
+pre { background: #f3f4f6; border: 1px solid #e5e7eb; border-radius: 0.25rem; margin-top: 0.5rem; overflow: auto; padding: 1rem; }
+code { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace; font-size: 0.875rem; line-height: 1.25rem; }
+.dashboard-grid { display: grid; gap: 1rem; grid-template-columns: repeat(4, minmax(0, 1fr)); }
+.card { border-radius: 0.25rem; padding: 1rem; text-align: center; }
+.card span { display: block; font-size: 2.25rem; line-height: 2.5rem; font-weight: 700; }
+.blue { background: #bfdbfe; color: #1e40af; }
+.green { background: #bbf7d0; color: #166534; }
+.yellow { background: #fef08a; color: #854d0e; }
+.red { background: #fecaca; color: #991b1b; }
+.clone { border-top: 1px solid #e5e7eb; padding: 1rem 0; }
+.clone:first-child { border-top: 0; }
+.clone p { margin: 0 0 0.5rem; color: #4b5563; }
+.hidden { display: none; }
+footer { margin-top: 60px; padding: 30px 0; border-top: 1px solid #e0e0e0; text-align: center; color: #666; }
+@media (max-width: 800px) {
+  .dashboard-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+  th, td { padding: 0.5rem; }
+}
+@media (max-width: 520px) {
+  .dashboard-grid { grid-template-columns: 1fr; }
+  main { margin-top: 1rem; }
+}
+"#;
+
+pub(super) const PRISM_CSS: &str = r#"
+pre[class*="language-"] { white-space: pre-wrap; word-break: break-word; }
+code[class*="language-"] { color: #111827; }
+"#;
+
+pub(super) const PRISM_JS: &str = r#"
+window.Prism = window.Prism || { highlightAll: function () {} };
+"#;

package/src/report/html.rs

@@ -0,0 +1,336 @@
+use std::collections::BTreeSet;
+use std::fs;
+use std::path::Path;
+
+use anyhow::{Context, Result};
+
+use super::json;
+use super::source::clone_fragment;
+use crate::cli::Options;
+use crate::detector::{CloneMatch, DetectionResult, StatisticRow};
+
+mod assets;
+
+const VERSION: &str = "4.2.4";
+
+pub(super) fn write(result: &DetectionResult, options: &Options) -> Result<()> {
+    let destination = options.output.join("html");
+    fs::create_dir_all(destination.join("styles")).with_context(|| {
+        format!(
+            "failed to create html styles dir `{}`",
+            destination.join("styles").display()
+        )
+    })?;
+    fs::create_dir_all(destination.join("js")).with_context(|| {
+        format!(
+            "failed to create html scripts dir `{}`",
+            destination.join("js").display()
+        )
+    })?;
+
+    let index = HtmlReport::from_detection(result).to_string();
+    write_file(&destination.join("index.html"), index.as_bytes())?;
+    write_file(
+        &destination.join("jscpd-report.json"),
+        json::to_pretty_json(result)?.as_bytes(),
+    )?;
+    write_file(
+        &destination.join("styles").join("tailwind.css"),
+        assets::TAILWIND_CSS.as_bytes(),
+    )?;
+    write_file(
+        &destination.join("styles").join("prism.css"),
+        assets::PRISM_CSS.as_bytes(),
+    )?;
+    write_file(
+        &destination.join("js").join("prism.js"),
+        assets::PRISM_JS.as_bytes(),
+    )?;
+
+    println!(
+        "HTML report saved to {}",
+        display_directory_with_slash(&destination)
+    );
+    Ok(())
+}
+
+fn write_file(path: &Path, content: &[u8]) -> Result<()> {
+    fs::write(path, content).with_context(|| format!("failed to write `{}`", path.display()))
+}
+
+struct HtmlReport<'a> {
+    result: &'a DetectionResult,
+    formats: Vec<String>,
+}
+
+impl<'a> HtmlReport<'a> {
+    fn from_detection(result: &'a DetectionResult) -> Self {
+        let mut formats = result
+            .statistics
+            .formats
+            .keys()
+            .cloned()
+            .collect::<BTreeSet<_>>();
+        formats.extend(result.clones.iter().map(|clone| clone.format.clone()));
+        Self {
+            result,
+            formats: formats.into_iter().collect(),
+        }
+    }
+}
+
+impl std::fmt::Display for HtmlReport<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let total = &self.result.statistics.total;
+
+        writeln!(f, "<!DOCTYPE html>")?;
+        writeln!(f, r#"<html lang="en">"#)?;
+        writeln!(f, "<head>")?;
+        writeln!(f, r#"<meta charset="UTF-8">"#)?;
+        writeln!(
+            f,
+            r#"<meta name="viewport" content="width=device-width, initial-scale=1.0">"#
+        )?;
+        writeln!(f, "<title>Copy/Paste Detector Report</title>")?;
+        writeln!(f, r#"<link href="styles/tailwind.css" rel="stylesheet">"#)?;
+        writeln!(f, r#"<link href="styles/prism.css" rel="stylesheet">"#)?;
+        writeln!(f, "</head>")?;
+        writeln!(f, "<body>")?;
+        writeln!(f, "<header><div class=\"container\">")?;
+        writeln!(f, "<h1>jscpd - copy/paste report</h1>")?;
+        writeln!(f, "</div></header>")?;
+        writeln!(f, "<main class=\"container\">")?;
+        write_dashboard(f, total)?;
+        write_formats(f, self)?;
+        write_clones(f, self)?;
+        writeln!(f, "</main>")?;
+        write_footer(f)?;
+        writeln!(f, r#"<script src="js/prism.js"></script>"#)?;
+        write_toggle_script(f)?;
+        writeln!(f, "</body>")?;
+        writeln!(f, "</html>")
+    }
+}
+
+fn write_dashboard(f: &mut std::fmt::Formatter<'_>, total: &StatisticRow) -> std::fmt::Result {
+    writeln!(f, r#"<section id="dashboard">"#)?;
+    writeln!(f, "<h2>Dashboard</h2>")?;
+    writeln!(f, r#"<div class="dashboard-grid">"#)?;
+    write_card(f, "blue", "Total Files", total.sources.to_string())?;
+    write_card(f, "green", "Total Lines of Code", total.lines.to_string())?;
+    write_card(f, "yellow", "Number of Clones", total.clones.to_string())?;
+    write_card(
+        f,
+        "red",
+        "Duplicated Lines",
+        format!("{} ({:.2}%)", total.duplicated_lines, total.percentage),
+    )?;
+    writeln!(f, "</div>")?;
+    writeln!(f, "</section>")
+}
+
+fn write_card(
+    f: &mut std::fmt::Formatter<'_>,
+    class_name: &str,
+    title: &str,
+    value: String,
+) -> std::fmt::Result {
+    writeln!(
+        f,
+        r#"<div class="card {class_name}"><h3>{}</h3><span>{}</span></div>"#,
+        escape_html(title),
+        escape_html(&value)
+    )
+}
+
+fn write_formats(f: &mut std::fmt::Formatter<'_>, report: &HtmlReport<'_>) -> std::fmt::Result {
+    writeln!(f, r#"<section id="formats">"#)?;
+    writeln!(f, "<h2>Formats with Duplications</h2>")?;
+    writeln!(f, "<table>")?;
+    writeln!(
+        f,
+        "<thead><tr><th>Format</th><th>Files</th><th>Lines</th><th>Clones</th><th>Duplicated Lines</th><th>Duplicated Tokens</th></tr></thead>"
+    )?;
+    writeln!(f, "<tbody>")?;
+    for format in &report.formats {
+        let Some(statistic) = report.result.statistics.formats.get(format) else {
+            continue;
+        };
+        let total = &statistic.total;
+        writeln!(
+            f,
+            r##"<tr><td><a href="#{}-clones">{}</a></td><td>{}</td><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr>"##,
+            escape_html(format),
+            escape_html(format),
+            total.sources,
+            total.lines,
+            total.clones,
+            total.duplicated_lines,
+            total.duplicated_tokens,
+        )?;
+    }
+    writeln!(f, "</tbody>")?;
+    writeln!(f, "</table>")?;
+    writeln!(f, "</section>")
+}
+
+fn write_clones(f: &mut std::fmt::Formatter<'_>, report: &HtmlReport<'_>) -> std::fmt::Result {
+    writeln!(f, r#"<section id="txt-clones">"#)?;
+    for format in &report.formats {
+        writeln!(f, r#"<a name="{}-clones"></a>"#, escape_html(format))?;
+        writeln!(f, "<h2>{}</h2>", escape_html(format))?;
+        writeln!(f, r#"<div class="clones">"#)?;
+        for (index, clone) in report
+            .result
+            .clones
+            .iter()
+            .enumerate()
+            .filter(|(_, clone)| clone.format == *format)
+        {
+            write_clone(f, report.result, clone, index)?;
+        }
+        writeln!(f, "</div>")?;
+    }
+    writeln!(f, "</section>")
+}
+
+fn write_clone(
+    f: &mut std::fmt::Formatter<'_>,
+    result: &DetectionResult,
+    clone: &CloneMatch,
+    index: usize,
+) -> std::fmt::Result {
+    writeln!(f, r#"<div class="clone">"#)?;
+    writeln!(
+        f,
+        "<p>{} (Line {}:{} - Line {}:{}), {} (Line {}:{} - Line {}:{})</p>",
+        escape_html(&clone.duplication_a.source_id),
+        clone.duplication_a.start.line,
+        clone.duplication_a.start.column,
+        clone.duplication_a.end.line,
+        clone.duplication_a.end.column,
+        escape_html(&clone.duplication_b.source_id),
+        clone.duplication_b.start.line,
+        clone.duplication_b.start.column,
+        clone.duplication_b.end.line,
+        clone.duplication_b.end.column,
+    )?;
+    writeln!(
+        f,
+        r#"<button id="expandBtn{index}" onclick="toggleCodeBlock('cloneGroup{index}', 'expandBtn{index}', 'collapseBtn{index}')">Show code</button>"#
+    )?;
+    writeln!(
+        f,
+        r#"<button class="hidden" id="collapseBtn{index}" onclick="toggleCodeBlock('cloneGroup{index}', 'expandBtn{index}', 'collapseBtn{index}')">Hide code</button>"#
+    )?;
+    writeln!(
+        f,
+        r#"<pre class="hidden" id="cloneGroup{index}"><code class="language-{}">{}</code></pre>"#,
+        escape_html(&clone.format),
+        escape_html(&clone_fragment(result, &clone.duplication_a))
+    )?;
+    writeln!(f, "</div>")
+}
+
+fn write_footer(f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    writeln!(f, "<footer>")?;
+    writeln!(
+        f,
+        r#"<p>Generated by <a href="https://jscpd.dev" target="_blank">jscpd</a> v{VERSION} by <a href="https://github.com/kucherenko" target="_blank">Andrey Kucherenko</a></p>"#
+    )?;
+    writeln!(
+        f,
+        r#"<p><a href="https://www.npmjs.com/package/jscpd" target="_blank">npm package</a> &middot; Since 2013 &middot; <a href="https://opencollective.com/jscpd" target="_blank">Sponsor jscpd</a></p>"#
+    )?;
+    writeln!(f, "</footer>")
+}
+
+fn write_toggle_script(f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    writeln!(f, "<script>")?;
+    writeln!(
+        f,
+        "function toggleCodeBlock(codeBlockId, expandBtnId, collapseBtnId) {{"
+    )?;
+    writeln!(
+        f,
+        "  const codeBlock = document.getElementById(codeBlockId);"
+    )?;
+    writeln!(
+        f,
+        "  const expandBtn = document.getElementById(expandBtnId);"
+    )?;
+    writeln!(
+        f,
+        "  const collapseBtn = document.getElementById(collapseBtnId);"
+    )?;
+    writeln!(f, "  codeBlock.classList.toggle('hidden');")?;
+    writeln!(f, "  expandBtn.classList.toggle('hidden');")?;
+    writeln!(f, "  collapseBtn.classList.toggle('hidden');")?;
+    writeln!(f, "}}")?;
+    writeln!(f, "</script>")
+}
+
+fn display_directory_with_slash(path: &Path) -> String {
+    let mut display = path.display().to_string();
+    if !display.ends_with(std::path::MAIN_SEPARATOR) {
+        display.push(std::path::MAIN_SEPARATOR);
+    }
+    display
+}
+
+fn escape_html(value: &str) -> String {
+    let mut escaped = String::with_capacity(value.len());
+    for character in value.chars() {
+        match character {
+            '&' => escaped.push_str("&amp;"),
+            '<' => escaped.push_str("&lt;"),
+            '>' => escaped.push_str("&gt;"),
+            '"' => escaped.push_str("&quot;"),
+            '\'' => escaped.push_str("&#39;"),
+            _ => escaped.push(character),
+        }
+    }
+    escaped
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::report::test_support::{
+        make_test_result_with_clone, write_test_report, write_test_report_output,
+    };
+
+    #[test]
+    fn html_report_writes_upstream_layout_files() {
+        let html = write_test_report("html", "html-report", &["html", "index.html"]);
+        let json = write_test_report("html", "html-report-json", &["html", "jscpd-report.json"]);
+
+        assert!(html.contains("<title>Copy/Paste Detector Report</title>"));
+        assert!(html.contains("jscpd - copy/paste report"));
+        assert!(html.contains("Formats with Duplications"));
+        assert!(html.contains("Show code"));
+        assert!(json.contains("\"duplicates\""));
+        assert!(json.contains("\"statistics\""));
+    }
+
+    #[test]
+    fn html_report_escapes_fragment_and_paths() {
+        let result = make_test_result_with_clone("src/a<&>.js", "src/b.js");
+        let html = HtmlReport::from_detection(&result).to_string();
+
+        assert!(html.contains("src/a&lt;&amp;&gt;.js"));
+        assert!(html.contains("alpha &lt;beta&gt; ]]&gt;"));
+    }
+
+    #[test]
+    fn html_report_writes_static_assets() {
+        let output = write_test_report_output("html", "html-assets");
+        let tailwind = output.join("html").join("styles").join("tailwind.css");
+        let prism_css = output.join("html").join("styles").join("prism.css");
+        let prism_js = output.join("html").join("js").join("prism.js");
+        let _ = std::fs::metadata(tailwind).unwrap();
+        let _ = std::fs::metadata(prism_css).unwrap();
+        let _ = std::fs::metadata(prism_js).unwrap();
+        let _ = std::fs::remove_dir_all(output);
+    }
+}

package/src/report/json.rs

@@ -0,0 +1,119 @@
+use anyhow::Result;
+use serde::Serialize;
+
+use super::file_output::write_file_report;
+use super::source::slice_range;
+use crate::cli::Options;
+use crate::detector::{BlamedLines, CloneMatch, DetectionResult, Statistics, clone_lines};
+
+pub(super) fn write(result: &DetectionResult, options: &Options) -> Result<()> {
+    let json = to_pretty_json(result)?;
+    write_file_report(options, "jscpd-report.json", "JSON report", json)
+}
+
+pub(super) fn to_pretty_json(result: &DetectionResult) -> Result<String> {
+    Ok(serde_json::to_string_pretty(&JsonReport::from_detection(
+        result,
+    ))?)
+}
+
+#[derive(Serialize)]
+struct JsonReport {
+    duplicates: Vec<JsonDuplicate>,
+    statistics: Statistics,
+}
+
+#[derive(Serialize)]
+struct JsonDuplicate {
+    format: String,
+    lines: usize,
+    tokens: usize,
+    #[serde(rename = "firstFile")]
+    first_file: JsonFile,
+    #[serde(rename = "secondFile")]
+    second_file: JsonFile,
+    fragment: String,
+}
+
+#[derive(Serialize)]
+struct JsonFile {
+    name: String,
+    start: usize,
+    end: usize,
+    #[serde(rename = "startLoc")]
+    start_loc: crate::tokenizer::Location,
+    #[serde(rename = "endLoc")]
+    end_loc: crate::tokenizer::Location,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    blame: Option<BlamedLines>,
+}
+
+impl JsonReport {
+    fn from_detection(result: &DetectionResult) -> Self {
+        Self {
+            duplicates: result
+                .clones
+                .iter()
+                .map(|clone| JsonDuplicate::from_clone(clone, result))
+                .collect(),
+            statistics: result.statistics.clone(),
+        }
+    }
+}
+
+impl JsonDuplicate {
+    fn from_clone(clone: &CloneMatch, result: &DetectionResult) -> Self {
+        let fragment = result
+            .source_contents
+            .get(&clone.duplication_a.source_id)
+            .map(|content| slice_range(content, clone.duplication_a.range))
+            .unwrap_or_default();
+
+        Self {
+            format: clone.format.clone(),
+            lines: clone_lines(clone),
+            tokens: 0,
+            first_file: JsonFile {
+                name: clone.duplication_a.source_id.clone(),
+                start: clone.duplication_a.start.line,
+                end: clone.duplication_a.end.line,
+                start_loc: clone.duplication_a.start.clone(),
+                end_loc: clone.duplication_a.end.clone(),
+                blame: clone.duplication_a.blame.clone(),
+            },
+            second_file: JsonFile {
+                name: clone.duplication_b.source_id.clone(),
+                start: clone.duplication_b.start.line,
+                end: clone.duplication_b.end.line,
+                start_loc: clone.duplication_b.start.clone(),
+                end_loc: clone.duplication_b.end.clone(),
+                blame: clone.duplication_b.blame.clone(),
+            },
+            fragment,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::report::test_support::{make_test_result_with_clone, single_line_blame};
+
+    use super::to_pretty_json;
+
+    #[test]
+    fn json_report_includes_blame_when_present() {
+        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",
+            "abc123",
+            "Alice",
+            "2024-01-01 00:00:00 +0000",
+        ));
+
+        let json = to_pretty_json(&result).unwrap();
+
+        assert!(json.contains(r#""blame""#));
+        assert!(json.contains(r#""author": "Alice""#));
+        assert!(json.contains(r#""rev": "abc123""#));
+    }
+}

package/src/report/markdown.rs

@@ -0,0 +1,125 @@
+use anyhow::Result;
+
+use super::file_output::write_file_report;
+use super::summary::{silent_summary, summary_rows};
+use crate::cli::Options;
+use crate::detector::DetectionResult;
+
+pub(super) fn write(result: &DetectionResult, options: &Options) -> Result<()> {
+    let md = MarkdownReport::from_detection(result).to_string();
+    write_file_report(options, "jscpd-report.md", "Markdown report", md)
+}
+
+struct MarkdownReport {
+    summary_line: String,
+    rows: Vec<[String; 7]>,
+}
+
+impl MarkdownReport {
+    fn from_detection(result: &DetectionResult) -> Self {
+        let stats = &result.statistics;
+        let summary_line = format!("> {}", silent_summary(result));
+        let mut rows = summary_rows(stats);
+        if let Some(total) = rows.last_mut() {
+            for cell in total {
+                *cell = format!("**{cell}**");
+            }
+        }
+
+        Self { summary_line, rows }
+    }
+}
+
+impl std::fmt::Display for MarkdownReport {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f)?;
+        writeln!(f, "# Copy/paste detection report")?;
+        writeln!(f)?;
+        writeln!(f, "{}", self.summary_line)?;
+        writeln!(f)?;
+        let widths = markdown_column_widths(&self.rows);
+        for (row_idx, row) in self.rows.iter().enumerate() {
+            write_markdown_row(f, row, &widths)?;
+            if row_idx == 0 {
+                write_markdown_separator(f, &widths)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+fn markdown_column_widths(rows: &[[String; 7]]) -> [usize; 7] {
+    let mut widths = [0usize; 7];
+    for row in rows {
+        for (idx, cell) in row.iter().enumerate() {
+            widths[idx] = widths[idx].max(cell.len());
+        }
+    }
+    widths
+}
+
+fn write_markdown_row(
+    f: &mut std::fmt::Formatter<'_>,
+    row: &[String; 7],
+    widths: &[usize; 7],
+) -> std::fmt::Result {
+    write!(f, "|")?;
+    for (idx, cell) in row.iter().enumerate() {
+        write!(f, " {cell:<width$} |", width = widths[idx])?;
+    }
+    writeln!(f)
+}
+
+fn write_markdown_separator(
+    f: &mut std::fmt::Formatter<'_>,
+    widths: &[usize; 7],
+) -> std::fmt::Result {
+    write!(f, "|")?;
+    for width in widths {
+        write!(f, " {:-<width$} |", "", width = *width)?;
+    }
+    writeln!(f)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::report::test_support::write_test_report;
+
+    #[test]
+    fn write_reports_writes_markdown_report() {
+        let md = write_test_report("markdown", "markdown-report", &["jscpd-report.md"]);
+
+        assert!(md.starts_with("\n# Copy/paste detection report"));
+        assert!(md.contains("> Duplications detection:"));
+    }
+
+    #[test]
+    fn markdown_report_matches_upstream_summary_shape() {
+        let result = crate::detector::DetectionResult {
+            clones: Vec::new(),
+            skipped_clones: Vec::new(),
+            statistics: crate::report::test_support::make_test_statistics(),
+            sources: Vec::new(),
+            source_contents: std::collections::HashMap::new(),
+        };
+        let md = MarkdownReport::from_detection(&result).to_string();
+
+        assert_eq!(
+            md,
+            [
+                "",
+                "# Copy/paste detection report",
+                "",
+                "> Duplications detection: Found 0 exact clones with 5(25%) duplicated lines in 2 (1 formats) files.",
+                "",
+                "| 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")
+        );
+    }
+}