@owenlamont/ryl 0.4.1 → 0.4.3

package/src/main.rs

@@ -1,535 +0,0 @@
-#![forbid(unsafe_code)]
-#![deny(
-    clippy::all,
-    clippy::pedantic,
-    clippy::cargo,
-    clippy::cognitive_complexity
-)]
-
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::io::IsTerminal;
-use std::path::{Path, PathBuf};
-use std::process::ExitCode;
-
-use clap::{Parser, ValueEnum};
-use ignore::WalkBuilder;
-use rayon::prelude::*;
-use ryl::cli_support::resolve_ctx;
-use ryl::config::{ConfigContext, Overrides, YamlLintConfig, discover_config};
-use ryl::migrate::{
-    MigrateOptions, OutputMode as MigrateOutputMode, SourceCleanup, WriteMode,
-    migrate_configs,
-};
-use ryl::{LintProblem, Severity, lint_file};
-
-fn gather_inputs(inputs: &[PathBuf]) -> (Vec<PathBuf>, Vec<PathBuf>) {
-    let mut explicit_files = Vec::new();
-    let mut candidates = Vec::new();
-    for p in inputs {
-        if p.is_dir() {
-            let walker = WalkBuilder::new(p)
-                .hidden(false)
-                .ignore(true)
-                .git_ignore(true)
-                .git_global(true)
-                .git_exclude(true)
-                .follow_links(false)
-                .build();
-            for e in walker.flatten() {
-                let fp = e.path().to_path_buf();
-                if fp.is_file() {
-                    candidates.push(fp);
-                }
-            }
-        } else {
-            explicit_files.push(p.clone());
-        }
-    }
-    (candidates, explicit_files)
-}
-
-fn build_global_cfg(
-    inputs: &[PathBuf],
-    cli: &Cli,
-) -> Result<Option<ConfigContext>, String> {
-    if cli.config_data.is_some()
-        || cli.config_file.is_some()
-        || std::env::var("YAMLLINT_CONFIG_FILE").is_ok()
-    {
-        let config_data = cli.config_data.as_ref().map(|raw| {
-            if !raw.is_empty() && !raw.contains(':') {
-                format!("extends: {raw}")
-            } else {
-                raw.clone()
-            }
-        });
-        discover_config(
-            inputs,
-            &Overrides {
-                config_file: cli.config_file.clone(),
-                config_data,
-            },
-        )
-        .map(Some)
-    } else {
-        Ok(None)
-    }
-}
-
-fn run_migration(cli: &Cli) -> Result<ExitCode, String> {
-    let cleanup = if let Some(suffix) = &cli.migrate.rename_old {
-        SourceCleanup::RenameSuffix(suffix.clone())
-    } else if cli.migrate.delete_old {
-        SourceCleanup::Delete
-    } else {
-        SourceCleanup::Keep
-    };
-    let options = MigrateOptions {
-        root: cli
-            .migrate
-            .root
-            .clone()
-            .unwrap_or_else(|| PathBuf::from(".")),
-        write_mode: if cli.migrate.write {
-            WriteMode::Write
-        } else {
-            WriteMode::Preview
-        },
-        output_mode: if cli.migrate.stdout {
-            MigrateOutputMode::IncludeToml
-        } else {
-            MigrateOutputMode::SummaryOnly
-        },
-        cleanup,
-    };
-    let result = migrate_configs(&options)?;
-    for warning in result.warnings {
-        eprintln!("{warning}");
-    }
-    if result.entries.is_empty() {
-        println!(
-            "No legacy YAML config files found under {}",
-            options.root.display()
-        );
-        return Ok(ExitCode::SUCCESS);
-    }
-
-    for entry in &result.entries {
-        println!("{} -> {}", entry.source.display(), entry.target.display());
-    }
-    if options.output_mode == MigrateOutputMode::IncludeToml {
-        for entry in &result.entries {
-            println!("# {}", entry.target.display());
-            println!("{}", entry.toml);
-        }
-    }
-    Ok(ExitCode::SUCCESS)
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, ValueEnum)]
-enum CliFormat {
-    Auto,
-    Standard,
-    Colored,
-    Github,
-    Parsable,
-}
-
-#[derive(Parser, Debug)]
-#[command(name = "ryl", version, about = "Fast YAML linter written in Rust")]
-struct Cli {
-    /// One or more paths: files and/or directories
-    #[arg(value_name = "PATH_OR_FILE")]
-    inputs: Vec<PathBuf>,
-
-    /// Path to configuration file (YAML or TOML)
-    #[arg(short = 'c', long = "config-file", value_name = "FILE")]
-    config_file: Option<PathBuf>,
-
-    /// Inline configuration data (yaml)
-    #[arg(short = 'd', long = "config-data", value_name = "YAML")]
-    config_data: Option<String>,
-
-    /// Output format (auto, standard, colored, github, parsable)
-    #[arg(short = 'f', long = "format", default_value_t = CliFormat::Auto, value_enum)]
-    format: CliFormat,
-
-    /// Convert discovered legacy YAML config files into .ryl.toml files
-    #[arg(long = "migrate-configs", default_value_t = false)]
-    migrate_configs: bool,
-
-    #[command(flatten)]
-    lint: LintFlags,
-
-    #[command(flatten)]
-    migrate: MigrateFlags,
-}
-
-#[derive(clap::Args, Debug, Default)]
-struct LintFlags {
-    /// List files that would be linted (reserved)
-    #[arg(long = "list-files", default_value_t = false)]
-    list_files: bool,
-
-    /// Strict mode (reserved)
-    #[arg(short = 's', long = "strict", default_value_t = false)]
-    strict: bool,
-
-    /// Suppress warnings (reserved)
-    #[arg(long = "no-warnings", default_value_t = false)]
-    no_warnings: bool,
-}
-
-#[derive(clap::Args, Debug, Default)]
-struct MigrateFlags {
-    /// Root path to search for legacy YAML config files (default: .)
-    #[arg(
-        long = "migrate-root",
-        value_name = "DIR",
-        requires = "migrate_configs"
-    )]
-    root: Option<PathBuf>,
-
-    /// Write migrated .ryl.toml files (otherwise preview only)
-    #[arg(
-        long = "migrate-write",
-        default_value_t = false,
-        requires = "migrate_configs"
-    )]
-    write: bool,
-
-    /// Print generated TOML to stdout during migration
-    #[arg(
-        long = "migrate-stdout",
-        default_value_t = false,
-        requires = "migrate_configs"
-    )]
-    stdout: bool,
-
-    /// Rename source YAML configs by appending this suffix after migration
-    #[arg(
-        long = "migrate-rename-old",
-        value_name = "SUFFIX",
-        conflicts_with = "delete_old",
-        requires_all = ["write", "migrate_configs"]
-    )]
-    rename_old: Option<String>,
-
-    /// Delete source YAML configs after migration
-    #[arg(
-        long = "migrate-delete-old",
-        default_value_t = false,
-        conflicts_with = "rename_old",
-        requires_all = ["write", "migrate_configs"]
-    )]
-    delete_old: bool,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum OutputFormat {
-    Standard,
-    Colored,
-    Github,
-    Parsable,
-}
-
-fn detect_output_format(choice: CliFormat) -> OutputFormat {
-    match choice {
-        CliFormat::Standard => OutputFormat::Standard,
-        CliFormat::Colored => OutputFormat::Colored,
-        CliFormat::Github => OutputFormat::Github,
-        CliFormat::Parsable => OutputFormat::Parsable,
-        CliFormat::Auto => {
-            if github_env_active() {
-                OutputFormat::Github
-            } else if supports_color() {
-                OutputFormat::Colored
-            } else {
-                OutputFormat::Standard
-            }
-        }
-    }
-}
-
-fn github_env_active() -> bool {
-    std::env::var_os("GITHUB_ACTIONS").is_some()
-        && std::env::var_os("GITHUB_WORKFLOW").is_some()
-}
-
-fn supports_color() -> bool {
-    if std::env::var_os("NO_COLOR").is_some() {
-        return false;
-    }
-    if std::env::var_os("FORCE_COLOR").is_some() {
-        return true;
-    }
-    std::io::stderr().is_terminal()
-}
-
-fn main() -> ExitCode {
-    let cli = Cli::parse();
-
-    if cli.migrate_configs {
-        return match run_migration(&cli) {
-            Ok(code) => code,
-            Err(err) => {
-                eprintln!("{err}");
-                ExitCode::from(2)
-            }
-        };
-    }
-
-    if cli.inputs.is_empty() {
-        eprintln!("error: expected one or more paths (files and/or directories)");
-        return ExitCode::from(2);
-    }
-
-    // Build a global config if -d/-c provided or env var set; else None for per-file discovery.
-    let global_cfg = match build_global_cfg(&cli.inputs, &cli) {
-        Ok(cfg) => cfg,
-        Err(e) => {
-            eprintln!("{e}");
-            return ExitCode::from(2);
-        }
-    };
-    if let Some(cfg) = &global_cfg {
-        for notice in &cfg.notices {
-            eprintln!("{notice}");
-        }
-    }
-    let inputs = cli.inputs;
-
-    // Determine files to parse from mixed inputs.
-    // - Directories: recursively gather only .yml/.yaml
-    // - Files: include as-is (even if extension isn't yaml)
-    let (candidates, explicit_files) = gather_inputs(&inputs);
-
-    // Filter directory candidates via ignores, respecting global vs per-file behavior.
-    let mut cache: HashMap<PathBuf, (PathBuf, YamlLintConfig)> = HashMap::new();
-    let mut emitted_notices: HashSet<String> = HashSet::new();
-    let mut files: Vec<(PathBuf, PathBuf, YamlLintConfig)> = Vec::new();
-    for f in candidates {
-        let (base_dir, cfg, notices) =
-            match resolve_ctx(&f, global_cfg.as_ref(), &mut cache) {
-                Ok(pair) => pair,
-                Err(e) => {
-                    eprintln!("{e}");
-                    return ExitCode::from(2);
-                }
-            };
-        for notice in notices {
-            if emitted_notices.insert(notice.clone()) {
-                eprintln!("{notice}");
-            }
-        }
-        let ignored = cfg.is_file_ignored(&f, &base_dir);
-        let yaml_ok = cfg.is_yaml_candidate(&f, &base_dir);
-        if !ignored && yaml_ok {
-            files.push((f, base_dir, cfg));
-        }
-    }
-
-    for ef in explicit_files {
-        let (base_dir, cfg, notices) =
-            match resolve_ctx(&ef, global_cfg.as_ref(), &mut cache) {
-                Ok(pair) => pair,
-                Err(e) => {
-                    eprintln!("{e}");
-                    return ExitCode::from(2);
-                }
-            };
-        for notice in notices {
-            if emitted_notices.insert(notice.clone()) {
-                eprintln!("{notice}");
-            }
-        }
-        let ignored = cfg.is_file_ignored(&ef, &base_dir);
-        let yaml_ok = cfg.is_yaml_candidate(&ef, &base_dir);
-        if !ignored && yaml_ok {
-            files.push((ef, base_dir, cfg));
-        }
-    }
-
-    if cli.lint.list_files {
-        for (path, ..) in &files {
-            println!("{}", path.display());
-        }
-        return ExitCode::SUCCESS;
-    }
-
-    if files.is_empty() {
-        return ExitCode::SUCCESS;
-    }
-
-    let mut results: Vec<(usize, Result<Vec<LintProblem>, String>)> = files
-        .par_iter()
-        .enumerate()
-        .map(|(idx, (path, base_dir, cfg))| (idx, lint_file(path, cfg, base_dir)))
-        .collect();
-
-    results.sort_by_key(|(idx, _)| *idx);
-
-    let output_format = detect_output_format(cli.format);
-    let (has_error, has_warning) =
-        process_results(&files, results, output_format, cli.lint.no_warnings);
-
-    if has_error {
-        ExitCode::from(1)
-    } else if has_warning && cli.lint.strict {
-        ExitCode::from(2)
-    } else {
-        ExitCode::SUCCESS
-    }
-}
-
-fn process_results(
-    files: &[(PathBuf, PathBuf, YamlLintConfig)],
-    results: Vec<(usize, Result<Vec<LintProblem>, String>)>,
-    output_format: OutputFormat,
-    no_warnings: bool,
-) -> (bool, bool) {
-    let mut has_error = false;
-    let mut has_warning = false;
-
-    for (idx, outcome) in results {
-        let (path, ..) = &files[idx];
-        match outcome {
-            Err(message) => {
-                eprintln!("{message}");
-                has_error = true;
-            }
-            Ok(diagnostics) => {
-                let mut problems = diagnostics
-                    .iter()
-                    .filter(|problem| {
-                        !(no_warnings && problem.level == Severity::Warning)
-                    })
-                    .peekable();
-
-                if problems.peek().is_none() {
-                    continue;
-                }
-
-                match output_format {
-                    OutputFormat::Standard => {
-                        eprintln!("{}", path.display());
-                        for problem in problems {
-                            eprintln!("{}", format_standard(problem));
-                            match problem.level {
-                                Severity::Error => has_error = true,
-                                Severity::Warning => has_warning = true,
-                            }
-                        }
-                        eprintln!();
-                    }
-                    OutputFormat::Colored => {
-                        eprintln!("\u{001b}[4m{}\u{001b}[0m", path.display());
-                        for problem in problems {
-                            eprintln!("{}", format_colored(problem));
-                            match problem.level {
-                                Severity::Error => has_error = true,
-                                Severity::Warning => has_warning = true,
-                            }
-                        }
-                        eprintln!();
-                    }
-                    OutputFormat::Github => {
-                        eprintln!("::group::{}", path.display());
-                        for problem in problems {
-                            eprintln!("{}", format_github(problem, path));
-                            match problem.level {
-                                Severity::Error => has_error = true,
-                                Severity::Warning => has_warning = true,
-                            }
-                        }
-                        eprintln!("::endgroup::");
-                        eprintln!();
-                    }
-                    OutputFormat::Parsable => {
-                        for problem in problems {
-                            eprintln!("{}", format_parsable(problem, path));
-                            match problem.level {
-                                Severity::Error => has_error = true,
-                                Severity::Warning => has_warning = true,
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    (has_error, has_warning)
-}
-
-fn format_standard(problem: &LintProblem) -> String {
-    let mut line = format!("  {}:{}", problem.line, problem.column);
-    line.push_str(&" ".repeat(12usize.saturating_sub(line.len())));
-    line.push_str(problem.level.as_str());
-    line.push_str(&" ".repeat(21usize.saturating_sub(line.len())));
-    line.push_str(&problem.message);
-    if let Some(rule) = problem.rule {
-        line.push_str("  (");
-        line.push_str(rule);
-        line.push(')');
-    }
-    line
-}
-
-fn format_colored(problem: &LintProblem) -> String {
-    let mut line = format!(
-        "  \u{001b}[2m{}:{}\u{001b}[0m",
-        problem.line, problem.column
-    );
-    line.push_str(&" ".repeat(20usize.saturating_sub(line.len())));
-    let level_str = match problem.level {
-        Severity::Warning => "\u{001b}[33mwarning\u{001b}[0m",
-        Severity::Error => "\u{001b}[31merror\u{001b}[0m",
-    };
-    line.push_str(level_str);
-    line.push_str(&" ".repeat(38usize.saturating_sub(line.len())));
-    line.push_str(&problem.message);
-    if let Some(rule) = problem.rule {
-        line.push_str("  \u{001b}[2m(");
-        line.push_str(rule);
-        line.push_str(")\u{001b}[0m");
-    }
-    line
-}
-
-fn format_github(problem: &LintProblem, path: &Path) -> String {
-    let mut line = format!(
-        "::{} file={},line={},col={}::{}:{} ",
-        problem.level.as_str(),
-        path.display(),
-        problem.line,
-        problem.column,
-        problem.line,
-        problem.column
-    );
-    if let Some(rule) = problem.rule {
-        line.push('[');
-        line.push_str(rule);
-        line.push_str("] ");
-    }
-    line.push_str(&problem.message);
-    line
-}
-
-fn format_parsable(problem: &LintProblem, path: &Path) -> String {
-    let mut line = format!(
-        "{}:{}:{}: [{}] {}",
-        path.display(),
-        problem.line,
-        problem.column,
-        problem.level.as_str(),
-        problem.message
-    );
-    if let Some(rule) = problem.rule {
-        line.push_str(" (");
-        line.push_str(rule);
-        line.push(')');
-    }
-    line
-}