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

//! File→project resolution — ports `resolver_test.go`.

mod common;

use common::{touch, type_names};
use projectdetect::{Indicator, ProjectType, Registry, Resolver};
use tempfile::tempdir;

/// `Resolver::resolve` walks up to the nearest project root.
#[test]
fn finds_nearest_project() {
    let reg = Registry::with_builtins();
    let root = tempdir().unwrap();
    touch(root.path(), "proj/go.mod");
    touch(root.path(), "proj/cmd/main.go");
    touch(root.path(), "proj/inner/Cargo.toml");
    touch(root.path(), "proj/inner/src/lib.rs");

    let r = Resolver::new(root.path(), &reg);

    let m = r.resolve(root.path().join("proj/cmd/main.go"));
    assert_eq!(type_names(&m), ["go"]);

    // The nearer Cargo.toml wins over the outer go.mod.
    let m = r.resolve(root.path().join("proj/inner/src/lib.rs"));
    assert_eq!(type_names(&m), ["rust"]);
}

/// A file outside any project resolves to nothing.
#[test]
fn no_project() {
    let reg = Registry::with_builtins();
    let root = tempdir().unwrap();
    touch(root.path(), "loose.txt");
    let r = Resolver::new(root.path(), &reg);
    assert!(r.resolve(root.path().join("loose.txt")).is_empty());
}

/// `resolve_for_path` returns the nearest project root and its types.
#[test]
fn resolve_for_path_finds_nearest() {
    let reg = Registry::with_builtins();
    let root = tempdir().unwrap();
    touch(root.path(), "proj/go.mod");
    touch(root.path(), "proj/cmd/main.go");
    touch(root.path(), "proj/inner/Cargo.toml");
    touch(root.path(), "proj/inner/src/lib.rs");

    let (p, m) = reg
        .resolve_for_path(root.path().join("proj/cmd/main.go"))
        .unwrap();
    assert_eq!(p, root.path().join("proj"));
    assert_eq!(type_names(&m), ["go"]);

    let (p, m) = reg
        .resolve_for_path(root.path().join("proj/inner/src/lib.rs"))
        .unwrap();
    assert_eq!(p, root.path().join("proj/inner"));
    assert_eq!(type_names(&m), ["rust"]);
}

/// `resolve_for_path` returns `None` when no ancestor is a project.
#[test]
fn resolve_for_path_no_project() {
    let reg = Registry::with_builtins();
    let root = tempdir().unwrap();
    touch(root.path(), "loose.txt");
    assert!(reg
        .resolve_for_path(root.path().join("loose.txt"))
        .is_none());
}

/// A polyglot root surfaces all matched types.
#[test]
fn resolve_for_path_polyglot() {
    let reg = Registry::with_builtins();
    let root = tempdir().unwrap();
    touch(root.path(), "go.mod");
    touch(root.path(), "docker-compose.yml");
    touch(root.path(), "cmd/main.go");

    let (p, m) = reg
        .resolve_for_path(root.path().join("cmd/main.go"))
        .unwrap();
    assert_eq!(p, root.path().to_path_buf());
    assert_eq!(type_names(&m), ["docker-compose", "go"]);
}

/// The resolver respects the registry it was constructed with.
#[test]
fn custom_registry() {
    let mut reg = Registry::new();
    reg.register(ProjectType::new(
        "custom",
        "Custom",
        vec![Indicator::HasFile("custom.marker".into())],
        vec![],
    ))
    .unwrap();

    let root = tempdir().unwrap();
    touch(root.path(), "custom.marker");
    touch(root.path(), "go.mod"); // would match built-in `go` in the default registry
    touch(root.path(), "sub/file.txt");

    let r = Resolver::new(root.path(), &reg);
    let m = r.resolve(root.path().join("sub/file.txt"));
    assert_eq!(type_names(&m), ["custom"]);
}