ejectest 0.3.0

Extract inline #[cfg(test)] mod tests into separate _tests.rs files.
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
114
115

use std::path::PathBuf;
use std::process::ExitCode;

use anyhow::Result;
use clap::{Parser, Subcommand, ValueEnum};
use ejectest::{FileFilter, OutputFormat, read_file_list};

/// Extract inline `#[cfg(test)] mod tests { ... }` into separate `_tests.rs` files.
#[derive(Parser)]
#[command(name = "ejectest", version, about)]
struct Cli {
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    /// Extract inline test modules from a file or directory (writes by default).
    Apply {
        /// Rust source file or directory to process.
        path: PathBuf,
        /// Show what would be done without writing files.
        #[arg(long)]
        dry_run: bool,
        /// Output format.
        #[arg(long, value_enum, default_value_t = Format::Text)]
        format: Format,
        /// Process only files listed in the given file (use `-` for stdin).
        #[arg(long)]
        files_from: Option<String>,
        /// Allow missing files and paths outside root in the file list.
        #[arg(long)]
        lenient: bool,
    },
    /// Detect inline test modules without modifying (file or directory).
    Check {
        /// Rust source file or directory to scan.
        path: PathBuf,
        /// Output format.
        #[arg(long, value_enum, default_value_t = Format::Text)]
        format: Format,
        /// Check only files listed in the given file (use `-` for stdin).
        #[arg(long)]
        files_from: Option<String>,
        /// Allow missing files and paths outside root in the file list.
        #[arg(long)]
        lenient: bool,
    },
}

#[derive(Clone, Copy, ValueEnum)]
enum Format {
    Text,
    Json,
}

impl From<Format> for OutputFormat {
    fn from(format: Format) -> Self {
        match format {
            Format::Text => Self::Text,
            Format::Json => Self::Json,
        }
    }
}

fn build_filter(
    files_from: Option<&str>,
    root: &std::path::Path,
    lenient: bool,
) -> Result<Option<FileFilter>> {
    match files_from {
        Some(source) => {
            let paths = read_file_list(source)?;
            Ok(Some(FileFilter::from_paths(root, paths, lenient)?))
        }
        None => Ok(None),
    }
}

fn main() -> Result<ExitCode> {
    env_logger::init();

    match Cli::parse().command {
        Command::Apply {
            path,
            dry_run,
            format,
            files_from,
            lenient,
        } => {
            let filter = build_filter(files_from.as_deref(), &path, lenient)?;
            let report = ejectest::apply_path(&path, dry_run, filter.as_ref())?;
            print!(
                "{}",
                ejectest::render_apply(&report, format.into(), dry_run)
            );
            Ok(ExitCode::SUCCESS)
        }
        Command::Check {
            path,
            format,
            files_from,
            lenient,
        } => {
            let filter = build_filter(files_from.as_deref(), &path, lenient)?;
            let report = ejectest::check_path(&path, filter.as_ref())?;
            print!("{}", ejectest::render_check(&report, format.into()));
            if report.has_inline() {
                Ok(ExitCode::FAILURE)
            } else {
                Ok(ExitCode::SUCCESS)
            }
        }
    }
}