weavatrix-clone 0.1.4

Evidence-first Type-1/2/3 code clone engine with deterministic families and bounded near-miss verification
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

#[path = "weavatrix_clone_cli/args.rs"]
mod args;
#[path = "weavatrix_clone_cli/render.rs"]
mod render;

use args::parse_arguments;
use render::render;
use std::{env, process::ExitCode, time::Instant};
use weavatrix_clone::{CloneConfig, CloneDetector, RepositoryCloneDetector, RepositoryOptions};

fn main() -> ExitCode {
    match run() {
        Ok(output) => {
            print!("{output}");
            ExitCode::SUCCESS
        }
        Err(message) => {
            eprintln!("weavatrix-clone: {message}");
            ExitCode::FAILURE
        }
    }
}

fn run() -> Result<String, String> {
    run_with(env::args().skip(1))
}

fn run_with(arguments: impl IntoIterator<Item = String>) -> Result<String, String> {
    let arguments = parse_arguments(arguments)?;
    let config = CloneConfig {
        min_tokens: arguments.min_tokens,
        mode: arguments.mode,
        ..CloneConfig::default()
    };
    let mut repository = RepositoryOptions {
        min_fragment_lines: arguments.min_lines,
        max_fragment_lines: arguments.max_lines,
        cross_extensions: arguments.cross_extensions,
        ..RepositoryOptions::default()
    };
    if let Some(extensions) = arguments.extensions {
        repository = repository.with_extensions(extensions);
    }
    let started = Instant::now();
    let report = RepositoryCloneDetector::new(
        CloneDetector::new(config).map_err(|error| error.to_string())?,
    )
    .options(repository)
    .detect(&arguments.root)
    .map_err(|error| error.to_string())?;
    render(
        &report,
        arguments.output,
        arguments.summary_only,
        started.elapsed(),
    )
}

#[cfg(test)]
mod tests {
    use super::run_with;

    #[test]
    fn executes_exact_summary_on_the_checked_in_oracle() {
        let corpus = format!(
            "{}/benchmarks/corpus/rust",
            env!("CARGO_MANIFEST_DIR").replace('\\', "/")
        );
        let output = run_with(
            [
                "--summary",
                "--mode",
                "exact",
                "--min-tokens",
                "24",
                "--min-lines",
                "3",
                "--max-lines",
                "400",
                "--format",
                "rs",
                &corpus,
            ]
            .into_iter()
            .map(str::to_owned),
        )
        .expect("oracle run");
        assert!(output.contains("type1="));
    }
}