sonicop 26.8.111 → 26.8.113

data/build.rs

@@ -0,0 +1,155 @@
+//! Records which commit the binary next to this build was made from.
+//!
+//! The fingerprint a measurement prints -- the binary's own hash -- answers "which binary", not
+//! "whose fixes are in it". Those are different questions, and on 2026-08-17 the gap cost the team
+//! five re-runs of a sixty-minute gate and two reports of bugs that had already been fixed on a
+//! branch nobody's tree had merged. Each side was rigorous on its own: one printed the fingerprint,
+//! the other reported how far its branch was ahead. Neither answers the question in between.
+//!
+//! Writing the commit beside the binary closes it without touching the CLI. `--version` stays
+//! byte-identical to what RuboCop prints, which the drop-in replacement depends on, and nothing
+//! reads this file at run time -- it exists for the measurement scripts, which can now say
+//! `git merge-base --is-ancestor <fix> <sha>` instead of asking a person.
+//!
+//! The file lands next to the executable rather than inside `OUT_DIR` so that the scripts can find
+//! it from the binary path alone; they are handed a path to `sonicop`, not a Cargo layout. A build
+//! that cannot reach git writes `unknown` rather than failing: this is a convenience for measuring,
+//! and a release built from a source tarball has no repository to ask.
+
+use std::ffi::OsString;
+use std::fs;
+use std::io;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+fn main() {
+    // The commit marker changes only with git. The embedded cache fingerprint, however, must move
+    // with every input that can change diagnostics so a development build never accepts reports
+    // from different code merely because the package version stayed put.
+    println!("cargo:rerun-if-changed=.git/HEAD");
+    println!("cargo:rerun-if-changed=.git/refs");
+    for input in [
+        "Cargo.toml",
+        "Cargo.lock",
+        "build.rs",
+        "config/default.yml",
+        "src",
+    ] {
+        println!("cargo:rerun-if-changed={input}");
+    }
+    let fingerprint = build_fingerprint().expect("failed to fingerprint Sonicop build inputs");
+    println!("cargo:rustc-env=SONICOP_BUILD_FINGERPRINT={fingerprint}");
+
+    let Some(profile_dir) = profile_dir() else {
+        return;
+    };
+    let sha = head_sha().unwrap_or_else(|| "unknown".to_owned());
+    let dirty = match working_tree_is_dirty() {
+        true => " dirty",
+        false => "",
+    };
+    let _ = std::fs::write(
+        profile_dir.join(".sonicop-build-sha"),
+        format!("{sha}{dirty}\n"),
+    );
+}
+
+/// Stable identity of everything that can affect the executable's lint result.
+///
+/// Hashing this once while compiling replaces reading and hashing the entire executable at every
+/// startup. Besides source and embedded configuration, the lockfile covers dependency revisions;
+/// compiler/target/cfg inputs cover builds whose source tree is byte-identical but semantics are
+/// not. Test and documentation files are intentionally absent because they never enter the binary.
+fn build_fingerprint() -> io::Result<blake3::Hash> {
+    let mut fingerprint = blake3::Hasher::new();
+    for input in [
+        "Cargo.toml",
+        "Cargo.lock",
+        "build.rs",
+        "config/default.yml",
+        "src",
+    ] {
+        hash_path(Path::new(input), &mut fingerprint)?;
+    }
+
+    let mut environment = std::env::vars_os()
+        .filter(|(name, _)| {
+            let name = name.to_string_lossy();
+            matches!(
+                name.as_ref(),
+                "TARGET" | "PROFILE" | "OPT_LEVEL" | "DEBUG" | "CARGO_ENCODED_RUSTFLAGS"
+            ) || name.starts_with("CARGO_CFG_")
+                || name.starts_with("CARGO_FEATURE_")
+        })
+        .collect::<Vec<(OsString, OsString)>>();
+    environment.sort_unstable();
+    for (name, value) in environment {
+        hash_part(&mut fingerprint, name.as_encoded_bytes());
+        hash_part(&mut fingerprint, value.as_encoded_bytes());
+    }
+
+    let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| OsString::from("rustc"));
+    let version = Command::new(rustc).arg("-vV").output()?;
+    if !version.status.success() {
+        return Err(io::Error::other("rustc -vV failed"));
+    }
+    hash_part(&mut fingerprint, &version.stdout);
+    Ok(fingerprint.finalize())
+}
+
+fn hash_path(path: &Path, fingerprint: &mut blake3::Hasher) -> io::Result<()> {
+    hash_part(fingerprint, path.as_os_str().as_encoded_bytes());
+    if path.is_dir() {
+        hash_part(fingerprint, b"directory");
+        let mut children = fs::read_dir(path)?
+            .collect::<Result<Vec<_>, _>>()?
+            .into_iter()
+            .map(|entry| entry.path())
+            .collect::<Vec<_>>();
+        children.sort_unstable();
+        for child in children {
+            hash_path(&child, fingerprint)?;
+        }
+    } else {
+        hash_part(fingerprint, b"file");
+        hash_part(fingerprint, &fs::read(path)?);
+    }
+    Ok(())
+}
+
+fn hash_part(fingerprint: &mut blake3::Hasher, bytes: &[u8]) {
+    fingerprint.update(&(bytes.len() as u64).to_le_bytes());
+    fingerprint.update(bytes);
+}
+
+/// `target/<profile>`, derived from where Cargo put this script's scratch space.
+///
+/// `OUT_DIR` is `target/<profile>/build/<pkg>-<hash>/out`, so the profile directory is three levels
+/// up. Cargo has no environment variable that names it directly.
+fn profile_dir() -> Option<PathBuf> {
+    let out_dir = PathBuf::from(std::env::var_os("OUT_DIR")?);
+    Some(out_dir.ancestors().nth(3)?.to_path_buf())
+}
+
+fn head_sha() -> Option<String> {
+    let done = Command::new("git")
+        .args(["rev-parse", "--short", "HEAD"])
+        .output()
+        .ok()?;
+    match done.status.success() {
+        true => Some(String::from_utf8(done.stdout).ok()?.trim().to_owned()),
+        false => None,
+    }
+}
+
+/// Whether the tree the binary was built from carries uncommitted changes.
+///
+/// **A commit alone would overstate what the binary contains.** Half of the re-runs on 2026-08-17
+/// were of trees whose commit was right and whose working copy had moved on, so the scripts need to
+/// see the difference between "built from this commit" and "built from this commit plus edits".
+fn working_tree_is_dirty() -> bool {
+    Command::new("git")
+        .args(["status", "--porcelain"])
+        .output()
+        .is_ok_and(|done| done.status.success() && !done.stdout.is_empty())
+}

