projd 0.1.0

Scan software projects and generate structured reports.
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

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

use anyhow::{Context, Result, bail};
use clap::{Parser, Subcommand, ValueEnum};
use projd_core::{ProjectScan, render_json, render_markdown, scan_path};

#[derive(Debug, Parser)]
#[command(name = "projd")]
#[command(version, about = projd_core::describe())]
struct Cli {
    #[command(subcommand)]
    command: Option<Command>,
}

#[derive(Debug, Subcommand)]
enum Command {
    /// Scan a local project directory.
    Scan {
        /// Project directory to scan.
        path: PathBuf,

        /// Output format.
        #[arg(short, long)]
        format: Option<OutputFormat>,

        /// Output file. If omitted, rendered content is printed to stdout.
        #[arg(short, long)]
        output: Option<PathBuf>,

        /// Replace the output file if it already exists.
        #[arg(long)]
        overwrite: bool,
    },
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
enum OutputFormat {
    Markdown,
    Json,
}

impl OutputFormat {
    fn detect_path(path: &Path) -> Option<Self> {
        let extension = path.extension()?.to_str()?.to_ascii_lowercase();
        match extension.as_str() {
            "md" | "markdown" => Some(Self::Markdown),
            "json" => Some(Self::Json),
            _ => None,
        }
    }
}

fn main() -> Result<()> {
    let cli = Cli::parse();

    match cli.command {
        Some(Command::Scan {
            path,
            format,
            output,
            overwrite,
        }) => {
            let format = choose_output_format(format, output.as_deref());
            let scan = scan_path(path)?;
            let rendered = render_scan(&scan, format)?;
            write_or_print(rendered, output, overwrite)
        }
        None => {
            println!("{} {}", projd_core::NAME, projd_core::VERSION);
            println!("{}", projd_core::describe());
            Ok(())
        }
    }
}

fn choose_output_format(format: Option<OutputFormat>, output: Option<&Path>) -> OutputFormat {
    format
        .or_else(|| output.and_then(OutputFormat::detect_path))
        .unwrap_or(OutputFormat::Markdown)
}

fn render_scan(scan: &ProjectScan, format: OutputFormat) -> Result<String> {
    match format {
        OutputFormat::Markdown => Ok(render_markdown(scan)),
        OutputFormat::Json => render_json(scan).map(|json| format!("{json}\n")),
    }
}

fn write_or_print(rendered: String, output: Option<PathBuf>, overwrite: bool) -> Result<()> {
    let Some(output) = output else {
        print!("{rendered}");
        return Ok(());
    };

    if output.exists() && !overwrite {
        bail!(
            "refusing to overwrite existing output file `{}`",
            output.display()
        );
    }

    fs::write(&output, rendered)
        .with_context(|| format!("failed to write output file `{}`", output.display()))?;
    Ok(())
}