projectdetect 0.1.0

Detect what kind of project a directory is (Go, Node, Rust, Xcode, …) by canonical indicator files, with recursive discovery, file→project resolution, and custom YAML/CEL types.
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

//! Recursive discovery — ports `projectdetect_test.go`'s Find tests.

mod common;

use common::touch;
use projectdetect::{FindOptions, Registry};
use tempfile::tempdir;

/// Non-nested (default): the walk stops at the first project root and does not
/// descend into a nested project.
#[test]
fn stops_at_project_root() {
    let reg = Registry::with_builtins();
    let root = tempdir().unwrap();
    touch(root.path(), "a/go.mod");
    touch(root.path(), "a/inner/go.mod");

    let res = reg.find(root.path(), &FindOptions::default()).unwrap();
    assert_eq!(res.count, 1, "projects={:?}", res.projects);
    assert_eq!(res.projects[0].path, root.path().join("a"));
}

/// Nested = true surfaces the inner project too.
#[test]
fn nested_true() {
    let reg = Registry::with_builtins();
    let root = tempdir().unwrap();
    touch(root.path(), "a/go.mod");
    touch(root.path(), "a/inner/Cargo.toml");

    let res = reg
        .find(
            root.path(),
            &FindOptions {
                nested: true,
                ..Default::default()
            },
        )
        .unwrap();
    assert_eq!(res.count, 2, "projects={:?}", res.projects);
}

/// The `types` filter keeps only matching project types.
#[test]
fn types_filter() {
    let reg = Registry::with_builtins();
    let root = tempdir().unwrap();
    touch(root.path(), "go-app/go.mod");
    touch(root.path(), "rust-app/Cargo.toml");
    touch(root.path(), "node-app/package.json");

    let res = reg
        .find(
            root.path(),
            &FindOptions {
                types: vec!["go".into(), "rust".into()],
                ..Default::default()
            },
        )
        .unwrap();
    assert_eq!(res.count, 2, "projects={:?}", res.projects);
}

/// Excludes prune directories (and their subtrees) during the walk.
#[test]
fn excludes() {
    let reg = Registry::with_builtins();
    let root = tempdir().unwrap();
    touch(root.path(), "real/go.mod");
    touch(root.path(), "node_modules/vendored/go.mod");

    let res = reg
        .find(
            root.path(),
            &FindOptions {
                excludes: vec!["node_modules".into()],
                ..Default::default()
            },
        )
        .unwrap();
    assert_eq!(res.count, 1, "projects={:?}", res.projects);
    assert_eq!(res.projects[0].path, root.path().join("real"));
}

/// A root `.gitignore` prunes matching directories when `respect_gitignore`
/// is set (this crate implements the option the Go doc promised).
#[test]
fn respects_root_gitignore() {
    let reg = Registry::with_builtins();
    let root = tempdir().unwrap();
    touch(root.path(), "kept/go.mod");
    touch(root.path(), "ignored/go.mod");
    common::write(root.path(), ".gitignore", "ignored/\n");

    let res = reg
        .find(
            root.path(),
            &FindOptions {
                respect_gitignore: true,
                ..Default::default()
            },
        )
        .unwrap();
    assert_eq!(res.count, 1, "projects={:?}", res.projects);
    assert_eq!(res.projects[0].path, root.path().join("kept"));
}

/// `collect_build_excludes` unions the build dirs of detected types.
#[test]
fn collect_build_excludes_unions() {
    let reg = Registry::with_builtins();
    let root = tempdir().unwrap();
    touch(root.path(), "g/go.mod"); // vendor
    touch(root.path(), "n/package.json"); // node_modules

    let ex = reg.collect_build_excludes(root.path()).unwrap();
    assert!(ex.contains(&"vendor".to_string()), "{ex:?}");
    assert!(ex.contains(&"node_modules".to_string()), "{ex:?}");
}