forked from Crockan/MercuryToolbox
1781 lines
60 KiB
Rust
1781 lines
60 KiB
Rust
//! The `reposhape` command summarizes repository trees.
|
|
#![allow(clippy::multiple_crate_versions)]
|
|
|
|
use std::collections::{BTreeMap, BTreeSet};
|
|
use std::ffi::OsString;
|
|
use std::fmt::Write as _;
|
|
use std::fs;
|
|
use std::path::{Path, PathBuf};
|
|
|
|
use configsupport::{
|
|
CliError, CommonArgs, ExitCode, RenderMode, parse_color_choice, parse_format_choice,
|
|
print_json, print_quick_help_error, print_structured,
|
|
};
|
|
use ignore::WalkBuilder;
|
|
use lexopt::prelude::{Long, Short, Value as ArgValue};
|
|
use serde::Serialize;
|
|
use serde_json::Value;
|
|
|
|
const MAX_SCANNED_FILES: usize = 250_000;
|
|
const MAX_MANIFEST_BYTES: u64 = 4 * 1024 * 1024;
|
|
|
|
const HELP: &str = "\
|
|
Detect repository ecosystems, manifests, command entrypoints, and CI hints.
|
|
|
|
Usage:
|
|
reposhape [OPTIONS] [PATH]
|
|
|
|
Options:
|
|
--format <FORMAT> Structured output format: text, json, toon
|
|
--json Shortcut for --format json
|
|
--toon Shortcut for --format toon
|
|
--color <WHEN> Control ANSI color output: auto, never
|
|
--quiet Suppress non-essential status output
|
|
--max-depth <COUNT> Optional traversal depth limit
|
|
--hidden Include hidden files and directories
|
|
-h, --help Show this help text
|
|
-V, --version Show the command version
|
|
|
|
Examples:
|
|
reposhape .
|
|
reposhape . --json | ConvertFrom-Json
|
|
reposhape C:\\src\\repo --max-depth 4
|
|
";
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct Cli {
|
|
common: CommonArgs,
|
|
max_depth: Option<usize>,
|
|
include_hidden: bool,
|
|
path: Option<PathBuf>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum ParseOutcome {
|
|
Help,
|
|
Version,
|
|
Run,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
|
|
struct RepoSummary {
|
|
root: String,
|
|
ecosystems: Vec<Ecosystem>,
|
|
manifests: Vec<Manifest>,
|
|
commands: Vec<CommandHint>,
|
|
entrypoints: Vec<EntryPoint>,
|
|
ci: Vec<CiHint>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
|
|
struct Ecosystem {
|
|
name: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
|
|
struct Manifest {
|
|
ecosystem: String,
|
|
kind: String,
|
|
path: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
|
|
struct CommandHint {
|
|
ecosystem: String,
|
|
build: Vec<String>,
|
|
test: Vec<String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
|
|
struct EntryPoint {
|
|
ecosystem: String,
|
|
kind: String,
|
|
path: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
|
|
struct CiHint {
|
|
provider: String,
|
|
kind: String,
|
|
path: String,
|
|
}
|
|
|
|
#[derive(Debug, Default)]
|
|
struct CommandAccumulator {
|
|
build: BTreeSet<String>,
|
|
test: BTreeSet<String>,
|
|
}
|
|
|
|
#[derive(Debug, Default)]
|
|
struct ScriptedLayoutState {
|
|
has_src: bool,
|
|
has_tests: bool,
|
|
has_docs: bool,
|
|
}
|
|
|
|
struct RepoScanState<'a> {
|
|
ecosystems: &'a mut BTreeSet<String>,
|
|
manifests: &'a mut Vec<Manifest>,
|
|
command_map: &'a mut BTreeMap<String, CommandAccumulator>,
|
|
entrypoints: &'a mut Vec<EntryPoint>,
|
|
ci: &'a mut Vec<CiHint>,
|
|
scripted_layout: &'a mut ScriptedLayoutState,
|
|
}
|
|
|
|
/// Parses CLI arguments and returns a process exit code.
|
|
#[must_use]
|
|
pub fn main_entry() -> i32 {
|
|
match parse_cli_from(std::env::args_os()) {
|
|
Ok((ParseOutcome::Help, _)) => {
|
|
print!("{HELP}");
|
|
ExitCode::Success.as_i32()
|
|
}
|
|
Ok((ParseOutcome::Version, _)) => {
|
|
println!("reposhape {}", env!("CARGO_PKG_VERSION"));
|
|
ExitCode::Success.as_i32()
|
|
}
|
|
Ok((ParseOutcome::Run, cli)) => match run(&cli) {
|
|
Ok(code) => code.as_i32(),
|
|
Err(error) => {
|
|
print_quick_help_error(&error, HELP);
|
|
error.exit_code().as_i32()
|
|
}
|
|
},
|
|
Err(error) => {
|
|
print_quick_help_error(&error, HELP);
|
|
error.exit_code().as_i32()
|
|
}
|
|
}
|
|
}
|
|
|
|
fn parse_cli_from<I, T>(args: I) -> Result<(ParseOutcome, Cli), CliError>
|
|
where
|
|
I: IntoIterator<Item = T>,
|
|
T: Into<OsString>,
|
|
{
|
|
let mut parser = lexopt::Parser::from_iter(args);
|
|
let mut cli = Cli {
|
|
common: CommonArgs::default(),
|
|
max_depth: None,
|
|
include_hidden: false,
|
|
path: None,
|
|
};
|
|
|
|
while let Some(argument) = parser
|
|
.next()
|
|
.map_err(|error| CliError::usage(error.to_string()))?
|
|
{
|
|
match argument {
|
|
Long("help") | Short('h') => return Ok((ParseOutcome::Help, cli)),
|
|
Long("version") | Short('V') => return Ok((ParseOutcome::Version, cli)),
|
|
Long("json") => cli.common.set_render_mode(RenderMode::Json),
|
|
Long("toon") => cli.common.set_render_mode(RenderMode::Toon),
|
|
Long("format") => {
|
|
let value = parser_value_string(&mut parser, "--format")?;
|
|
cli.common.set_render_mode(parse_format_choice(&value)?);
|
|
}
|
|
Long("quiet") => cli.common.quiet = true,
|
|
Long("hidden") => cli.include_hidden = true,
|
|
Long("color") => {
|
|
cli.common.color =
|
|
parse_color_choice(&parser_value_string(&mut parser, "--color")?)?;
|
|
}
|
|
Long("max-depth") => {
|
|
cli.max_depth = Some(parse_usize_flag(
|
|
"--max-depth",
|
|
&parser_value_string(&mut parser, "--max-depth")?,
|
|
)?);
|
|
}
|
|
ArgValue(path) if cli.path.is_none() => cli.path = Some(PathBuf::from(path)),
|
|
_ => {
|
|
return Err(CliError::usage(
|
|
"unsupported argument; use --help to see available options",
|
|
));
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok((ParseOutcome::Run, cli))
|
|
}
|
|
|
|
fn parser_value_string(parser: &mut lexopt::Parser, flag: &str) -> Result<String, CliError> {
|
|
let value = parser
|
|
.value()
|
|
.map_err(|error| CliError::usage(error.to_string()))?;
|
|
value.into_string().map_err(|invalid| {
|
|
CliError::usage(format!(
|
|
"{flag} expects UTF-8 text, got '{}'",
|
|
invalid.to_string_lossy()
|
|
))
|
|
})
|
|
}
|
|
|
|
fn parse_usize_flag(flag: &str, value: &str) -> Result<usize, CliError> {
|
|
value
|
|
.parse::<usize>()
|
|
.map_err(|error| CliError::usage(format!("invalid {flag} value '{value}': {error}")))
|
|
}
|
|
|
|
fn run(cli: &Cli) -> Result<ExitCode, CliError> {
|
|
let summary = inspect_repository(cli)?;
|
|
match cli.common.render_mode() {
|
|
RenderMode::Json => print_json(&summary)?,
|
|
RenderMode::Toon => print_structured(&summary, RenderMode::Toon)?,
|
|
RenderMode::Text => print!("{}", render_summary(&summary)),
|
|
}
|
|
Ok(ExitCode::Success)
|
|
}
|
|
|
|
fn inspect_repository(cli: &Cli) -> Result<RepoSummary, CliError> {
|
|
inspect_repository_with_file_cap(cli, MAX_SCANNED_FILES)
|
|
}
|
|
|
|
fn inspect_repository_with_file_cap(
|
|
cli: &Cli,
|
|
max_scanned_files: usize,
|
|
) -> Result<RepoSummary, CliError> {
|
|
let root = cli
|
|
.path
|
|
.clone()
|
|
.unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));
|
|
if !root.exists() {
|
|
return Err(CliError::runtime(format!(
|
|
"repository path does not exist: {}",
|
|
root.display()
|
|
)));
|
|
}
|
|
|
|
let mut builder = WalkBuilder::new(&root);
|
|
builder.hidden(!cli.include_hidden);
|
|
builder.git_ignore(true);
|
|
builder.git_global(true);
|
|
builder.git_exclude(true);
|
|
if let Some(depth) = cli.max_depth {
|
|
builder.max_depth(Some(depth));
|
|
}
|
|
|
|
let mut ecosystems = BTreeSet::<String>::new();
|
|
let mut manifests = Vec::<Manifest>::new();
|
|
let mut entrypoints = Vec::<EntryPoint>::new();
|
|
let mut ci = Vec::<CiHint>::new();
|
|
let mut command_map = BTreeMap::<String, CommandAccumulator>::new();
|
|
let mut scripted_layout = ScriptedLayoutState::default();
|
|
let mut scanned_files = 0_usize;
|
|
let mut state = RepoScanState {
|
|
ecosystems: &mut ecosystems,
|
|
manifests: &mut manifests,
|
|
command_map: &mut command_map,
|
|
entrypoints: &mut entrypoints,
|
|
ci: &mut ci,
|
|
scripted_layout: &mut scripted_layout,
|
|
};
|
|
|
|
validate_github_workflows_dir(&root)?;
|
|
for entry in builder.build() {
|
|
let entry = entry
|
|
.map_err(|error| CliError::runtime(format!("failed to walk repository: {error}")))?;
|
|
if entry.path().is_file() {
|
|
scanned_files += 1;
|
|
if scanned_files > max_scanned_files {
|
|
return Err(CliError::runtime(format!(
|
|
"reposhape scan exceeded {max_scanned_files} files; narrow the scan with --max-depth or a smaller root"
|
|
)));
|
|
}
|
|
scan_file(&root, entry.path(), &mut state)?;
|
|
}
|
|
}
|
|
detect_github_actions(&root, state.ci)?;
|
|
state
|
|
.scripted_layout
|
|
.finish(state.ecosystems, state.entrypoints);
|
|
dedup_manifests(state.manifests);
|
|
dedup_entrypoints(state.entrypoints);
|
|
dedup_ci(state.ci);
|
|
|
|
let ecosystems = ecosystems
|
|
.into_iter()
|
|
.map(|name| Ecosystem { name })
|
|
.collect::<Vec<_>>();
|
|
let commands = command_map
|
|
.into_iter()
|
|
.map(|(ecosystem, hints)| CommandHint {
|
|
ecosystem,
|
|
build: hints.build.into_iter().collect(),
|
|
test: hints.test.into_iter().collect(),
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
Ok(RepoSummary {
|
|
root: root.display().to_string(),
|
|
ecosystems,
|
|
manifests,
|
|
commands,
|
|
entrypoints,
|
|
ci,
|
|
})
|
|
}
|
|
|
|
#[allow(clippy::too_many_lines)]
|
|
fn scan_file(root: &Path, file: &Path, state: &mut RepoScanState<'_>) -> Result<(), CliError> {
|
|
let relative = relative_path(root, file);
|
|
let normalized_relative = normalize_separators(&relative);
|
|
let Some(file_name) = file.file_name().and_then(|value| value.to_str()) else {
|
|
return Ok(());
|
|
};
|
|
|
|
match file_name {
|
|
"Cargo.toml" => {
|
|
add_ecosystem(state.ecosystems, "cargo");
|
|
add_manifest(state.manifests, "cargo", "cargo_toml", &relative);
|
|
add_commands(state.command_map, "cargo", "cargo build", "cargo test");
|
|
detect_cargo_entrypoints(root, file, state.entrypoints);
|
|
}
|
|
"package.json" => {
|
|
detect_node_workspace(
|
|
root,
|
|
file,
|
|
state.ecosystems,
|
|
state.manifests,
|
|
state.command_map,
|
|
state.entrypoints,
|
|
)?;
|
|
}
|
|
"package-lock.json" => {
|
|
add_ecosystem(state.ecosystems, "npm");
|
|
add_manifest(state.manifests, "npm", "package_lock", &relative);
|
|
}
|
|
"pnpm-lock.yaml" => {
|
|
add_ecosystem(state.ecosystems, "pnpm");
|
|
add_manifest(state.manifests, "pnpm", "pnpm_lock", &relative);
|
|
}
|
|
"yarn.lock" => {
|
|
add_ecosystem(state.ecosystems, "yarn");
|
|
add_manifest(state.manifests, "yarn", "yarn_lock", &relative);
|
|
}
|
|
"bun.lock" | "bun.lockb" => {
|
|
add_ecosystem(state.ecosystems, "bun");
|
|
add_manifest(state.manifests, "bun", "bun_lock", &relative);
|
|
}
|
|
"pyproject.toml" => {
|
|
detect_python_project(
|
|
root,
|
|
file,
|
|
state.ecosystems,
|
|
state.manifests,
|
|
state.command_map,
|
|
state.entrypoints,
|
|
)?;
|
|
}
|
|
"go.mod" => {
|
|
add_ecosystem(state.ecosystems, "go");
|
|
add_manifest(state.manifests, "go", "go_mod", &relative);
|
|
add_commands(state.command_map, "go", "go build ./...", "go test ./...");
|
|
detect_go_entrypoints(root, file, state.entrypoints);
|
|
}
|
|
"CMakeLists.txt" => {
|
|
add_ecosystem(state.ecosystems, "cmake");
|
|
add_manifest(state.manifests, "cmake", "cmake_lists", &relative);
|
|
add_commands(
|
|
state.command_map,
|
|
"cmake",
|
|
"cmake -S . -B build && cmake --build build",
|
|
"ctest --test-dir build",
|
|
);
|
|
}
|
|
"Makefile" | "makefile" | "GNUmakefile" => {
|
|
add_ecosystem(state.ecosystems, "make");
|
|
add_manifest(state.manifests, "make", "makefile", &relative);
|
|
detect_make_commands(file, state.command_map)?;
|
|
}
|
|
_ => {
|
|
if has_extension_case_insensitive(file_name, "csproj") {
|
|
add_ecosystem(state.ecosystems, "dotnet");
|
|
add_manifest(state.manifests, "dotnet", "csproj", &relative);
|
|
add_entrypoint(state.entrypoints, "dotnet", "project", &relative);
|
|
add_command_line(
|
|
state.command_map,
|
|
"dotnet",
|
|
"build",
|
|
format!("dotnet build {relative}"),
|
|
);
|
|
add_command_line(
|
|
state.command_map,
|
|
"dotnet",
|
|
"test",
|
|
format!("dotnet test {relative}"),
|
|
);
|
|
} else if has_extension_case_insensitive(file_name, "sln") {
|
|
add_ecosystem(state.ecosystems, "dotnet");
|
|
add_manifest(state.manifests, "dotnet", "sln", &relative);
|
|
add_entrypoint(state.entrypoints, "dotnet", "solution", &relative);
|
|
add_command_line(
|
|
state.command_map,
|
|
"dotnet",
|
|
"build",
|
|
format!("dotnet build {relative}"),
|
|
);
|
|
add_command_line(
|
|
state.command_map,
|
|
"dotnet",
|
|
"test",
|
|
format!("dotnet test {relative}"),
|
|
);
|
|
} else if file_name.starts_with("requirements")
|
|
&& has_extension_case_insensitive(file_name, "txt")
|
|
{
|
|
add_ecosystem(state.ecosystems, "python");
|
|
add_manifest(state.manifests, "python", "requirements", &relative);
|
|
add_command_line(state.command_map, "python", "test", "pytest".to_string());
|
|
} else if normalized_relative.starts_with(".github/workflows/")
|
|
&& is_yaml_path(&relative)
|
|
{
|
|
state.ci.push(CiHint {
|
|
provider: "github_actions".to_string(),
|
|
kind: "workflow".to_string(),
|
|
path: relative.clone(),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
scan_scripted_layout_path(
|
|
&relative,
|
|
&normalized_relative,
|
|
state.ecosystems,
|
|
state.manifests,
|
|
state.command_map,
|
|
state.entrypoints,
|
|
state.scripted_layout,
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn scan_scripted_layout_path(
|
|
relative: &str,
|
|
normalized_relative: &str,
|
|
ecosystems: &mut BTreeSet<String>,
|
|
manifests: &mut Vec<Manifest>,
|
|
command_map: &mut BTreeMap<String, CommandAccumulator>,
|
|
entrypoints: &mut Vec<EntryPoint>,
|
|
scripted_layout: &mut ScriptedLayoutState,
|
|
) {
|
|
match normalized_relative {
|
|
"build.ps1" => {
|
|
add_ecosystem(ecosystems, "scripted");
|
|
add_manifest(manifests, "scripted", "build_script", relative);
|
|
add_command_line(
|
|
command_map,
|
|
"scripted",
|
|
"build",
|
|
format!("pwsh -NoProfile -File {relative}"),
|
|
);
|
|
add_entrypoint(entrypoints, "scripted", "build_script", relative);
|
|
}
|
|
"build.cmd" | "build.bat" => {
|
|
add_ecosystem(ecosystems, "scripted");
|
|
add_manifest(manifests, "scripted", "build_script", relative);
|
|
add_command_line(
|
|
command_map,
|
|
"scripted",
|
|
"build",
|
|
format!("cmd /d /c {relative}"),
|
|
);
|
|
add_entrypoint(entrypoints, "scripted", "build_script", relative);
|
|
}
|
|
"build.sh" => {
|
|
add_ecosystem(ecosystems, "scripted");
|
|
add_manifest(manifests, "scripted", "build_script", relative);
|
|
add_command_line(command_map, "scripted", "build", format!("sh {relative}"));
|
|
add_entrypoint(entrypoints, "scripted", "build_script", relative);
|
|
}
|
|
"test.ps1" => {
|
|
add_ecosystem(ecosystems, "scripted");
|
|
add_manifest(manifests, "scripted", "test_script", relative);
|
|
add_command_line(
|
|
command_map,
|
|
"scripted",
|
|
"test",
|
|
format!("pwsh -NoProfile -File {relative}"),
|
|
);
|
|
add_entrypoint(entrypoints, "scripted", "test_script", relative);
|
|
}
|
|
"test.cmd" | "test.bat" => {
|
|
add_ecosystem(ecosystems, "scripted");
|
|
add_manifest(manifests, "scripted", "test_script", relative);
|
|
add_command_line(
|
|
command_map,
|
|
"scripted",
|
|
"test",
|
|
format!("cmd /d /c {relative}"),
|
|
);
|
|
add_entrypoint(entrypoints, "scripted", "test_script", relative);
|
|
}
|
|
"test.sh" => {
|
|
add_ecosystem(ecosystems, "scripted");
|
|
add_manifest(manifests, "scripted", "test_script", relative);
|
|
add_command_line(command_map, "scripted", "test", format!("sh {relative}"));
|
|
add_entrypoint(entrypoints, "scripted", "test_script", relative);
|
|
}
|
|
"README.md" => add_entrypoint(entrypoints, "scripted", "readme", relative),
|
|
_ => {}
|
|
}
|
|
|
|
if normalized_relative.starts_with("src/") {
|
|
scripted_layout.has_src = true;
|
|
}
|
|
if normalized_relative.starts_with("tests/") {
|
|
scripted_layout.has_tests = true;
|
|
}
|
|
if normalized_relative.starts_with("docs/") {
|
|
scripted_layout.has_docs = true;
|
|
}
|
|
}
|
|
|
|
impl ScriptedLayoutState {
|
|
fn finish(&self, ecosystems: &mut BTreeSet<String>, entrypoints: &mut Vec<EntryPoint>) {
|
|
if self.has_src {
|
|
add_ecosystem(ecosystems, "scripted");
|
|
add_entrypoint(entrypoints, "scripted", "source_dir", "src");
|
|
}
|
|
if self.has_tests {
|
|
add_ecosystem(ecosystems, "scripted");
|
|
add_entrypoint(entrypoints, "scripted", "test_dir", "tests");
|
|
}
|
|
if self.has_docs {
|
|
add_ecosystem(ecosystems, "scripted");
|
|
add_entrypoint(entrypoints, "scripted", "docs_dir", "docs");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn validate_github_workflows_dir(root: &Path) -> Result<(), CliError> {
|
|
let workflows = root.join(".github").join("workflows");
|
|
if workflows.exists() && !workflows.is_dir() {
|
|
return Err(CliError::runtime(format!(
|
|
"failed to read GitHub workflow directory {}: path is not a directory",
|
|
workflows.display()
|
|
)));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn detect_cargo_entrypoints(root: &Path, manifest: &Path, entrypoints: &mut Vec<EntryPoint>) {
|
|
let base = manifest.parent().unwrap_or(root);
|
|
let main = base.join("src").join("main.rs");
|
|
if main.exists() {
|
|
add_entrypoint(
|
|
entrypoints,
|
|
"cargo",
|
|
"rust_bin",
|
|
&relative_path(root, &main),
|
|
);
|
|
}
|
|
let lib = base.join("src").join("lib.rs");
|
|
if lib.exists() {
|
|
add_entrypoint(entrypoints, "cargo", "rust_lib", &relative_path(root, &lib));
|
|
}
|
|
}
|
|
|
|
fn detect_node_workspace(
|
|
root: &Path,
|
|
package_json: &Path,
|
|
ecosystems: &mut BTreeSet<String>,
|
|
manifests: &mut Vec<Manifest>,
|
|
command_map: &mut BTreeMap<String, CommandAccumulator>,
|
|
entrypoints: &mut Vec<EntryPoint>,
|
|
) -> Result<(), CliError> {
|
|
let relative = relative_path(root, package_json);
|
|
let raw = read_bounded_text_file(package_json, "package.json")?;
|
|
let parsed = serde_json::from_str::<Value>(&raw).map_err(|error| {
|
|
CliError::runtime(format!(
|
|
"failed to parse package.json {}: {error}",
|
|
package_json.display()
|
|
))
|
|
})?;
|
|
let manager = detect_node_manager(package_json, &parsed);
|
|
add_ecosystem(ecosystems, manager);
|
|
add_manifest(manifests, manager, "package_json", &relative);
|
|
add_default_node_commands(command_map, manager, &parsed);
|
|
add_node_entrypoints(root, package_json, manager, &parsed, entrypoints);
|
|
Ok(())
|
|
}
|
|
|
|
fn detect_node_manager(path: &Path, package_json: &Value) -> &'static str {
|
|
let base = path.parent().unwrap_or_else(|| Path::new("."));
|
|
if base.join("pnpm-lock.yaml").exists() {
|
|
return "pnpm";
|
|
}
|
|
if base.join("yarn.lock").exists() {
|
|
return "yarn";
|
|
}
|
|
if base.join("bun.lock").exists() || base.join("bun.lockb").exists() {
|
|
return "bun";
|
|
}
|
|
let package_manager = package_json
|
|
.get("packageManager")
|
|
.and_then(Value::as_str)
|
|
.unwrap_or_default();
|
|
if package_manager.starts_with("pnpm@") {
|
|
"pnpm"
|
|
} else if package_manager.starts_with("yarn@") {
|
|
"yarn"
|
|
} else if package_manager.starts_with("bun@") {
|
|
"bun"
|
|
} else {
|
|
"npm"
|
|
}
|
|
}
|
|
|
|
fn add_default_node_commands(
|
|
command_map: &mut BTreeMap<String, CommandAccumulator>,
|
|
manager: &str,
|
|
package_json: &Value,
|
|
) {
|
|
let scripts = package_json.get("scripts").and_then(Value::as_object);
|
|
if let Some(scripts) = scripts {
|
|
if scripts.contains_key("build") {
|
|
add_command_line(
|
|
command_map,
|
|
manager,
|
|
"build",
|
|
node_script_command(manager, "build"),
|
|
);
|
|
}
|
|
if scripts.contains_key("test") {
|
|
add_command_line(
|
|
command_map,
|
|
manager,
|
|
"test",
|
|
node_script_command(manager, "test"),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn node_script_command(manager: &str, script: &str) -> String {
|
|
match manager {
|
|
"yarn" => format!("yarn {script}"),
|
|
"bun" => format!("bun run {script}"),
|
|
"pnpm" => format!("pnpm run {script}"),
|
|
_ => format!("npm run {script}"),
|
|
}
|
|
}
|
|
|
|
fn add_node_entrypoints(
|
|
root: &Path,
|
|
package_json_path: &Path,
|
|
manager: &str,
|
|
package_json: &Value,
|
|
entrypoints: &mut Vec<EntryPoint>,
|
|
) {
|
|
let base = package_json_path.parent().unwrap_or(root);
|
|
if let Some(main) = package_json.get("main").and_then(Value::as_str) {
|
|
let path = base.join(main);
|
|
add_entrypoint(
|
|
entrypoints,
|
|
manager,
|
|
"node_main",
|
|
&relative_path(root, &path),
|
|
);
|
|
}
|
|
if let Some(bin) = package_json.get("bin") {
|
|
match bin {
|
|
Value::String(path_text) => {
|
|
let path = base.join(path_text);
|
|
add_entrypoint(
|
|
entrypoints,
|
|
manager,
|
|
"node_bin",
|
|
&relative_path(root, &path),
|
|
);
|
|
}
|
|
Value::Object(map) => {
|
|
for value in map.values() {
|
|
if let Some(path_text) = value.as_str() {
|
|
let path = base.join(path_text);
|
|
add_entrypoint(
|
|
entrypoints,
|
|
manager,
|
|
"node_bin",
|
|
&relative_path(root, &path),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn detect_python_project(
|
|
root: &Path,
|
|
pyproject: &Path,
|
|
ecosystems: &mut BTreeSet<String>,
|
|
manifests: &mut Vec<Manifest>,
|
|
command_map: &mut BTreeMap<String, CommandAccumulator>,
|
|
entrypoints: &mut Vec<EntryPoint>,
|
|
) -> Result<(), CliError> {
|
|
let relative = relative_path(root, pyproject);
|
|
add_ecosystem(ecosystems, "python");
|
|
add_manifest(manifests, "python", "pyproject_toml", &relative);
|
|
add_commands(command_map, "python", "python -m build", "pytest");
|
|
|
|
let raw = read_bounded_text_file(pyproject, "pyproject")?;
|
|
let parsed = raw.parse::<toml::Value>().map_err(|error| {
|
|
CliError::runtime(format!(
|
|
"failed to parse pyproject {}: {error}",
|
|
pyproject.display()
|
|
))
|
|
})?;
|
|
let scripts = parsed
|
|
.get("project")
|
|
.and_then(|value| value.get("scripts"))
|
|
.and_then(toml::Value::as_table);
|
|
if let Some(table) = scripts {
|
|
for (name, _) in table {
|
|
add_entrypoint(
|
|
entrypoints,
|
|
"python",
|
|
"project_script",
|
|
&format!("{relative}::{name}"),
|
|
);
|
|
}
|
|
}
|
|
let poetry_scripts = parsed
|
|
.get("tool")
|
|
.and_then(|value| value.get("poetry"))
|
|
.and_then(|value| value.get("scripts"))
|
|
.and_then(toml::Value::as_table);
|
|
if let Some(table) = poetry_scripts {
|
|
for (name, _) in table {
|
|
add_entrypoint(
|
|
entrypoints,
|
|
"python",
|
|
"poetry_script",
|
|
&format!("{relative}::{name}"),
|
|
);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
fn detect_scripted_layout(
|
|
root: &Path,
|
|
files: &[PathBuf],
|
|
ecosystems: &mut BTreeSet<String>,
|
|
manifests: &mut Vec<Manifest>,
|
|
command_map: &mut BTreeMap<String, CommandAccumulator>,
|
|
entrypoints: &mut Vec<EntryPoint>,
|
|
) {
|
|
let mut scripted_layout = ScriptedLayoutState::default();
|
|
for file in files {
|
|
let relative = relative_path(root, file);
|
|
let normalized_relative = normalize_separators(&relative);
|
|
scan_scripted_layout_path(
|
|
&relative,
|
|
&normalized_relative,
|
|
ecosystems,
|
|
manifests,
|
|
command_map,
|
|
entrypoints,
|
|
&mut scripted_layout,
|
|
);
|
|
}
|
|
scripted_layout.finish(ecosystems, entrypoints);
|
|
dedup_manifests(manifests);
|
|
dedup_entrypoints(entrypoints);
|
|
}
|
|
|
|
fn detect_go_entrypoints(root: &Path, go_mod: &Path, entrypoints: &mut Vec<EntryPoint>) {
|
|
let base = go_mod.parent().unwrap_or(root);
|
|
let main = base.join("main.go");
|
|
if main.exists() {
|
|
add_entrypoint(entrypoints, "go", "go_main", &relative_path(root, &main));
|
|
}
|
|
let cmd_dir = base.join("cmd");
|
|
if !cmd_dir.exists() {
|
|
return;
|
|
}
|
|
if let Ok(entries) = fs::read_dir(cmd_dir) {
|
|
for entry in entries.flatten() {
|
|
let main_path = entry.path().join("main.go");
|
|
if main_path.exists() {
|
|
add_entrypoint(
|
|
entrypoints,
|
|
"go",
|
|
"go_cmd",
|
|
&relative_path(root, &main_path),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn detect_make_commands(
|
|
makefile: &Path,
|
|
command_map: &mut BTreeMap<String, CommandAccumulator>,
|
|
) -> Result<(), CliError> {
|
|
let content = read_bounded_text_file(makefile, "Makefile")?;
|
|
add_command_line(command_map, "make", "build", "make".to_string());
|
|
if content.lines().any(|line| {
|
|
let trimmed = line.trim_start();
|
|
trimmed.starts_with("test:") || trimmed.starts_with("check:")
|
|
}) {
|
|
add_command_line(command_map, "make", "test", "make test".to_string());
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn detect_github_actions(root: &Path, ci: &mut Vec<CiHint>) -> Result<(), CliError> {
|
|
let workflows = root.join(".github").join("workflows");
|
|
if !workflows.exists() {
|
|
return Ok(());
|
|
}
|
|
let entries = fs::read_dir(&workflows).map_err(|error| {
|
|
CliError::runtime(format!(
|
|
"failed to read GitHub workflow directory {}: {error}",
|
|
workflows.display()
|
|
))
|
|
})?;
|
|
for entry in entries {
|
|
let entry = entry.map_err(|error| {
|
|
CliError::runtime(format!(
|
|
"failed to read workflow entry in {}: {error}",
|
|
workflows.display()
|
|
))
|
|
})?;
|
|
let path = entry.path();
|
|
let relative = relative_path(root, &path);
|
|
if is_yaml_path(&relative) {
|
|
ci.push(CiHint {
|
|
provider: "github_actions".to_string(),
|
|
kind: "workflow".to_string(),
|
|
path: relative,
|
|
});
|
|
}
|
|
}
|
|
dedup_ci(ci);
|
|
Ok(())
|
|
}
|
|
|
|
fn has_extension_case_insensitive(path_like: &str, extension: &str) -> bool {
|
|
Path::new(path_like)
|
|
.extension()
|
|
.and_then(|value| value.to_str())
|
|
.is_some_and(|value| value.eq_ignore_ascii_case(extension))
|
|
}
|
|
|
|
fn is_yaml_path(path: &str) -> bool {
|
|
has_extension_case_insensitive(path, "yml") || has_extension_case_insensitive(path, "yaml")
|
|
}
|
|
|
|
fn add_ecosystem(ecosystems: &mut BTreeSet<String>, ecosystem: &str) {
|
|
ecosystems.insert(ecosystem.to_string());
|
|
}
|
|
|
|
fn add_manifest(manifests: &mut Vec<Manifest>, ecosystem: &str, kind: &str, path: &str) {
|
|
manifests.push(Manifest {
|
|
ecosystem: ecosystem.to_string(),
|
|
kind: kind.to_string(),
|
|
path: path.to_string(),
|
|
});
|
|
}
|
|
|
|
fn add_entrypoint(entrypoints: &mut Vec<EntryPoint>, ecosystem: &str, kind: &str, path: &str) {
|
|
entrypoints.push(EntryPoint {
|
|
ecosystem: ecosystem.to_string(),
|
|
kind: kind.to_string(),
|
|
path: path.to_string(),
|
|
});
|
|
}
|
|
|
|
fn add_commands(
|
|
command_map: &mut BTreeMap<String, CommandAccumulator>,
|
|
ecosystem: &str,
|
|
build: &str,
|
|
test: &str,
|
|
) {
|
|
add_command_line(command_map, ecosystem, "build", build.to_string());
|
|
add_command_line(command_map, ecosystem, "test", test.to_string());
|
|
}
|
|
|
|
fn add_command_line(
|
|
command_map: &mut BTreeMap<String, CommandAccumulator>,
|
|
ecosystem: &str,
|
|
kind: &str,
|
|
value: String,
|
|
) {
|
|
let entry = command_map.entry(ecosystem.to_string()).or_default();
|
|
match kind {
|
|
"build" => {
|
|
entry.build.insert(value);
|
|
}
|
|
"test" => {
|
|
entry.test.insert(value);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
fn dedup_manifests(manifests: &mut Vec<Manifest>) {
|
|
manifests.sort_by(|left, right| {
|
|
(
|
|
left.ecosystem.as_str(),
|
|
left.kind.as_str(),
|
|
left.path.as_str(),
|
|
)
|
|
.cmp(&(
|
|
right.ecosystem.as_str(),
|
|
right.kind.as_str(),
|
|
right.path.as_str(),
|
|
))
|
|
});
|
|
manifests.dedup_by(|left, right| {
|
|
left.ecosystem == right.ecosystem && left.kind == right.kind && left.path == right.path
|
|
});
|
|
}
|
|
|
|
fn dedup_entrypoints(entrypoints: &mut Vec<EntryPoint>) {
|
|
entrypoints.sort_by(|left, right| {
|
|
(
|
|
left.ecosystem.as_str(),
|
|
left.kind.as_str(),
|
|
left.path.as_str(),
|
|
)
|
|
.cmp(&(
|
|
right.ecosystem.as_str(),
|
|
right.kind.as_str(),
|
|
right.path.as_str(),
|
|
))
|
|
});
|
|
entrypoints.dedup_by(|left, right| {
|
|
left.ecosystem == right.ecosystem && left.kind == right.kind && left.path == right.path
|
|
});
|
|
}
|
|
|
|
fn dedup_ci(ci: &mut Vec<CiHint>) {
|
|
ci.sort_by(|left, right| {
|
|
(
|
|
left.provider.as_str(),
|
|
left.kind.as_str(),
|
|
left.path.as_str(),
|
|
)
|
|
.cmp(&(
|
|
right.provider.as_str(),
|
|
right.kind.as_str(),
|
|
right.path.as_str(),
|
|
))
|
|
});
|
|
ci.dedup_by(|left, right| {
|
|
left.provider == right.provider && left.kind == right.kind && left.path == right.path
|
|
});
|
|
}
|
|
|
|
fn read_bounded_text_file(path: &Path, label: &str) -> Result<String, CliError> {
|
|
read_bounded_text_file_with_limit(path, label, MAX_MANIFEST_BYTES)
|
|
}
|
|
|
|
fn read_bounded_text_file_with_limit(
|
|
path: &Path,
|
|
label: &str,
|
|
max_manifest_bytes: u64,
|
|
) -> Result<String, CliError> {
|
|
let metadata = fs::metadata(path).map_err(|error| {
|
|
if error.kind() == std::io::ErrorKind::NotFound {
|
|
CliError::runtime(format!("failed to read {}: {error}", path.display()))
|
|
} else {
|
|
CliError::runtime(format!("failed to inspect {}: {error}", path.display()))
|
|
}
|
|
})?;
|
|
if metadata.len() > max_manifest_bytes {
|
|
return Err(CliError::runtime(format!(
|
|
"refusing to read {label} {} because it is {} bytes; reposhape manifest files are capped at {max_manifest_bytes} bytes",
|
|
path.display(),
|
|
metadata.len()
|
|
)));
|
|
}
|
|
fs::read_to_string(path)
|
|
.map_err(|error| CliError::runtime(format!("failed to read {}: {error}", path.display())))
|
|
}
|
|
|
|
fn relative_path(root: &Path, path: &Path) -> String {
|
|
path.strip_prefix(root)
|
|
.unwrap_or(path)
|
|
.display()
|
|
.to_string()
|
|
}
|
|
|
|
fn normalize_separators(path: &str) -> String {
|
|
path.replace('\\', "/")
|
|
}
|
|
|
|
fn render_summary(summary: &RepoSummary) -> String {
|
|
let mut output = format!(
|
|
"root={} ecosystems={} manifests={} commands={} entrypoints={} ci={}\n",
|
|
summary.root,
|
|
render_pipe_list(
|
|
&summary
|
|
.ecosystems
|
|
.iter()
|
|
.map(|item| item.name.clone())
|
|
.collect::<Vec<_>>()
|
|
),
|
|
summary.manifests.len(),
|
|
summary.commands.len(),
|
|
summary.entrypoints.len(),
|
|
summary.ci.len()
|
|
);
|
|
for manifest in summary.manifests.iter().take(8) {
|
|
let _ = writeln!(
|
|
output,
|
|
"manifest ecosystem={} kind={} path={}",
|
|
manifest.ecosystem, manifest.kind, manifest.path
|
|
);
|
|
}
|
|
append_omitted_line(&mut output, "manifest", summary.manifests.len(), 8);
|
|
for command in summary.commands.iter().take(6) {
|
|
let _ = writeln!(
|
|
output,
|
|
"command ecosystem={} build={} test={}",
|
|
command.ecosystem,
|
|
render_pipe_list(&command.build),
|
|
render_pipe_list(&command.test)
|
|
);
|
|
}
|
|
append_omitted_line(&mut output, "command", summary.commands.len(), 6);
|
|
for entrypoint in summary.entrypoints.iter().take(12) {
|
|
let _ = writeln!(
|
|
output,
|
|
"entrypoint ecosystem={} kind={} path={}",
|
|
entrypoint.ecosystem, entrypoint.kind, entrypoint.path
|
|
);
|
|
}
|
|
append_omitted_line(&mut output, "entrypoint", summary.entrypoints.len(), 12);
|
|
for pipeline in summary.ci.iter().take(6) {
|
|
let _ = writeln!(
|
|
output,
|
|
"ci provider={} kind={} path={}",
|
|
pipeline.provider, pipeline.kind, pipeline.path
|
|
);
|
|
}
|
|
append_omitted_line(&mut output, "ci", summary.ci.len(), 6);
|
|
output
|
|
}
|
|
|
|
fn append_omitted_line(output: &mut String, label: &str, total: usize, shown: usize) {
|
|
if total > shown {
|
|
let _ = writeln!(output, "{}_omitted={}", label, total - shown);
|
|
}
|
|
}
|
|
|
|
fn render_pipe_list(values: &[String]) -> String {
|
|
if values.is_empty() {
|
|
"-".to_string()
|
|
} else {
|
|
values.join("|")
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use std::collections::{BTreeMap, BTreeSet};
|
|
|
|
#[test]
|
|
fn parse_cli_supports_depth_hidden_and_path() {
|
|
let (_, cli) = parse_cli_from([
|
|
"reposhape",
|
|
"--json",
|
|
"--max-depth",
|
|
"2",
|
|
"--hidden",
|
|
"demo",
|
|
])
|
|
.expect("cli");
|
|
assert!(cli.common.json);
|
|
assert_eq!(cli.max_depth, Some(2));
|
|
assert!(cli.include_hidden);
|
|
assert_eq!(cli.path, Some(PathBuf::from("demo")));
|
|
}
|
|
|
|
#[test]
|
|
fn node_manager_and_relative_path_helpers_work() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
fs::write(
|
|
temp.path().join("package.json"),
|
|
"{\"scripts\":{\"build\":\"tsc\",\"test\":\"vitest\"}}",
|
|
)
|
|
.expect("package");
|
|
fs::write(temp.path().join("pnpm-lock.yaml"), "lockfileVersion: '9.0'").expect("lock");
|
|
let package = serde_json::from_str::<Value>(
|
|
&fs::read_to_string(temp.path().join("package.json")).expect("read package"),
|
|
)
|
|
.expect("json");
|
|
assert_eq!(
|
|
detect_node_manager(&temp.path().join("package.json"), &package),
|
|
"pnpm"
|
|
);
|
|
assert_eq!(
|
|
relative_path(temp.path(), &temp.path().join("package.json")),
|
|
"package.json"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn parse_cli_reports_help_version_and_usage_errors() {
|
|
let (help, _) = parse_cli_from(["reposhape", "--help"]).expect("help");
|
|
assert_eq!(help, ParseOutcome::Help);
|
|
|
|
let (version, _) = parse_cli_from(["reposhape", "--version"]).expect("version");
|
|
assert_eq!(version, ParseOutcome::Version);
|
|
|
|
let missing_depth = parse_cli_from(["reposhape", "--max-depth"]).expect_err("missing");
|
|
assert!(missing_depth.to_string().contains("--max-depth"));
|
|
|
|
let invalid_depth =
|
|
parse_cli_from(["reposhape", "--max-depth", "abc"]).expect_err("invalid depth");
|
|
assert!(
|
|
invalid_depth
|
|
.to_string()
|
|
.contains("invalid --max-depth value 'abc'")
|
|
);
|
|
|
|
let invalid_color =
|
|
parse_cli_from(["reposhape", "--color", "always"]).expect_err("invalid color");
|
|
assert!(
|
|
invalid_color
|
|
.to_string()
|
|
.contains("invalid --color value 'always'")
|
|
);
|
|
|
|
let unsupported = parse_cli_from(["reposhape", "--unknown"]).expect_err("unsupported");
|
|
assert!(unsupported.to_string().contains("unsupported argument"));
|
|
}
|
|
|
|
#[test]
|
|
fn inspect_repository_reports_missing_path() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
let cli = Cli {
|
|
common: CommonArgs::default(),
|
|
max_depth: None,
|
|
include_hidden: false,
|
|
path: Some(temp.path().join("missing")),
|
|
};
|
|
|
|
let error = inspect_repository(&cli).expect_err("missing path should fail");
|
|
assert!(error.to_string().contains("repository path does not exist"));
|
|
}
|
|
|
|
#[test]
|
|
fn inspect_repository_rejects_unbounded_large_file_sets() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
for index in 0..=3 {
|
|
fs::write(temp.path().join(format!("file-{index}.txt")), "x").expect("file");
|
|
}
|
|
let cli = Cli {
|
|
common: CommonArgs::default(),
|
|
max_depth: None,
|
|
include_hidden: false,
|
|
path: Some(temp.path().to_path_buf()),
|
|
};
|
|
|
|
let error = inspect_repository_with_file_cap(&cli, 2).expect_err("file cap should fail");
|
|
|
|
assert!(
|
|
error
|
|
.to_string()
|
|
.contains("reposhape scan exceeded 2 files")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn read_bounded_text_file_rejects_large_manifests() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
let path = temp.path().join("package.json");
|
|
fs::write(&path, vec![b' '; 129]).expect("large manifest");
|
|
|
|
let error = read_bounded_text_file_with_limit(&path, "package.json", 128)
|
|
.expect_err("manifest cap");
|
|
|
|
assert!(error.to_string().contains("manifest files are capped"));
|
|
}
|
|
|
|
#[test]
|
|
fn detect_node_manager_prefers_locks_then_package_manager_then_default() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
let package_path = temp.path().join("package.json");
|
|
|
|
assert_eq!(
|
|
detect_node_manager(&package_path, &serde_json::json!({})),
|
|
"npm"
|
|
);
|
|
assert_eq!(
|
|
detect_node_manager(
|
|
&package_path,
|
|
&serde_json::json!({"packageManager":"yarn@4.1.0"})
|
|
),
|
|
"yarn"
|
|
);
|
|
|
|
fs::write(temp.path().join("bun.lock"), "").expect("bun lock");
|
|
assert_eq!(
|
|
detect_node_manager(
|
|
&package_path,
|
|
&serde_json::json!({"packageManager":"pnpm@9.0.0"})
|
|
),
|
|
"bun"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn default_node_commands_and_script_command_variants_work() {
|
|
let mut command_map = BTreeMap::new();
|
|
|
|
add_default_node_commands(
|
|
&mut command_map,
|
|
"pnpm",
|
|
&serde_json::json!({"scripts":{"build":"tsc"}}),
|
|
);
|
|
let hints = command_map.get("pnpm").expect("pnpm hints");
|
|
assert!(hints.build.contains("pnpm run build"));
|
|
assert!(hints.test.is_empty());
|
|
|
|
add_default_node_commands(
|
|
&mut command_map,
|
|
"pnpm",
|
|
&serde_json::json!({"scripts":{"test":"vitest"}}),
|
|
);
|
|
let hints = command_map.get("pnpm").expect("pnpm hints");
|
|
assert!(hints.test.contains("pnpm run test"));
|
|
|
|
assert_eq!(node_script_command("yarn", "build"), "yarn build");
|
|
assert_eq!(node_script_command("bun", "build"), "bun run build");
|
|
assert_eq!(node_script_command("pnpm", "build"), "pnpm run build");
|
|
assert_eq!(node_script_command("npm", "build"), "npm run build");
|
|
}
|
|
|
|
#[test]
|
|
fn detect_node_workspace_supports_scripts_main_and_bin_object() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
let package_json = temp.path().join("package.json");
|
|
fs::write(
|
|
&package_json,
|
|
r#"{
|
|
"scripts":{"build":"tsc","test":"vitest"},
|
|
"main":"index.js",
|
|
"bin":{"tool":"bin/tool.js","alt":"bin/alt.js"},
|
|
"packageManager":"npm@10.5.0"
|
|
}"#,
|
|
)
|
|
.expect("package");
|
|
fs::write(temp.path().join("pnpm-lock.yaml"), "lockfileVersion: '9.0'").expect("lock");
|
|
|
|
let mut ecosystems = BTreeSet::new();
|
|
let mut manifests = Vec::new();
|
|
let mut command_map = BTreeMap::new();
|
|
let mut entrypoints = Vec::new();
|
|
|
|
detect_node_workspace(
|
|
temp.path(),
|
|
&package_json,
|
|
&mut ecosystems,
|
|
&mut manifests,
|
|
&mut command_map,
|
|
&mut entrypoints,
|
|
)
|
|
.expect("workspace detection");
|
|
|
|
assert!(ecosystems.contains("pnpm"));
|
|
assert!(manifests.iter().any(|manifest| {
|
|
manifest.ecosystem == "pnpm"
|
|
&& manifest.kind == "package_json"
|
|
&& manifest.path == "package.json"
|
|
}));
|
|
let hints = command_map.get("pnpm").expect("pnpm hints");
|
|
assert!(hints.build.contains("pnpm run build"));
|
|
assert!(hints.test.contains("pnpm run test"));
|
|
assert!(entrypoints.iter().any(|entrypoint| {
|
|
entrypoint.ecosystem == "pnpm"
|
|
&& entrypoint.kind == "node_main"
|
|
&& entrypoint.path == "index.js"
|
|
}));
|
|
assert_eq!(
|
|
entrypoints
|
|
.iter()
|
|
.filter(|entrypoint| entrypoint.kind == "node_bin")
|
|
.count(),
|
|
2
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn detect_node_workspace_reports_read_and_parse_errors() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
let missing = temp.path().join("missing-package.json");
|
|
let mut ecosystems = BTreeSet::new();
|
|
let mut manifests = Vec::new();
|
|
let mut command_map = BTreeMap::new();
|
|
let mut entrypoints = Vec::new();
|
|
|
|
let missing_error = detect_node_workspace(
|
|
temp.path(),
|
|
&missing,
|
|
&mut ecosystems,
|
|
&mut manifests,
|
|
&mut command_map,
|
|
&mut entrypoints,
|
|
)
|
|
.expect_err("missing package should fail");
|
|
assert!(missing_error.to_string().contains("failed to read"));
|
|
|
|
let broken = temp.path().join("package.json");
|
|
fs::write(&broken, "{not-json").expect("broken package");
|
|
let parse_error = detect_node_workspace(
|
|
temp.path(),
|
|
&broken,
|
|
&mut ecosystems,
|
|
&mut manifests,
|
|
&mut command_map,
|
|
&mut entrypoints,
|
|
)
|
|
.expect_err("broken package should fail");
|
|
assert!(
|
|
parse_error
|
|
.to_string()
|
|
.contains("failed to parse package.json")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn detect_python_project_collects_scripts_and_reports_parse_errors() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
let pyproject = temp.path().join("pyproject.toml");
|
|
fs::write(
|
|
&pyproject,
|
|
r#"
|
|
[project]
|
|
name = "demo"
|
|
[project.scripts]
|
|
serve = "demo:main"
|
|
[tool.poetry.scripts]
|
|
fmt = "demo:fmt"
|
|
"#,
|
|
)
|
|
.expect("pyproject");
|
|
|
|
let mut ecosystems = BTreeSet::new();
|
|
let mut manifests = Vec::new();
|
|
let mut command_map = BTreeMap::new();
|
|
let mut entrypoints = Vec::new();
|
|
detect_python_project(
|
|
temp.path(),
|
|
&pyproject,
|
|
&mut ecosystems,
|
|
&mut manifests,
|
|
&mut command_map,
|
|
&mut entrypoints,
|
|
)
|
|
.expect("python project");
|
|
|
|
assert!(ecosystems.contains("python"));
|
|
assert!(manifests.iter().any(|manifest| {
|
|
manifest.ecosystem == "python"
|
|
&& manifest.kind == "pyproject_toml"
|
|
&& manifest.path == "pyproject.toml"
|
|
}));
|
|
let hints = command_map.get("python").expect("python hints");
|
|
assert!(hints.build.contains("python -m build"));
|
|
assert!(hints.test.contains("pytest"));
|
|
assert!(entrypoints.iter().any(|entrypoint| {
|
|
entrypoint.kind == "project_script" && entrypoint.path == "pyproject.toml::serve"
|
|
}));
|
|
assert!(entrypoints.iter().any(|entrypoint| {
|
|
entrypoint.kind == "poetry_script" && entrypoint.path == "pyproject.toml::fmt"
|
|
}));
|
|
|
|
fs::write(&pyproject, "[project\nname = \"broken\"").expect("broken pyproject");
|
|
let parse_error = detect_python_project(
|
|
temp.path(),
|
|
&pyproject,
|
|
&mut ecosystems,
|
|
&mut manifests,
|
|
&mut command_map,
|
|
&mut entrypoints,
|
|
)
|
|
.expect_err("broken pyproject should fail");
|
|
assert!(
|
|
parse_error
|
|
.to_string()
|
|
.contains("failed to parse pyproject")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn detect_go_entrypoints_finds_root_and_cmd_main_files() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
let go_mod = temp.path().join("go.mod");
|
|
fs::write(&go_mod, "module example.com/demo\n").expect("go.mod");
|
|
fs::create_dir_all(temp.path().join("cmd").join("server")).expect("cmd dir");
|
|
fs::create_dir_all(temp.path().join("cmd").join("worker")).expect("cmd dir");
|
|
fs::write(temp.path().join("main.go"), "package main\n").expect("main");
|
|
fs::write(
|
|
temp.path().join("cmd").join("server").join("main.go"),
|
|
"package main\n",
|
|
)
|
|
.expect("cmd main");
|
|
|
|
let mut entrypoints = Vec::new();
|
|
detect_go_entrypoints(temp.path(), &go_mod, &mut entrypoints);
|
|
|
|
assert!(entrypoints.iter().any(|entrypoint| {
|
|
entrypoint.ecosystem == "go"
|
|
&& entrypoint.kind == "go_main"
|
|
&& entrypoint.path == "main.go"
|
|
}));
|
|
assert!(entrypoints.iter().any(|entrypoint| {
|
|
entrypoint.ecosystem == "go"
|
|
&& entrypoint.kind == "go_cmd"
|
|
&& entrypoint.path.replace('\\', "/") == "cmd/server/main.go"
|
|
}));
|
|
assert!(
|
|
!entrypoints
|
|
.iter()
|
|
.any(|entrypoint| entrypoint.path.replace('\\', "/") == "cmd/worker/main.go")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn detect_scripted_layout_surfaces_manifestless_build_projects() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
fs::create_dir_all(temp.path().join("src")).expect("src dir");
|
|
fs::create_dir_all(temp.path().join("tests")).expect("tests dir");
|
|
fs::create_dir_all(temp.path().join("docs")).expect("docs dir");
|
|
fs::write(temp.path().join("build.ps1"), "Write-Host build").expect("build script");
|
|
fs::write(temp.path().join("README.md"), "# demo").expect("readme");
|
|
fs::write(temp.path().join("src").join("Plugin.cs"), "class Plugin {}").expect("source");
|
|
fs::write(
|
|
temp.path().join("tests").join("PluginTests.cs"),
|
|
"class PluginTests {}",
|
|
)
|
|
.expect("test source");
|
|
|
|
let files = vec![
|
|
temp.path().join("build.ps1"),
|
|
temp.path().join("README.md"),
|
|
temp.path().join("src").join("Plugin.cs"),
|
|
temp.path().join("tests").join("PluginTests.cs"),
|
|
temp.path().join("docs").join("notes.md"),
|
|
];
|
|
let mut ecosystems = BTreeSet::new();
|
|
let mut manifests = Vec::new();
|
|
let mut command_map = BTreeMap::new();
|
|
let mut entrypoints = Vec::new();
|
|
|
|
detect_scripted_layout(
|
|
temp.path(),
|
|
&files,
|
|
&mut ecosystems,
|
|
&mut manifests,
|
|
&mut command_map,
|
|
&mut entrypoints,
|
|
);
|
|
|
|
assert!(ecosystems.contains("scripted"));
|
|
assert!(manifests.iter().any(|manifest| {
|
|
manifest.ecosystem == "scripted"
|
|
&& manifest.kind == "build_script"
|
|
&& normalize_separators(&manifest.path) == "build.ps1"
|
|
}));
|
|
let scripted = command_map.get("scripted").expect("scripted commands");
|
|
assert!(scripted.build.contains("pwsh -NoProfile -File build.ps1"));
|
|
assert!(entrypoints.iter().any(|entrypoint| {
|
|
entrypoint.ecosystem == "scripted"
|
|
&& entrypoint.kind == "source_dir"
|
|
&& entrypoint.path == "src"
|
|
}));
|
|
assert!(entrypoints.iter().any(|entrypoint| {
|
|
entrypoint.ecosystem == "scripted"
|
|
&& entrypoint.kind == "test_dir"
|
|
&& entrypoint.path == "tests"
|
|
}));
|
|
assert!(entrypoints.iter().any(|entrypoint| {
|
|
entrypoint.ecosystem == "scripted"
|
|
&& entrypoint.kind == "docs_dir"
|
|
&& entrypoint.path == "docs"
|
|
}));
|
|
}
|
|
|
|
#[test]
|
|
fn detect_make_commands_handles_test_and_check_targets() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
let makefile = temp.path().join("Makefile");
|
|
fs::write(&makefile, "build:\n\t@echo build\ncheck:\n\t@echo check\n").expect("makefile");
|
|
|
|
let mut command_map = BTreeMap::new();
|
|
detect_make_commands(&makefile, &mut command_map).expect("make commands");
|
|
let hints = command_map.get("make").expect("make hints");
|
|
assert!(hints.build.contains("make"));
|
|
assert!(hints.test.contains("make test"));
|
|
|
|
fs::write(&makefile, "build:\n\t@echo build\n").expect("makefile");
|
|
let mut command_map = BTreeMap::new();
|
|
detect_make_commands(&makefile, &mut command_map).expect("make commands");
|
|
let hints = command_map.get("make").expect("make hints");
|
|
assert!(hints.build.contains("make"));
|
|
assert!(hints.test.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn detect_github_actions_filters_yaml_and_reports_directory_errors() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
let workflows = temp.path().join(".github").join("workflows");
|
|
fs::create_dir_all(&workflows).expect("workflows");
|
|
fs::write(workflows.join("ci.yml"), "name: ci\n").expect("ci");
|
|
fs::write(workflows.join("release.yaml"), "name: release\n").expect("release");
|
|
fs::write(workflows.join("notes.txt"), "ignore\n").expect("notes");
|
|
|
|
let mut ci = Vec::new();
|
|
detect_github_actions(temp.path(), &mut ci).expect("github actions");
|
|
assert_eq!(ci.len(), 2);
|
|
assert!(
|
|
ci.iter()
|
|
.any(|hint| hint.path.replace('\\', "/") == ".github/workflows/ci.yml")
|
|
);
|
|
assert!(
|
|
ci.iter()
|
|
.any(|hint| hint.path.replace('\\', "/") == ".github/workflows/release.yaml")
|
|
);
|
|
|
|
let broken = tempfile::tempdir().expect("broken tempdir");
|
|
let broken_github = broken.path().join(".github");
|
|
fs::create_dir_all(&broken_github).expect("broken github dir");
|
|
fs::write(broken_github.join("workflows"), "not a directory").expect("broken workflows");
|
|
let mut ci = Vec::new();
|
|
let error =
|
|
detect_github_actions(broken.path(), &mut ci).expect_err("workflows file should fail");
|
|
assert!(
|
|
error
|
|
.to_string()
|
|
.contains("failed to read GitHub workflow directory")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn inspect_repository_detects_mixed_repo_layouts_in_one_pass() {
|
|
let temp = tempfile::tempdir().expect("tempdir");
|
|
fs::create_dir_all(temp.path().join(".github/workflows")).expect("workflow dir");
|
|
fs::create_dir_all(temp.path().join("src")).expect("src dir");
|
|
fs::create_dir_all(temp.path().join("tests")).expect("tests dir");
|
|
fs::create_dir_all(temp.path().join("docs")).expect("docs dir");
|
|
fs::create_dir_all(temp.path().join("cmd/demo")).expect("cmd dir");
|
|
|
|
fs::write(
|
|
temp.path().join("Cargo.toml"),
|
|
"[package]\nname='demo'\nversion='0.1.0'\n",
|
|
)
|
|
.expect("cargo");
|
|
fs::write(
|
|
temp.path().join("package.json"),
|
|
r#"{"packageManager":"pnpm@9.0.0","scripts":{"build":"tsc","test":"vitest"},"main":"index.js"}"#,
|
|
)
|
|
.expect("package");
|
|
fs::write(temp.path().join("pnpm-lock.yaml"), "lockfileVersion: '9.0'").expect("pnpm");
|
|
fs::write(
|
|
temp.path().join("pyproject.toml"),
|
|
"[project]\nname='demo'\n[project.scripts]\nserve='demo:main'\n",
|
|
)
|
|
.expect("pyproject");
|
|
fs::write(temp.path().join("go.mod"), "module example.com/demo\n").expect("go");
|
|
fs::write(temp.path().join("CMakeLists.txt"), "project(demo)\n").expect("cmake");
|
|
fs::write(temp.path().join("Makefile"), "test:\n\tpytest\n").expect("make");
|
|
fs::write(temp.path().join("build.ps1"), "Write-Host build\n").expect("build script");
|
|
fs::write(temp.path().join("test.sh"), "pytest\n").expect("test script");
|
|
fs::write(temp.path().join("requirements.txt"), "pytest\n").expect("requirements");
|
|
fs::write(
|
|
temp.path().join(".github/workflows/ci.yml"),
|
|
"name: ci\non: [push]\n",
|
|
)
|
|
.expect("workflow");
|
|
fs::write(temp.path().join("src/main.rs"), "fn main() {}\n").expect("src");
|
|
fs::write(
|
|
temp.path().join("tests/test_demo.py"),
|
|
"def test_demo():\n assert True\n",
|
|
)
|
|
.expect("tests");
|
|
fs::write(temp.path().join("docs/guide.md"), "# guide\n").expect("docs");
|
|
fs::write(
|
|
temp.path().join("cmd/demo/main.go"),
|
|
"package main\nfunc main() {}\n",
|
|
)
|
|
.expect("go main");
|
|
|
|
let summary = inspect_repository(&Cli {
|
|
common: CommonArgs::default(),
|
|
max_depth: None,
|
|
include_hidden: true,
|
|
path: Some(temp.path().to_path_buf()),
|
|
})
|
|
.expect("summary");
|
|
|
|
let ecosystems = summary
|
|
.ecosystems
|
|
.iter()
|
|
.map(|ecosystem| ecosystem.name.as_str())
|
|
.collect::<BTreeSet<_>>();
|
|
assert!(ecosystems.contains("cargo"));
|
|
assert!(ecosystems.contains("pnpm"));
|
|
assert!(ecosystems.contains("python"));
|
|
assert!(ecosystems.contains("go"));
|
|
assert!(ecosystems.contains("cmake"));
|
|
assert!(ecosystems.contains("make"));
|
|
assert!(ecosystems.contains("scripted"));
|
|
assert!(
|
|
summary
|
|
.ci
|
|
.iter()
|
|
.any(|hint| normalize_separators(&hint.path) == ".github/workflows/ci.yml")
|
|
);
|
|
assert!(
|
|
summary
|
|
.entrypoints
|
|
.iter()
|
|
.any(|entrypoint| entrypoint.path == "src")
|
|
);
|
|
assert!(summary.commands.iter().any(|command| {
|
|
command.ecosystem == "cargo" && command.build.contains(&"cargo build".to_string())
|
|
}));
|
|
assert!(summary.commands.iter().any(|command| {
|
|
command.ecosystem == "scripted"
|
|
&& command
|
|
.build
|
|
.iter()
|
|
.any(|value| value.contains("build.ps1"))
|
|
}));
|
|
}
|
|
|
|
#[test]
|
|
fn dedup_helpers_sort_and_remove_duplicates() {
|
|
let mut manifests = vec![
|
|
Manifest {
|
|
ecosystem: "python".to_string(),
|
|
kind: "pyproject_toml".to_string(),
|
|
path: "pyproject.toml".to_string(),
|
|
},
|
|
Manifest {
|
|
ecosystem: "cargo".to_string(),
|
|
kind: "cargo_toml".to_string(),
|
|
path: "Cargo.toml".to_string(),
|
|
},
|
|
Manifest {
|
|
ecosystem: "python".to_string(),
|
|
kind: "pyproject_toml".to_string(),
|
|
path: "pyproject.toml".to_string(),
|
|
},
|
|
];
|
|
dedup_manifests(&mut manifests);
|
|
assert_eq!(manifests.len(), 2);
|
|
assert_eq!(manifests[0].ecosystem, "cargo");
|
|
assert_eq!(manifests[1].ecosystem, "python");
|
|
|
|
let mut entrypoints = vec![
|
|
EntryPoint {
|
|
ecosystem: "go".to_string(),
|
|
kind: "go_cmd".to_string(),
|
|
path: "cmd/server/main.go".to_string(),
|
|
},
|
|
EntryPoint {
|
|
ecosystem: "go".to_string(),
|
|
kind: "go_main".to_string(),
|
|
path: "main.go".to_string(),
|
|
},
|
|
EntryPoint {
|
|
ecosystem: "go".to_string(),
|
|
kind: "go_cmd".to_string(),
|
|
path: "cmd/server/main.go".to_string(),
|
|
},
|
|
];
|
|
dedup_entrypoints(&mut entrypoints);
|
|
assert_eq!(entrypoints.len(), 2);
|
|
assert_eq!(entrypoints[0].kind, "go_cmd");
|
|
assert_eq!(entrypoints[1].kind, "go_main");
|
|
|
|
let mut ci = vec![
|
|
CiHint {
|
|
provider: "github_actions".to_string(),
|
|
kind: "workflow".to_string(),
|
|
path: ".github/workflows/release.yaml".to_string(),
|
|
},
|
|
CiHint {
|
|
provider: "github_actions".to_string(),
|
|
kind: "workflow".to_string(),
|
|
path: ".github/workflows/ci.yml".to_string(),
|
|
},
|
|
CiHint {
|
|
provider: "github_actions".to_string(),
|
|
kind: "workflow".to_string(),
|
|
path: ".github/workflows/ci.yml".to_string(),
|
|
},
|
|
];
|
|
dedup_ci(&mut ci);
|
|
assert_eq!(ci.len(), 2);
|
|
assert_eq!(ci[0].path, ".github/workflows/ci.yml");
|
|
assert_eq!(ci[1].path, ".github/workflows/release.yaml");
|
|
}
|
|
|
|
#[test]
|
|
fn render_summary_and_pipe_list_cover_empty_and_populated_variants() {
|
|
let empty = RepoSummary {
|
|
root: "repo".to_string(),
|
|
ecosystems: Vec::new(),
|
|
manifests: Vec::new(),
|
|
commands: Vec::new(),
|
|
entrypoints: Vec::new(),
|
|
ci: Vec::new(),
|
|
};
|
|
let empty_rendered = render_summary(&empty);
|
|
assert!(
|
|
empty_rendered
|
|
.contains("root=repo ecosystems=- manifests=0 commands=0 entrypoints=0 ci=0")
|
|
);
|
|
assert_eq!(render_pipe_list(&[]), "-");
|
|
|
|
let populated = RepoSummary {
|
|
root: "repo".to_string(),
|
|
ecosystems: vec![Ecosystem {
|
|
name: "cargo".to_string(),
|
|
}],
|
|
manifests: vec![Manifest {
|
|
ecosystem: "cargo".to_string(),
|
|
kind: "cargo_toml".to_string(),
|
|
path: "Cargo.toml".to_string(),
|
|
}],
|
|
commands: vec![CommandHint {
|
|
ecosystem: "cargo".to_string(),
|
|
build: vec!["cargo build".to_string(), "cargo clippy".to_string()],
|
|
test: Vec::new(),
|
|
}],
|
|
entrypoints: vec![EntryPoint {
|
|
ecosystem: "cargo".to_string(),
|
|
kind: "rust_bin".to_string(),
|
|
path: "src/main.rs".to_string(),
|
|
}],
|
|
ci: vec![CiHint {
|
|
provider: "github_actions".to_string(),
|
|
kind: "workflow".to_string(),
|
|
path: ".github/workflows/ci.yml".to_string(),
|
|
}],
|
|
};
|
|
let rendered = render_summary(&populated);
|
|
assert!(rendered.contains("ecosystems=cargo manifests=1 commands=1 entrypoints=1 ci=1"));
|
|
assert!(rendered.contains("manifest ecosystem=cargo kind=cargo_toml path=Cargo.toml"));
|
|
assert!(rendered.contains("command ecosystem=cargo build=cargo build|cargo clippy test=-"));
|
|
assert!(rendered.contains("entrypoint ecosystem=cargo kind=rust_bin path=src/main.rs"));
|
|
assert!(
|
|
rendered
|
|
.contains("ci provider=github_actions kind=workflow path=.github/workflows/ci.yml")
|
|
);
|
|
}
|
|
}
|