adrs 0.7.6

Command line tool for managing Architecture Decision Records
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

//! Export commands.

use adrs_core::{JsonAdr, Repository, export_adr, export_directory, export_repository};
use anyhow::{Context, Result};
use std::path::Path;

/// Export ADRs to JSON-ADR format.
///
/// If `dir` is provided, exports from that directory without requiring an adrs repository.
/// Otherwise, exports from the repository at `root`.
///
/// Options:
/// - `metadata_only`: If true, excludes content fields (context, decision, consequences)
///   and sets source_uri based on base_url.
/// - `base_url`: Base URL for constructing source_uri values.
pub fn export_json(
    root: &Path,
    adr_number: Option<u32>,
    dir: Option<&Path>,
    pretty: bool,
    metadata_only: bool,
    base_url: Option<String>,
) -> Result<()> {
    let json = if let Some(dir_path) = dir {
        // Export from arbitrary directory (no repo required)
        if adr_number.is_some() {
            anyhow::bail!("Cannot specify both --dir and an ADR number");
        }

        let mut export = export_directory(dir_path).context(format!(
            "Failed to export from directory: {}",
            dir_path.display()
        ))?;

        if metadata_only || base_url.is_some() {
            for adr in &mut export.adrs {
                apply_metadata_options(adr, metadata_only, &base_url);
            }
        }

        if pretty {
            serde_json::to_string_pretty(&export)?
        } else {
            serde_json::to_string(&export)?
        }
    } else {
        // Export from repository
        let repo = Repository::open(root).context("Failed to open ADR repository")?;

        if let Some(number) = adr_number {
            // Export single ADR
            let adr = repo
                .get(number)
                .context(format!("ADR {} not found", number))?;
            let mut json_adr = export_adr(&adr);

            if metadata_only || base_url.is_some() {
                apply_metadata_options(&mut json_adr, metadata_only, &base_url);
            }

            if pretty {
                serde_json::to_string_pretty(&json_adr)?
            } else {
                serde_json::to_string(&json_adr)?
            }
        } else {
            // Export all ADRs
            let mut export = export_repository(&repo)?;

            if metadata_only || base_url.is_some() {
                for adr in &mut export.adrs {
                    apply_metadata_options(adr, metadata_only, &base_url);
                }
            }

            if pretty {
                serde_json::to_string_pretty(&export)?
            } else {
                serde_json::to_string(&export)?
            }
        }
    };

    println!("{}", json);
    Ok(())
}

/// Apply metadata-only options to a JSON ADR.
fn apply_metadata_options(adr: &mut JsonAdr, metadata_only: bool, base_url: &Option<String>) {
    // Set source_uri from base_url and path
    if let Some(base) = base_url
        && let Some(path) = &adr.path
    {
        // Extract just the filename from the path
        let filename = std::path::Path::new(path)
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or(path);

        // Construct the full URI
        let base_trimmed = base.trim_end_matches('/');
        adr.source_uri = Some(format!("{}/{}", base_trimmed, filename));
    }

    // Clear content fields if metadata_only
    if metadata_only {
        adr.context = None;
        adr.decision = None;
        adr.consequences = None;
        adr.confirmation = None;
        adr.decision_drivers.clear();
        adr.considered_options.clear();
        adr.custom_sections.clear();
    }
}