cpp-amalgamate 1.0.1

cpp-amalgamate recursively combines C++ source files and the headers they include into a single output file. 
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
116
117

#![warn(
    // Lint groups
    future_incompatible,
    nonstandard_style,
    rust_2018_compatibility,
    rust_2018_idioms,
    rust_2021_compatibility,
    // Allow by default
    elided_lifetimes_in_paths,
    missing_debug_implementations,
    trivial_casts,
    trivial_numeric_casts,
    unused_extern_crates,
    unused_import_braces,
    unused_qualifications,
    // Clippy
    clippy::all,
    clippy::pedantic,
    clippy::cargo,
    clippy::clone_on_ref_ptr,
    clippy::decimal_literal_representation,
    clippy::filetype_is_file,
    clippy::float_cmp_const,
    clippy::get_unwrap,
    clippy::if_then_some_else_none,
    clippy::rc_mutex,
    clippy::rest_pat_in_fully_bound_structs,
    clippy::shadow_unrelated,
    clippy::todo,
    clippy::unimplemented,
    clippy::unwrap_used,
    clippy::verbose_file_reads,
)]
#![allow(clippy::module_name_repetitions, clippy::non_ascii_literal)]

mod cli;
mod filter;
mod logging;
mod process;
mod resolve;

use std::{
    env,
    fs::File,
    io::{self, BufWriter, Write},
    path::PathBuf,
};

use anyhow::{Context, Result};
use log::{error, info};

use crate::{
    cli::Opts,
    filter::InliningFilter,
    logging::ErrorHandling,
    process::{ErrorHandlingOpts, Processor},
    resolve::IncludeResolver,
};

fn run_with_writer(opts: &Opts, writer: impl Write) -> Result<()> {
    let resolver = IncludeResolver::new(
        opts.quote_search_dirs().map(PathBuf::from).collect(),
        opts.system_search_dirs().map(PathBuf::from).collect(),
    )?;
    let filter = InliningFilter::new(
        opts.quote_filter_globs().cloned(),
        opts.system_filter_globs().cloned(),
    )?;
    let error_handling_opts = ErrorHandlingOpts {
        cyclic_include: opts.cyclic_include_handling(),
        unresolvable_quote_include: opts.unresolvable_quote_include_handling(),
        unresolvable_system_include: opts.unresolvable_system_include_handling(),
    };
    let mut processor = Processor::new(
        writer,
        resolver,
        opts.line_directives,
        filter,
        error_handling_opts,
    );
    opts.files
        .iter()
        .try_for_each(|source_file| processor.process(source_file))
}

fn try_main() -> Result<()> {
    let opts = Opts::parse();

    let mut builder = env_logger::builder();
    if env::var_os("RUST_LOG_VERBOSE").is_some() {
        builder.format_timestamp_millis();
    } else {
        builder
            .format_level(true)
            .format_module_path(false)
            .format_target(false)
            .format_timestamp(None);
    }
    builder.filter_level(opts.log_level()).init();

    if let Some(out_file) = &opts.output {
        info!("Writing to {:?}", out_file);
        let writer = BufWriter::new(File::create(out_file).context("Failed to open output file")?);
        run_with_writer(&opts, writer)
    } else {
        info!("Writing to terminal");
        let stdout = io::stdout();
        run_with_writer(&opts, stdout.lock())
    }
}

fn main() {
    if let Err(error) = try_main() {
        error!("{:#}", error);
        std::process::exit(1);
    }
}