cargo-attribution 0.5.0

A cargo subcommand to give credit to your dependencies
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
110
111
112
113

// SPDX-License-Identifier: MPL-2.0
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

use std::path::PathBuf;

use cargo_attribution::{
    licenses,
    metadata::{self},
    serialize::{DependencySerialized, SelfSerialized},
};
use cargo_metadata::{CargoOpt, MetadataCommand};
use clap::Parser;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let CargoCli::Attribution(Args {
        manifest_path,
        current_dir,
        all_features,
        no_default_features,
        features,
        output_dir,
        filter_platform,
        only_normal_dependencies,
    }) = CargoCli::parse();

    let mut mc = MetadataCommand::new();
    mc.manifest_path(manifest_path);
    mc.current_dir(current_dir);

    if all_features {
        mc.features(CargoOpt::AllFeatures);
    }

    if no_default_features {
        mc.features(CargoOpt::NoDefaultFeatures);
    }

    if let Some(features) = features {
        mc.features(CargoOpt::SomeFeatures(features));
    }

    if let Some(platform) = filter_platform {
        mc.other_options(["--filter-platform".to_owned(), platform]);
    }

    let metadata = mc.exec()?;
    println!("Extracting Metadata");
    let (mut dependencies_data, crate_data) =
        metadata::get_data(metadata, only_normal_dependencies)?;
    println!("Complete Metadata");

    cargo_attribution::create_folder(&output_dir)?;

    let dependencies_file = DependencySerialized::new(&dependencies_data);
    dependencies_file.create_toml(&output_dir)?;

    if let Some(crate_data) = crate_data {
        let crate_file = SelfSerialized::new(&crate_data);
        crate_file.create_toml(&output_dir)?;
        dependencies_data.push(crate_data);
    }

    licenses::generate_licenses(&dependencies_data, output_dir).await?;
    Ok(())
}

#[derive(clap::Args)]
#[command(author, version, about)]
struct Args {
    /// Path to the Cargo.toml,
    #[arg(long, default_value = "./Cargo.toml")]
    manifest_path: PathBuf,

    /// Directory of the cargo process,
    #[arg(long, default_value = ".")]
    current_dir: PathBuf,

    /// Directory of the output files,
    #[arg(long, default_value = "./attribution")]
    output_dir: PathBuf,

    /// Activate all available features
    #[arg(long)]
    all_features: bool,

    /// Deactivate default features
    #[arg(long)]
    no_default_features: bool,

    /// Select features to activate,
    /// e.g. f1,f2,f3
    #[arg(long, value_delimiter = ',')]
    features: Option<Vec<String>>,

    /// Filter by target triple,
    /// e.g., "wasm32-unknown-unknown"
    #[arg(long)]
    filter_platform: Option<String>,

    /// Avoid dev, build, and unknown dependencies
    #[arg(long)]
    only_normal_dependencies: bool,
}

#[derive(Parser)]
#[command(name = "cargo")]
#[command(bin_name = "cargo")]
enum CargoCli {
    Attribution(Args),
}