odcs 0.9.0

Reference implementation of the Open Data Contract Standard (ODCS)
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

//! Recursive contract file discovery.

use std::fs;
use std::path::{Path, PathBuf};

/// Returns true when the path looks like an ODCS contract file.
#[must_use]
pub fn is_contract_file(path: &Path) -> bool {
    matches!(
        path.extension().and_then(|ext| ext.to_str()),
        Some("yaml") | Some("yml") | Some("json")
    )
}

fn should_skip_dir(name: &str) -> bool {
    name.starts_with('.')
}

/// Recursively collect contract file paths under `root`, sorted lexicographically.
pub fn collect_contract_files_recursive(root: &Path) -> Result<Vec<PathBuf>, String> {
    let mut files = Vec::new();
    collect_recursive(root, root, &mut files)?;
    files.sort();
    Ok(files)
}

fn collect_recursive(root: &Path, current: &Path, out: &mut Vec<PathBuf>) -> Result<(), String> {
    for entry in fs::read_dir(current)
        .map_err(|error| format!("failed to read directory {}: {error}", current.display()))?
    {
        let entry = entry
            .map_err(|error| format!("failed to read directory {}: {error}", current.display()))?;
        let path = entry.path();
        if path.is_dir() {
            let Some(name) = path.file_name().and_then(|n| n.to_str()) else {
                continue;
            };
            if should_skip_dir(name) {
                continue;
            }
            collect_recursive(root, &path, out)?;
        } else if path.is_file() && is_contract_file(&path) {
            out.push(path.strip_prefix(root).unwrap_or(&path).to_path_buf());
        }
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    fn fixture_root() -> PathBuf {
        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/registry/contracts")
    }

    #[test]
    fn recursive_scan_finds_nested_contracts() {
        let files = collect_contract_files_recursive(&fixture_root()).expect("scan");
        let names: Vec<_> = files
            .iter()
            .map(|path| path.to_string_lossy().into_owned())
            .collect();
        assert!(names
            .iter()
            .any(|name| name.contains("nested/consumer.yaml")));
        assert!(names.iter().any(|name| name.contains("provider-v1.yaml")));
    }
}