data/lib/sonicop/runner.rb

@@ -15,7 +15,13 @@ module Sonicop
       MESSAGE
 
       begin
-        exec(binary, *arguments)
+        # `[binary, binary]` = exec 形式の強制。`exec(binary, *arguments)` は arguments が空、
+        # つまり「カレントディレクトリを見る素の `sonicop`」という最も普通の呼び出しのとき
+        # `exec(String)` = commandline 形式に落ちる。この形式は空白で単語分割し、メタ文字が
+        # あればまるごと /bin/sh に渡すため、binary のパス次第で ENOENT や exit 127 になる。
+        # パスの出所は SONICOP_BINARY と gem の install 先で、どちらもメタ文字を含まない保証がない。
+        # argv0 は multi-arg 形式が既定で入れるものと同じ値を明示している。
+        exec([binary, binary], *arguments)
       rescue SystemCallError => error
         # 実行できない典型は「platform gem は入ったが実行環境と ABI が違う」ケース
         # (musl 環境に glibc ビルドが入るなど)。素の errno だけでは原因が読めない。

data/lib/sonicop/version.rb

@@ -2,5 +2,5 @@
 
 # Generated from Cargo.toml by `rake version:sync`. Do not edit by hand.
 module Sonicop
-  VERSION = '26.8.111'
+  VERSION = '26.8.113'
 end

data/src/cli.rs

@@ -11,8 +11,9 @@ use crate::config::{Config, ConfigStore};
 use crate::cop_name::{self, selector_matches};
 use crate::diagnostic::{FileReport, Offense, Severity};
 use crate::engine::{
-    CorrectMode, NO_SYNTAX_GUARD, Selection, correct_file, discover_targets_with_store,
-    inspect_files_with_store, inspect_source, is_mandatory_cop, offense_count, write_corrected,
+    CorrectMode, NO_SYNTAX_GUARD, ResultCache, Selection, correct_file,
+    discover_targets_with_store, inspect_files_with_store_cached, inspect_stdin, is_mandatory_cop,
+    offense_count, write_corrected,
 };
 use crate::formatter::{
     Format, FormatOptions, offenses_by_cop, render, smart_path, yaml_single_quoted,
@@ -238,9 +239,11 @@ impl Cli {
 }
 
 pub fn run() -> i32 {
-    crate::profile::set_enabled(std::env::var_os("SONICOP_PROFILE").is_some());
+    // Sized from the registry: a fixed table silently drops every cop past its end.
+    let names: Vec<&'static str> = crate::rules::rule_names().collect();
+    crate::profile::set_enabled(std::env::var_os("SONICOP_PROFILE").is_some(), names.len());
     let code = run_inner();
-    crate::profile::report(&crate::rules::rule_names().collect::<Vec<_>>());
+    crate::profile::report(&names);
     code
 }
 
@@ -304,10 +307,17 @@ fn output_paths_by_format(matches: &ArgMatches) -> Vec<Option<PathBuf>> {
 
     let mut slots = vec![None; format_positions.len().max(1)];
     for (out_position, path) in out_positions.into_iter().zip(out_paths) {
+        // `Options#parse`: `-o` attaches to the `-f` it follows. One written before any `-f` lands
+        // in `output_path` instead, and the only thing that reads it is `apply_default_formatter`'s
+        // `@options[:formatters] ||= [[format, output_path]]` -- a no-op once a `-f` was given. So
+        // with a `-f` present such a path is dropped, and the formatter writes to stdout; with none,
+        // it is where the default formatter writes.
         let slot = format_positions
             .iter()
-            .rposition(|format_position| *format_position < out_position)
-            .unwrap_or(0);
+            .rposition(|format_position| *format_position < out_position);
+        let Some(slot) = slot.or_else(|| format_positions.is_empty().then_some(0)) else {
+            continue;
+        };
         slots[slot].get_or_insert_with(|| path.clone());
     }
     slots
@@ -392,13 +402,28 @@ fn try_run(cli: Cli, outputs: &[Option<PathBuf>]) -> Result<i32> {
 
     let correct_mode = cli.correct_mode();
     let selection = build_selection(&cli, &config, correct_mode)?;
+    let result_cache = result_cache(&cli, &cwd, &selection, &config)?;
     if !cli.list_target_files {
         warn_unimplemented_enabled(&config, &selection);
     }
 
     let parallel = !cli.no_parallel && (cli.parallel || cli.stdin.is_none());
-    let mut reports = match inspect_inputs(&cli, &cwd, &configs, &selection, parallel)? {
-        Inspection::Reports(reports) => reports,
+    let inspection = inspect_inputs(
+        &cli,
+        &cwd,
+        &configs,
+        &selection,
+        parallel,
+        result_cache.as_ref(),
+    )?;
+    if let Some(cache) = &result_cache {
+        cache.prune();
+    }
+    let (mut reports, target_count) = match inspection {
+        Inspection::Reports {
+            reports,
+            target_count,
+        } => (reports, target_count),
         Inspection::ListedTargets => return Ok(0),
     };
 
@@ -426,22 +451,22 @@ fn try_run(cli: Cli, outputs: &[Option<PathBuf>]) -> Result<i32> {
     // A file RuboCop could not finish counts as a failed run even when nothing else offended.
     let failing = fail_level.failing(&reports) || had_errors;
 
+    filter_displayed_offenses(&mut reports, &cli, fail_level);
+    render_outputs(
+        &RenderRequest {
+            cli: &cli,
+            config: &config,
+            cwd: &cwd,
+            fail_level,
+            outputs,
+            corrected_count,
+            target_count,
+            elapsed: started.elapsed().as_secs_f64(),
+        },
+        &reports,
+    )?;
     if let Some(corrected) = stdin_corrected {
-        print!("{corrected}");
-    } else {
-        filter_displayed_offenses(&mut reports, &cli, fail_level);
-        render_outputs(
-            &RenderRequest {
-                cli: &cli,
-                config: &config,
-                cwd: &cwd,
-                fail_level,
-                outputs,
-                corrected_count,
-                elapsed: started.elapsed().as_secs_f64(),
-            },
-            &reports,
-        )?;
+        print_corrected_stdin(&cli, &corrected)?;
     }
 
     Ok(i32::from(failing))
@@ -471,14 +496,69 @@ fn build_selection(cli: &Cli, config: &Config, correct_mode: CorrectMode) -> Res
         ignore_disable_comments: cli.ignore_disable_comments,
         display_suppressed: cli.display_suppressed,
         correcting: correct_mode != CorrectMode::None,
+        // `LSP.enabled?`. `--lsp` sets it too, but that mode returns before anything is inspected,
+        // so `--editor-mode` is the only way it reaches a cop from here.
+        editor_mode: cli.editor_mode,
         // **No flag turns this on from the command line.** The guard is switched off for tests
         // only, and even then per case; a run reaches the environment variable or nothing.
         skip_syntax_guard: false,
     })
 }
 
+fn result_cache(
+    cli: &Cli,
+    cwd: &Path,
+    selection: &Selection,
+    config: &Config,
+) -> Result<Option<ResultCache>> {
+    // Profiling reports what inspecting the files costs, so it serves cached reports to nobody --
+    // unless the run asks for the cache in as many words, which is how the cost of a cache *hit*
+    // gets measured at all.
+    let profiling = std::env::var_os("SONICOP_PROFILE").is_some();
+    let enabled = cli.cache.as_deref() != Some("false")
+        && !selection.correcting
+        && cli.stdin.is_none()
+        && !cli.profile
+        && !cli.memory
+        && (!profiling || cli.cache.as_deref() == Some("true"));
+    if !enabled {
+        return Ok(None);
+    }
+    let root = cli
+        .cache_root
+        .clone()
+        .unwrap_or_else(|| default_cache_root(cwd));
+    let max_files = config.all_cops_value("MaxFilesInCache").unwrap_or(20_000);
+    if max_files == 0 {
+        return Ok(None);
+    }
+    ResultCache::new(root, config.path_base(), selection, max_files).map(Some)
+}
+
+fn default_cache_root(cwd: &Path) -> PathBuf {
+    if let Some(root) = std::env::var_os("XDG_CACHE_HOME") {
+        return PathBuf::from(root).join("sonicop");
+    }
+    if cfg!(target_os = "macos")
+        && let Some(home) = std::env::var_os("HOME")
+    {
+        return PathBuf::from(home).join("Library/Caches/sonicop");
+    }
+    if let Some(home) = std::env::var_os("HOME") {
+        return PathBuf::from(home).join(".cache/sonicop");
+    }
+    cwd.join(".sonicop-cache")
+}
+
 enum Inspection {
-    Reports(Vec<FileReport>),
+    Reports {
+        reports: Vec<FileReport>,
+        /// What discovery produced, which `--fail-fast` leaves larger than the number of reports.
+        /// `JSONFormatter` takes `target_file_count` from `started(target_files)` and
+        /// `inspected_file_count` from `finished(inspected_files)`, so the two are separate counts
+        /// and only a run that inspects everything it found makes them equal.
+        target_count: usize,
+    },
     ListedTargets,
 }
 
@@ -488,6 +568,7 @@ fn inspect_inputs(
     configs: &ConfigStore,
     selection: &Selection,
     parallel: bool,
+    cache: Option<&ResultCache>,
 ) -> Result<Inspection> {
     let Some(stdin_path) = &cli.stdin else {
         let mut targets = discover_targets_with_store(
@@ -503,6 +584,9 @@ fn inspect_inputs(
             }
             return Ok(Inspection::ListedTargets);
         }
+        if let Some(cache) = cache {
+            cache.prepare(targets.len());
+        }
         let reports = if cli.fail_fast {
             targets.sort_by_key(|path| {
                 std::cmp::Reverse(
@@ -511,28 +595,40 @@ fn inspect_inputs(
                         .ok(),
                 )
             });
-            inspect_fail_fast(&targets, configs, selection)?
+            inspect_fail_fast(&targets, configs, selection, cache)?
         } else {
-            inspect_files_with_store(&targets, configs, selection, parallel)?
+            inspect_files_with_store_cached(&targets, configs, selection, parallel, cache)?
         };
-        return Ok(Inspection::Reports(reports));
+        return Ok(Inspection::Reports {
+            reports,
+            target_count: targets.len(),
+        });
     };
 
     if !cli.paths.is_empty() {
         bail!("--stdin requires exactly one path supplied as its argument and no file arguments");
     }
-    let mut text = String::new();
+    // Read as bytes, not as text: `$stdin.binmode.read` (`options.rb:46`) is what RuboCop reads,
+    // and a source that is not valid UTF-8 is an offense to report rather than a run to abort.
+    let mut bytes = Vec::new();
     io::stdin()
-        .read_to_string(&mut text)
-        .context("failed to read UTF-8 source from stdin")?;
+        .read_to_end(&mut bytes)
+        .context("failed to read source from stdin")?;
     let target_config = configs.for_path(stdin_path)?;
-    let report = inspect_source(stdin_path.clone(), text, &target_config, selection)?;
-    Ok(Inspection::Reports(vec![report]))
+    let report = inspect_stdin(stdin_path.clone(), bytes, &target_config, selection)?;
+    Ok(Inspection::Reports {
+        reports: vec![report],
+        target_count: 1,
+    })
 }
 
 struct CorrectionRun {
     reports: Vec<FileReport>,
     corrected_count: usize,
+    /// The buffer `--stdin` is left holding, which is `@options[:stdin]` after the run: the
+    /// corrected source when a cop rewrote it, and the source that was read when none did.
+    /// `Team#autocorrect` (`cop/team.rb:175-178`) only assigns it on a rewrite, so the unchanged
+    /// case is not an absence -- it is the original buffer, and upstream prints that too.
     stdin_corrected: Option<String>,
     had_errors: bool,
 }
@@ -566,12 +662,12 @@ fn apply_corrections(
             eprintln!("{message}");
             had_errors = true;
         }
-        if outcome.rewritten {
-            if cli.stdin.is_some() {
+        if cli.stdin.is_some() {
+            if correct_mode != CorrectMode::None {
                 stdin_corrected = Some(outcome.text);
-            } else {
-                write_corrected(&path, &outcome.text)?;
             }
+        } else if outcome.rewritten {
+            write_corrected(&path, &outcome.text)?;
         }
         corrected_reports.push(outcome.report);
     }
@@ -611,15 +707,26 @@ impl FailLevel {
         }
     }
 
+    /// `Runner#considered_failure?` (`runner.rb:561-569`).
+    ///
+    /// `autocorrect` adds a reason to fail; it does not replace the one every run has. Upstream
+    /// returns early for a correctable offense **and then falls through** to the severity
+    /// comparison, so an uncorrectable offense at or above the threshold still fails the run.
+    /// Reading the pseudo level as "correctable offenses only" instead lets `--fail-level
+    /// autocorrect` exit 0 on a `Metrics/MethodLength` no cop can fix -- a green CI on code
+    /// RuboCop fails, which is the one direction a linter must never be wrong in.
     fn failing(self, reports: &[FileReport]) -> bool {
-        match self {
-            // A correctable offense fails even once it has been corrected.
-            Self::Autocorrect => reports
+        // `minimum_severity_to_fail` reads `autocorrect` as `:refactor`, which [`Self::severity`]
+        // already does, so the threshold applies whichever level was asked for.
+        if offense_count(reports, self.severity()) > 0 {
+            return true;
+        }
+        // A correctable offense fails even once it has been corrected.
+        self == Self::Autocorrect
+            && reports
                 .iter()
                 .flat_map(|report| &report.offenses)
-                .any(Offense::is_correctable),
-            Self::Severity(severity) => offense_count(reports, severity) > 0,
-        }
+                .any(Offense::is_correctable)
     }
 }
 
@@ -743,11 +850,17 @@ fn inspect_fail_fast(
     paths: &[PathBuf],
     configs: &ConfigStore,
     selection: &Selection,
+    cache: Option<&ResultCache>,
 ) -> Result<Vec<FileReport>> {
     let mut reports = Vec::new();
     for path in paths {
-        let mut inspected =
-            inspect_files_with_store(std::slice::from_ref(path), configs, selection, false)?;
+        let mut inspected = inspect_files_with_store_cached(
+            std::slice::from_ref(path),
+            configs,
+            selection,
+            false,
+            cache,
+        )?;
         let has_offense = inspected
             .first()
             .is_some_and(|report| !report.offenses.is_empty());
@@ -944,7 +1057,24 @@ fn generate_todo(reports: &[FileReport], cwd: &Path, cli: &Cli) -> Result<()> {
     }
     fs::write(cwd.join(".rubocop_todo.yml"), output)?;
     let root_config = cwd.join(".rubocop.yml");
-    let existing = fs::read_to_string(&root_config).unwrap_or_default();
+    // `add_inheritance_from_auto_generated_file` reads the file only after `File.exist?` says
+    // there is one, so "absent" and "unreadable" are separate answers and only the first means
+    // "write a new one". Collapsing them -- `unwrap_or_default()` -- turns every read failure into
+    // an empty string, and the prepend below silently becomes a replace: a `.rubocop.yml` that is
+    // not valid UTF-8, or that the process cannot open, is overwritten by the one line this would
+    // have added to it, with a zero exit code and nothing on stderr. Fail instead.
+    let existing = match fs::read_to_string(&root_config) {
+        Ok(existing) => existing,
+        Err(error) if error.kind() == io::ErrorKind::NotFound => String::new(),
+        Err(error) => {
+            return Err(error).with_context(|| {
+                format!(
+                    "failed to read {}; refusing to replace it with the generated inheritance",
+                    root_config.display()
+                )
+            });
+        }
+    };
     if !existing.contains(".rubocop_todo.yml") {
         let addition = if existing.is_empty() {
             "inherit_from: .rubocop_todo.yml\n".to_owned()
@@ -979,6 +1109,9 @@ struct RenderRequest<'a> {
     /// Destination per format, already paired the way RuboCop pairs `--out` with `--format`.
     outputs: &'a [Option<PathBuf>],
     corrected_count: usize,
+    /// How many files discovery produced, which is not how many were inspected once `--fail-fast`
+    /// stops the run early. See [`Inspection::Reports`].
+    target_count: usize,
     elapsed: f64,
 }
 
@@ -990,6 +1123,7 @@ fn render_outputs(request: &RenderRequest<'_>, reports: &[FileReport]) -> Result
         fail_level,
         outputs,
         corrected_count,
+        target_count,
         elapsed,
     } = *request;
     let formats = if cli.formats.is_empty() {
@@ -1021,6 +1155,7 @@ fn render_outputs(request: &RenderRequest<'_>, reports: &[FileReport]) -> Result
                 extra_details: cli.extra_details,
                 color,
                 corrected_count,
+                target_file_count: target_count,
                 fail_level: fail_level.severity(),
                 safe_autocorrect: cli.correct_mode() == CorrectMode::Safe,
                 display_only_failed: cli.display_only_failed,
@@ -1038,6 +1173,42 @@ fn render_outputs(request: &RenderRequest<'_>, reports: &[FileReport]) -> Result
     Ok(())
 }
 
+/// `ExecuteRunner::INTEGRATION_FORMATTERS`: the formats whose consumers parse the whole stream, so
+/// nothing may be appended to them. Both the short and the long spelling of each.
+const INTEGRATION_FORMATTERS: [&str; 6] = ["h", "html", "j", "json", "ju", "junit"];
+
+/// Appends the source `--stdin` was left holding to a formatter's report, the way
+/// `ExecuteRunner#maybe_print_corrected_source` (`cli/command/execute_runner.rb:92-102`) does.
+///
+/// An editor driving `--stdin -a` reads the corrected buffer off the end of the output, which is
+/// what the twenty `=` mark the start of. The report still comes first: printing only the buffer
+/// leaves nothing to say what was corrected, and with `--format json` it puts raw Ruby where a
+/// caller asked for JSON and will try to parse it.
+///
+/// Two details are upstream's rather than chosen here. The check is against `@options[:format]`,
+/// which the option parser assigns per `-f`, so it is the **last** format on the command line that
+/// decides -- `-f json -f simple` appends. And `--stderr` moves the separator but not the source:
+/// upstream picks the stream for the `puts` and then `print`s to `$stdout` unconditionally, by
+/// which point the redirect around the runner has already been undone.
+fn print_corrected_stdin(cli: &Cli, corrected: &str) -> Result<()> {
+    if cli
+        .formats
+        .last()
+        .is_some_and(|format| INTEGRATION_FORMATTERS.contains(&format.as_str()))
+    {
+        return Ok(());
+    }
+    let separator = format!("{}\n", "=".repeat(20));
+    if cli.stderr {
+        io::stderr().write_all(separator.as_bytes())?;
+    } else {
+        io::stdout().write_all(separator.as_bytes())?;
+    }
+    io::stdout().write_all(corrected.as_bytes())?;
+    io::stdout().flush()?;
+    Ok(())
+}
+
 fn init_config(cwd: &Path) -> Result<i32> {
     let path = cwd.join(".rubocop.yml");
     if path.exists() {