shirobai 2026.0905.1300 → 2026.0920.1100

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f4f98851b8d60acd4a275498959e3e6a0fca00455715bcdfa5b16a653a90015
-  data.tar.gz: 9bb15c3004bfa6415d01d2e6038dfa430cd930f260f988faf22133f445869597
+  metadata.gz: f65a6269e60ead3a7b5175cad5be36b3364bb5ee6025dd7bcc3a2b82d69466c6
+  data.tar.gz: 6af011435008fec04f1a8bced1d5e5d620160b465b6a290963fcfcda1561a8a2
 SHA512:
-  metadata.gz: 7effd8214232c64b9fee9ecbe046bf102e2b24936aef4c991039bd8028acc79d936b4c6d0d42ed184a247e1e1ac0b1ea0ca268f57c6001a3d16e9913af9106a5
-  data.tar.gz: 186a7b1f6e790e78c73f85ed0000bacf40ed19dbb8c0ab426b52b31b124f81f7eb907392400732b242b8fd92026907bef51f637f117c0957e92c14f117f1f3ae
+  metadata.gz: d88a4fc322d82e59683f33de8d8a3ae93a62f59ac358dc583a83201ccf3db4021a5076ac60a4a5ba60802d557ab8d18ad3771d6be40a1c01268582aa4083e743
+  data.tar.gz: 2cee35078890630d5291e962e5fb6d6a9c2f49a4595bd1b212ead6db8aaff8a73aa8460845e11d49d2360d26680d2006bbde79b2ba7c2646e6fbbbefa2b48032

data/Cargo.lock

@@ -356,7 +356,7 @@ checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
 
 [[package]]
 name = "shirobai"
-version = "2026.905.1300"
+version = "2026.920.1100"
 dependencies = [
  "magnus",
  "shirobai-core",
@@ -364,7 +364,7 @@ dependencies = [
 
 [[package]]
 name = "shirobai-core"
-version = "2026.905.1300"
+version = "2026.920.1100"
 dependencies = [
  "libc",
  "ruby-prism",

data/Cargo.toml

@@ -7,7 +7,7 @@ resolver = "3"
 # is crate 2026.709.0 -- cargo rejects leading zeros in numeric segments, and
 # Gem::Version normalizes to the same integers, so the two stay value-equal).
 [workspace.package]
-version = "2026.905.1300"
+version = "2026.920.1100"
 
 # Release tuning. The hot path crosses crate boundaries (ext cdylib -> core
 # check_* -> ruby-prism); without LTO the cross-crate calls are not inlined and

data/crates/shirobai-core/src/bin/bundle_profile.rs

@@ -213,7 +213,7 @@ fn run_perrule(sources: &[Vec<u8>], cfg: &BundleConfig, iterations: usize) {
                 s,
                 cfg.argument_alignment_style,
                 cfg.argument_alignment_indent,
-                cfg.argument_alignment_incompatible,
+                cfg.argument_alignment_hash_separator,
             ));
         }),
         e!("first_argument_indentation", |s: &[u8]| {

data/crates/shirobai-core/src/rules/aligner.rs

@@ -389,6 +389,7 @@ impl<'a> Aligner<'a> {
         let original_line_indent = self.line_indentation(first);
         let mut relevant_line_indent_at_level = true;
         let assignment_lines = self.assignment_lines();
+        let boundary_lines = self.interrupting_operator_lines(&assignment_lines);
 
         for &line_number in line_range {
             let current_line_indent = self.line_indentation(line_number);
@@ -396,7 +397,11 @@ impl<'a> Aligner<'a> {
                 .line_text(line_number)
                 .map(is_blank_line)
                 .unwrap_or(true);
-            if (current_line_indent < original_line_indent && !blank_line)
+            // A line carrying another alignable operator (`<<`, `==`, ...)
+            // that is not an assignment line ends the group (1.91,
+            // `interrupting_operator_lines` as `relevant_lines` boundaries).
+            if (line_number != first && boundary_lines.contains(&line_number))
+                || (current_line_indent < original_line_indent && !blank_line)
                 || (relevant_line_indent_at_level && blank_line)
             {
                 break;
@@ -413,6 +418,20 @@ impl<'a> Aligner<'a> {
         result
     }
 
+    /// `interrupting_operator_lines`: the lines of every
+    /// `ASSIGNMENT_OR_COMPARISON_TOKENS` token that are not assignment lines.
+    fn interrupting_operator_lines(
+        &self,
+        assignment_lines: &[usize],
+    ) -> std::collections::BTreeSet<usize> {
+        self.tokens
+            .iter()
+            .filter(|t| t.assignment_or_comparison())
+            .map(|t| self.line(t.begin_pos))
+            .filter(|line| !assignment_lines.contains(line))
+            .collect()
+    }
+
     /// `assignment_lines` = lines of `assignment_tokens`.
     fn assignment_lines(&self) -> Vec<usize> {
         self.assignment_tokens()

data/crates/shirobai-core/src/rules/argument_alignment.rs

@@ -36,9 +36,9 @@ pub fn check_argument_alignment(
     source: &[u8],
     style: u8,
     indent_width: usize,
-    incompatible: bool,
+    hash_separator: bool,
 ) -> Vec<ArgAlignOffense> {
-    let Some(mut rule) = build_rule(source, style, indent_width, incompatible) else {
+    let Some(mut rule) = build_rule(source, style, indent_width, hash_separator) else {
         return Vec::new();
     };
     super::dispatch::run(source, &mut [&mut rule]);
@@ -47,11 +47,15 @@ pub fn check_argument_alignment(
 
 /// Build the rule for use standalone or in a shared-walk bundle. `None` when
 /// the cop is disabled outright (`autocorrect_incompatible_with_other_cops?`).
+/// `hash_separator` is `enforce_hash_argument_with_separator?`: a
+/// separator-aligned `Layout/HashAlignment`. With `with_first_argument` it
+/// disables the cop; with `with_fixed_indentation` it leaves a trailing
+/// braceless hash's pairs to HashAlignment (1.91).
 pub(crate) fn build_rule(
     source: &[u8],
     style: u8,
     indent_width: usize,
-    incompatible: bool,
+    hash_separator: bool,
 ) -> Option<Visitor<'_>> {
     let style = if style == 1 {
         Style::WithFixedIndentation
@@ -59,7 +63,7 @@ pub(crate) fn build_rule(
         Style::WithFirstArgument
     };
     // `autocorrect_incompatible_with_other_cops?`: disables the cop entirely.
-    if incompatible && style == Style::WithFirstArgument {
+    if hash_separator && style == Style::WithFirstArgument {
         return None;
     }
     let line_index = super::line_index::with_line_index(source, |li| li.clone());
@@ -68,6 +72,7 @@ pub(crate) fn build_rule(
         line_index,
         style,
         indent: indent_width,
+        hash_separator,
         offenses: Vec::new(),
     })
 }
@@ -77,6 +82,8 @@ pub(crate) struct Visitor<'a> {
     line_index: Rc<LineIndex>,
     style: Style,
     indent: usize,
+    /// `enforce_hash_argument_with_separator?`.
+    hash_separator: bool,
     pub(crate) offenses: Vec<ArgAlignOffense>,
 }
 
@@ -170,6 +177,10 @@ impl Visitor<'_> {
                     .collect();
                 let last = args.last().unwrap();
                 match braceless_hash_pairs(last) {
+                    // `return items if enforce_hash_argument_with_separator?`
+                    // (1.91): the pairs belong to HashAlignment's separator
+                    // alignment, so they are not alignment items here.
+                    Some(_) if self.hash_separator => {}
                     Some(pairs) => items.extend(pairs),
                     None => items.push(loc(&last.location())),
                 }
@@ -306,4 +317,24 @@ mod tests {
         assert_eq!(got.len(), 1);
         assert_eq!(got[0].2, 3); // `bar` (col 2) aligns under `foo` (col 5)
     }
+
+    // 1.91: with a separator-aligned `Layout/HashAlignment`, the pairs of a
+    // trailing braceless hash are not alignment items under
+    // `with_fixed_indentation` (they belong to HashAlignment); other
+    // arguments are still checked. Under `with_first_argument` the cop is
+    // disabled outright.
+    #[test]
+    fn hash_separator_leaves_trailing_hash_pairs_to_hash_alignment() {
+        let sep = |src: &str, style: u8| {
+            check_argument_alignment(src.as_bytes(), style, 2, true)
+                .into_iter()
+                .map(|o| o.column_delta)
+                .collect::<Vec<_>>()
+        };
+        assert!(sep("validates :foo,\n          bar: 1,\n       bazqux: 2\n", 1).is_empty());
+        assert_eq!(sep("func(:foo,\n     :bar)\n", 1), vec![-3]);
+        assert!(sep("func(a,\n  b,\nc)\n", 0).is_empty());
+        // Without the separator style the pairs are aligned as before.
+        assert_eq!(run("validates :foo,\n          bar: 1,\n       bazqux: 2\n", 1).len(), 2);
+    }
 }

data/crates/shirobai-core/src/rules/bundle.rs

@@ -332,7 +332,7 @@ pub struct BundleConfig {
     pub multiline_method_call: (u8, usize, usize),
     pub argument_alignment_style: u8,
     pub argument_alignment_indent: usize,
-    pub argument_alignment_incompatible: bool,
+    pub argument_alignment_hash_separator: bool,
     pub array_alignment_style: u8,
     pub array_alignment_indent: usize,
     pub first_argument_style: u8,
@@ -579,7 +579,7 @@ impl BundleConfig {
             multiline_method_call: (nums[18] as u8, nums[19] as usize, nums[20] as usize),
             argument_alignment_style: nums[21] as u8,
             argument_alignment_indent: nums[22] as usize,
-            argument_alignment_incompatible: nums[23] != 0,
+            argument_alignment_hash_separator: nums[23] != 0,
             array_alignment_style: nums[112] as u8,
             array_alignment_indent: nums[113] as usize,
             frozen_string_literal_comment_style: nums[116] as u8,
@@ -1212,7 +1212,7 @@ pub fn check_all_bundle(source: &[u8], cfg: &BundleConfig) -> BundleResult {
         source,
         cfg.argument_alignment_style,
         cfg.argument_alignment_indent,
-        cfg.argument_alignment_incompatible,
+        cfg.argument_alignment_hash_separator,
     );
     let mut ara_rule = array_alignment::build_rule(
         source,
@@ -4486,7 +4486,7 @@ mod tests {
     fn shared_walk_respects_disabled_rules() {
         let src = "foo(bar,\n  baz)\nfoo([\n  1\n])\n";
         let (mut nums, lists) = default_packed();
-        nums[0][23] = 1; // argument_alignment incompatible (with_first_argument)
+        nums[0][23] = 1; // argument_alignment hash_separator (disables with_first_argument)
         nums[0][26] = 1; // first_argument enforce_fixed_no_line_break
         nums[0][37] = 1; // first_array_element enforce_fixed_indentation
         let cfg = BundleConfig::from_packed(&nums, lists).unwrap();

data/crates/shirobai-core/src/rules/duplicate_magic_comment.rs

@@ -730,9 +730,9 @@ fn simple_fsl_value(line: &[u8]) -> Option<FslValue> {
 ///   is already false: `valid?` = `@comment.start_with?('#')` (no leading
 ///   space) AND `any?` = one of the remaining magic kinds is specified
 ///   (`frozen_string_literal`, `shareable_constant_value`, `rbs_inline`,
-///   `typed`). `rbs_inline` is special: it counts only when the value is
-///   exactly `enabled`/`disabled` (`rbs_inline_specified?` ==
-///   `valid_rbs_inline_value?`).
+///   `warn_indent` since 1.91, `typed`). `rbs_inline` is special: it counts
+///   only when the value is exactly `enabled`/`disabled`
+///   (`rbs_inline_specified?` == `valid_rbs_inline_value?`).
 /// - [`OrderedBucket::None`] — neither.
 ///
 /// The format dispatch mirrors `MagicComment.parse` (Emacs, else Vim, else
@@ -750,15 +750,19 @@ pub(crate) fn ordered_bucket(line: &[u8]) -> OrderedBucket {
     let hash_prefixed = line.first() == Some(&b'#');
 
     if let Some(token) = emacs_token(line) {
-        // EmacsComment: `;`-separated tokens, each stripped. `encoding` and
-        // `frozen_string_literal`/`shareable_constant_value` are the only kinds
-        // Emacs can carry (`rbs_inline`/`typed` extraction is nil).
+        // EmacsComment: `;`-separated tokens, each stripped. `encoding`,
+        // `frozen_string_literal`, `shareable_constant_value` and `warn_indent`
+        // are the only kinds Emacs can carry (`rbs_inline`/`typed` extraction
+        // is nil).
         let mut encoding = false;
         let mut other = false;
         for tok in split_strip(token, b";") {
             if editor_kv_matches(tok, &[b"encoding", b"coding"], b':') {
                 encoding = true;
-            } else if fsl_keyword_kv_matches(tok) || shareable_keyword_kv_matches(tok) {
+            } else if fsl_keyword_kv_matches(tok)
+                || shareable_keyword_kv_matches(tok)
+                || warn_indent_keyword_kv_matches(tok)
+            {
                 other = true;
             }
         }
@@ -790,6 +794,7 @@ pub(crate) fn ordered_bucket(line: &[u8]) -> OrderedBucket {
         && (simple_fsl(line)
             || simple_shareable_specified(line)
             || simple_rbs_inline_specified(line)
+            || simple_warn_indent_specified(line)
             || simple_typed_specified(line))
     {
         return OrderedBucket::OtherValid;
@@ -797,6 +802,29 @@ pub(crate) fn ordered_bucket(line: &[u8]) -> OrderedBucket {
     OrderedBucket::None
 }
 
+/// Emacs editor token match for `\Awarn[_-]indent\s*:\s*TOKEN\z`
+/// (case-SENSITIVE keyword, like `EditorComment#match`). `warn_indent` is a
+/// magic comment since 1.91 (`MagicComment::KEYWORDS[:warn_indent]`).
+fn warn_indent_keyword_kv_matches(tok: &[u8]) -> bool {
+    match warn_indent_keyword_len(tok, false) {
+        Some(klen) => editor_kv_matches(&tok[klen..], &[b""], b':'),
+        None => false,
+    }
+}
+
+/// Length of `warn[_-]indent` at the start of `s`, or None.
+fn warn_indent_keyword_len(s: &[u8], ci: bool) -> Option<usize> {
+    let mut p = eat(s, 0, b"warn", ci)?;
+    p = eat_one_of(s, p, b"_-")?;
+    p = eat(s, p, b"indent", ci)?;
+    Some(p)
+}
+
+/// `warn_indent_specified?` for a SimpleComment line (any TOKEN).
+fn simple_warn_indent_specified(line: &[u8]) -> bool {
+    simple_anchored_token(line, |s| warn_indent_keyword_len(s, true)).is_some()
+}
+
 /// Emacs editor token match for `\Ashareable[_-]constant[_-]value\s*:\s*TOKEN\z`
 /// (case-SENSITIVE keyword, like `EditorComment#match`).
 fn shareable_keyword_kv_matches(tok: &[u8]) -> bool {

data/crates/shirobai-core/src/rules/duplicate_methods.rs

@@ -223,6 +223,8 @@ enum Kind {
         chain: Option<ConstChain>,
     },
     Lvasgn,
+    /// `@ivar = Class.new do ... end`: an `:ivasgn` parent (1.91).
+    Ivasgn,
     If,
     Other,
 }
@@ -491,6 +493,7 @@ enum PParent<'a> {
     BeginWrap { pp_block: bool },
     Def(usize),
     Casgn,
+    Ivasgn,
     Lvasgn,
     Disallowed,
 }
@@ -564,6 +567,7 @@ impl<'s> DuplicateMethodsRule<'s> {
             }
             Kind::Call(info) => PParent::Call(info),
             Kind::Casgn { .. } => PParent::Casgn,
+            Kind::Ivasgn => PParent::Ivasgn,
             Kind::Lvasgn => PParent::Lvasgn,
             Kind::Def { .. } => PParent::Def(call_idx - 1),
             _ => PParent::Disallowed,
@@ -633,7 +637,9 @@ impl<'s> DuplicateMethodsRule<'s> {
                     None => path_line(),
                 }
             }
-            PParent::Casgn => path_line(),
+            // `:casgn` and `:ivasgn` (1.91) parents have no receiver; the
+            // block gets its unique source-location id.
+            PParent::Casgn | PParent::Ivasgn => path_line(),
             PParent::BeginWrap { pp_block } => {
                 if pp_block {
                     path_line()
@@ -1244,6 +1250,7 @@ impl<'s> DuplicateMethodsRule<'s> {
                 }
             }
             Node::LocalVariableWriteNode { .. } => frame.kind = Kind::Lvasgn,
+            Node::InstanceVariableWriteNode { .. } => frame.kind = Kind::Ivasgn,
             Node::CallNode { .. } => {
                 let c = node.as_call_node().unwrap();
                 let kind = block_kind(&c);
@@ -1905,4 +1912,20 @@ mod tests {
         );
         assert_eq!(&src[evts[0].off_start..evts[0].off_end], "alias_method :a, :b");
     }
+
+    // 1.91: a Class.new block assigned to an instance variable (`:ivasgn`
+    // parent) gets its own path:line scope id like a casgn one, so singleton
+    // methods in separate blocks are not duplicates of each other.
+    #[test]
+    fn ivasgn_class_new_blocks_get_distinct_scope_ids() {
+        let src = "def setup\n  @first = Class.new do\n    class << self\n      def name; end\n    end\n  end\n\n  Class.new do\n    class << self\n      def name; end\n    end\n  end\nend\n";
+        let evts = events(src);
+        // `def setup`, then the two singleton `name`s.
+        assert_eq!(evts.len(), 3);
+        assert_eq!(evts[1].0, evts[2].0);
+        assert_eq!(evts[1].2, 2); // @path:2 (the ivasgn block)
+        // The second block's parent is the def body's `begin`: no scope id,
+        // as before.
+        assert_eq!(evts[2].2, -1);
+    }
 }

data/crates/shirobai-core/src/rules/else_alignment.rs

@@ -114,6 +114,9 @@ enum FrameKind {
     },
     /// A block node (`BlockNode`).
     Block,
+    /// A `class` / `module` / `class << self` body: the opening keyword range.
+    /// An implicit-begin `rescue`/`else` in such a body aligns with it (1.91).
+    ClassLike { kw_start: usize, kw_end: usize },
     /// A write node (assignment LHS): the LHS span (start..value_start trimmed),
     /// here approximated by the whole write-node range start and its first line.
     Write,
@@ -413,6 +416,13 @@ impl<'a> Visitor<'a> {
                     let call_start = self.frames[nf - 2].start;
                     return self.start_line_range(call_start);
                 }
+                // `when :class, :module, :sclass then parent.loc.keyword` (1.91).
+                FrameKind::ClassLike { kw_start, kw_end } => {
+                    return AlignRange {
+                        start: *kw_start,
+                        end: *kw_end,
+                    };
+                }
                 _ => {}
             }
         }
@@ -670,6 +680,24 @@ impl<'a> Visitor<'a> {
             }
         } else if node.as_block_node().is_some() {
             FrameKind::Block
+        } else if let Some(n) = node.as_class_node() {
+            let (s, e) = loc(&n.class_keyword_loc());
+            FrameKind::ClassLike {
+                kw_start: s,
+                kw_end: e,
+            }
+        } else if let Some(n) = node.as_module_node() {
+            let (s, e) = loc(&n.module_keyword_loc());
+            FrameKind::ClassLike {
+                kw_start: s,
+                kw_end: e,
+            }
+        } else if let Some(n) = node.as_singleton_class_node() {
+            let (s, e) = loc(&n.class_keyword_loc());
+            FrameKind::ClassLike {
+                kw_start: s,
+                kw_end: e,
+            }
         } else if is_write_node(node) {
             FrameKind::Write
         } else {
@@ -843,4 +871,30 @@ mod tests {
     fn rescue_inside_if_branches_no_offense() {
         assert!(variable("if a\n  a rescue nil\nelse\n  a rescue nil\nend\n").is_empty());
     }
+
+    // 1.91: an implicit-begin `rescue`/`else` in a class body aligns with
+    // the `class` keyword (`when :class, :module, :sclass then
+    // parent.loc.keyword`), not with `rescue`.
+    #[test]
+    fn class_body_else_aligns_with_class_keyword() {
+        let r = keyword("class MyClass\n  foo\nrescue SomeException\n  bar\n  else\n  baz\nend\n");
+        assert_eq!(r.len(), 1);
+        assert!(r[0].message.contains("Align `else` with `class`."));
+        assert_eq!(r[0].column_delta, -2);
+        assert!(keyword("class MyClass\n  foo\nrescue SomeException\n  bar\nelse\n  baz\nend\n").is_empty());
+    }
+
+    #[test]
+    fn module_body_else_aligns_with_module_keyword() {
+        let r = keyword("module M\n  foo\nrescue E\n  bar\n  else\n  baz\nend\n");
+        assert_eq!(r.len(), 1);
+        assert!(r[0].message.contains("Align `else` with `module`."));
+    }
+
+    #[test]
+    fn sclass_body_else_aligns_with_class_keyword() {
+        let r = keyword("class << self\n  foo\nrescue E\n  bar\n  else\n  baz\nensure\n  q\nend\n");
+        assert_eq!(r.len(), 1);
+        assert!(r[0].message.contains("Align `else` with `class`."));
+    }
 }

data/crates/shirobai-core/src/rules/extra_spacing.rs

@@ -1050,4 +1050,15 @@ mod tests {
         // The first `=` (col 2) is not aligned with the block's max -> flagged.
         assert_eq!(off.len(), 1);
     }
+
+    // 1.91: a line carrying another alignable operator (`<<`, `==`, ...)
+    // that is not itself an assignment line ends the equal-sign alignment
+    // group, so the assignments around it are not "unaligned".
+    #[test]
+    fn force_alignment_group_ends_at_an_interrupting_operator_line() {
+        assert!(run("aaaa = b\ne << f\ng += h\n", cfg(true, false, true)).is_empty());
+        assert!(run("aaaa = b\nraise if e == f\ng += h\n", cfg(true, false, true)).is_empty());
+        // Sanity: adjacent assignments still form a group.
+        assert_eq!(run("aaaa = b\ng += h\n", cfg(true, false, true)).len(), 1);
+    }
 }

data/crates/shirobai-core/src/rules/first_array_element_indentation.rs

@@ -86,7 +86,8 @@ pub fn check_first_array_element_indentation(
 /// Build the rule for use standalone or in a shared-walk bundle. `None` when
 /// the cop is disabled outright: `Layout/ArrayAlignment` enforcing
 /// `with_fixed_indentation` gates both `on_array` and `on_send` unless the
-/// style is `consistent`.
+/// style is `consistent` (`autocorrect_incompatible_with_other_cops?`, whose
+/// per-array part for the `consistent` style runs in `process_array`).
 pub(crate) fn build_rule(
     source: &[u8],
     style: u8,
@@ -102,6 +103,7 @@ pub(crate) fn build_rule(
         line_index: super::line_index::with_line_index(source, |li| li.clone()),
         style,
         indent: indent_width,
+        enforce_fixed_indentation,
         stack: Vec::new(),
         offenses: Vec::new(),
     })
@@ -166,6 +168,10 @@ pub(crate) struct Visitor<'a> {
     line_index: Rc<LineIndex>,
     style: Style,
     indent: usize,
+    /// `enforce_first_argument_with_fixed_indentation?` (`Layout/ArrayAlignment`
+    /// enforces `with_fixed_indentation`). Only reaches the visitor with the
+    /// `consistent` style; the other styles stand down in `build_rule`.
+    enforce_fixed_indentation: bool,
     stack: Vec<Frame>,
     pub(crate) offenses: Vec<FirstArrayElemIndentOffense>,
 }
@@ -313,6 +319,21 @@ impl<'a> Visitor<'a> {
         let paren = self.claimed_paren(open_start);
         let first = a.elements().iter().next().map(|e| loc(&e.location()));
 
+        // `autocorrect_incompatible_with_other_cops?` for the `consistent`
+        // style (1.91): under `Layout/ArrayAlignment: with_fixed_indentation`
+        // an array of two or more elements is left alone unless its indent
+        // base is the start of its line (ArrayAlignment does not align
+        // single-element arrays, so those are still checked).
+        if self.enforce_fixed_indentation
+            && a.elements().iter().count() >= 2
+            && !matches!(
+                self.indent_base(open_start, first, paren),
+                (_, BaseType::StartOfLine)
+            )
+        {
+            return;
+        }
+
         if let Some(f) = first {
             if self.line_of(f.0) == self.line_of(open_start) {
                 return;
@@ -640,4 +661,25 @@ mod tests {
             .is_empty()
         );
     }
+
+    // 1.91 `autocorrect_incompatible_with_other_cops?` for the `consistent`
+    // style under `Layout/ArrayAlignment: with_fixed_indentation`: an array of
+    // two or more elements whose indent base is not the start of its line is
+    // left to ArrayAlignment; single-element and bracketless arrays are not.
+    #[test]
+    fn consistent_style_defers_multi_element_arrays_to_array_alignment() {
+        let enforced = |src: &str| {
+            check_first_array_element_indentation(src.as_bytes(), 1, 2, true)
+                .into_iter()
+                .map(|o| o.message)
+                .collect::<Vec<_>>()
+        };
+        assert!(enforced("foo bar: [\n      'foo',\n      'bar'\n],\nbaz: 'baz'\n").is_empty());
+        let single = enforced("foo bar: [\n1\n],\nbaz: 3\n");
+        assert_eq!(single.len(), 2);
+        assert!(single[0].contains("relative to the parent hash key"));
+        assert!(enforced("x = 1,\n    2\n").is_empty());
+        // A start-of-line base is still checked (the bracket itself is fine).
+        assert_eq!(enforced("x = [\n1,\n2\n]\n").len(), 1);
+    }
 }

data/crates/shirobai-core/src/rules/hash_syntax.rs

@@ -151,6 +151,10 @@ enum FrameKind {
         braces: bool,
         /// `pairs.last` range and whether `key.source == value.source` (omittable).
         last_pair: Option<((usize, usize), bool)>,
+        /// `hash_rockets_enforced?(hash)` (1.91): the whole hash converts to
+        /// rockets (`EnforcedStyle: hash_rockets` or `force_hash_rockets?`),
+        /// so its pairs skip the shorthand checks.
+        rockets_enforced: bool,
     },
     /// Prism `ArgumentsNode`: transparent in parser, skipped when finding a
     /// node's "parser parent".
@@ -334,11 +338,25 @@ impl Visitor<'_> {
             let h = node.as_keyword_hash_node()?;
             (h.elements().iter().collect(), false)
         };
-        let last_pair = elements.iter().filter_map(|e| e.as_assoc_node()).next_back().map(|a| {
-            let p = pair_from_assoc(self.source, &a);
-            (p.range, p.key_source == p.value_source)
-        });
-        Some(FrameKind::Hash { braces, last_pair })
+        let pairs: Vec<Pair> = elements
+            .iter()
+            .filter_map(|e| e.as_assoc_node())
+            .map(|a| pair_from_assoc(self.source, &a))
+            .collect();
+        let last_pair = pairs
+            .last()
+            .map(|p| (p.range, p.key_source == p.value_source));
+        let rockets_enforced = self.hash_rockets_enforced(&pairs);
+        Some(FrameKind::Hash {
+            braces,
+            last_pair,
+            rockets_enforced,
+        })
+    }
+
+    /// `hash_rockets_enforced?(hash_node)` (1.91).
+    fn hash_rockets_enforced(&self, pairs: &[Pair]) -> bool {
+        self.cfg.style == STYLE_HASH_ROCKETS || self.force_hash_rockets(pairs)
     }
 
     fn call_frame(&self, node: &Node<'_>) -> Option<CallFrame> {
@@ -557,12 +575,16 @@ impl Visitor<'_> {
     // ---- shorthand: `on_hash_for_mixed_shorthand` (consistent / either_consistent) ----
 
     fn on_hash_for_mixed_shorthand(&mut self, pairs: &[Pair]) {
+        // `ignore_mixed_hash_shorthand_syntax?`.
         if !self.cfg.ruby31_plus {
             return;
         }
         if self.cfg.shorthand != SHORT_CONSISTENT && self.cfg.shorthand != SHORT_EITHER_CONSISTENT {
             return;
         }
+        if self.hash_rockets_enforced(pairs) {
+            return;
+        }
         let mut omitted = Vec::new();
         let mut omittable = Vec::new();
         let mut needed = false;
@@ -618,6 +640,17 @@ impl Visitor<'_> {
         if self.ignore_hash_shorthand_syntax() {
             return;
         }
+        // `hash_rockets_enforced?(pair_node.parent)` (1.91): the parent hash
+        // is the stack top when `on_pair` runs from `enter(AssocNode)`.
+        if matches!(
+            self.stack.last().map(|f| &f.kind),
+            Some(FrameKind::Hash {
+                rockets_enforced: true,
+                ..
+            })
+        ) {
+            return;
+        }
         if self.cfg.shorthand == SHORT_ALWAYS {
             if pair.value_omission || self.require_hash_value(pair) {
                 return;
@@ -785,7 +818,9 @@ impl Visitor<'_> {
         // return unless last_pair.key.source == last_pair.value.source
         let hash_idx = self.stack.len().checked_sub(1)?;
         let (hash_braces, last_pair) = match &self.stack[hash_idx].kind {
-            FrameKind::Hash { braces, last_pair } => (*braces, *last_pair),
+            FrameKind::Hash {
+                braces, last_pair, ..
+            } => (*braces, *last_pair),
             _ => return None,
         };
         let (_last_pair_range, last_pair_omittable) = last_pair?;
@@ -1309,4 +1344,23 @@ mod tests {
         assert!(offenses("{foo: foo}", &c).is_empty());
         assert!(offenses("{foo:}", &c).is_empty());
     }
+
+    // 1.91 `hash_rockets_enforced?`: when the whole hash converts to rockets
+    // (`EnforcedStyle: hash_rockets` or `UseHashRocketsWithSymbolValues`),
+    // its pairs skip the shorthand checks instead of also being told to omit
+    // the value (which clobbered the rocket correction).
+    #[test]
+    fn rockets_enforced_hash_skips_shorthand_checks() {
+        // hash_rockets + always: only the rocket offense.
+        assert_eq!(offenses("f(a: a)", &cfg(1, 0)), vec![(2, 4, 1)]);
+        // ruby19 + always + UseHashRocketsWithSymbolValues.
+        let mut c = cfg(0, 0);
+        c.use_hash_rockets_with_symbol_values = true;
+        assert_eq!(offenses("f(a: :sym, b: b)", &c), vec![(2, 4, 1), (11, 13, 1)]);
+        // hash_rockets + consistent: no mixed-shorthand offense either.
+        assert!(offenses("f(a: a, b: 1)", &cfg(1, 3)).iter().all(|o| o.2 == 1));
+        // Without rockets the shorthand check still fires.
+        assert_eq!(offenses("f(a: a)", &cfg(0, 0)).len(), 1);
+        assert_eq!(offenses("f(a: a)", &cfg(0, 0))[0].2, 3);
+    }
 }

data/crates/shirobai-core/src/rules/indentation_width.rs

@@ -334,7 +334,11 @@ impl<'a> Visitor<'a> {
         } else {
             (begin_pos as isize - indentation) as usize
         };
-        if indentation >= 0 {
+        // `pos = ind <= begin_pos ? ind..begin_pos : begin_pos..ind` (1.91):
+        // ordered by position, not by the sign of the delta, so an
+        // under-indented tab body (negative delta but `ind` behind
+        // `begin_pos`) still yields a forward range.
+        if ind <= begin_pos {
             (ind, begin_pos)
         } else {
             (begin_pos, ind)
@@ -1307,4 +1311,15 @@ mod tests {
         });
         assert!(got.is_empty());
     }
+
+    // 1.91: an under-indented tab body yields a forward offense range
+    // (`ind <= begin_pos ? ind..begin_pos : begin_pos..ind`), with the
+    // negative tab count in the message.
+    #[test]
+    fn tabs_under_indented_body_has_forward_range() {
+        let got = run_cfg("\t\ta = if b\n\tc\n\t\tend\n", |c| c.use_tabs = true);
+        assert_eq!(got.len(), 1);
+        assert!(got[0].message.contains("Use 1 (not -1) tabs"), "{}", got[0].message);
+        assert!(got[0].start_offset <= got[0].end_offset);
+    }
 }

data/crates/shirobai-core/src/rules/line_length_breakable.rs

@@ -373,6 +373,17 @@ fn offset_after_chars(source: &[u8], begin: usize, n_chars: usize) -> usize {
 
 /// `rindex(/\\(u[\da-f]{0,4}|x[\da-f]{0,2})?\z/)` — the char index of a trailing
 /// escape sequence (the backslash), if the substring ends in one.
+/// `rindex(/\s/)` — the char index of the last whitespace in `substr`.
+fn rindex_whitespace(substr: &str) -> Option<usize> {
+    substr.char_indices().rev().find_map(|(i, c)| {
+        if c.is_whitespace() {
+            Some(substr[..i].chars().count())
+        } else {
+            None
+        }
+    })
+}
+
 fn trailing_escape_char_index(substr: &str) -> Option<usize> {
     let chars: Vec<char> = substr.chars().collect();
     // Find the rightmost backslash whose suffix (to end) matches the pattern.
@@ -881,14 +892,11 @@ impl<'pr> BreakableVisitor<'_> {
         range_end: usize,
     ) -> Option<usize> {
         let substr = self.largest_possible_string(node, parent_quote, range_begin, range_end);
-        // rindex(/\s/)
-        if let Some(space_char_idx) = substr.char_indices().rev().find_map(|(i, c)| {
-            if c.is_whitespace() {
-                Some(substr[..i].chars().count())
-            } else {
-                None
-            }
-        }) {
+        // `breakable_space_position` (1.91): `rindex(/\s/)`, but a space that
+        // is the last character of the string content is no break point (the
+        // split would leave the content unchanged and loop); retry on the
+        // substring before it.
+        if let Some(space_char_idx) = self.breakable_space_position(node, range_begin, &substr) {
             // resize(space_pos + 1)
             return Some(offset_after_chars(
                 self.source,
@@ -918,6 +926,40 @@ impl<'pr> BreakableVisitor<'_> {
         Some(offset_after_chars(self.source, range_begin, new_chars))
     }
 
+    /// `breakable_space_position(node, substr)` — the char index of the last
+    /// whitespace in `substr`, unless that space sits at the end of the string
+    /// content (`space_pos + 1 > string_content_length - 1`); then the last
+    /// whitespace of `substr[0, limit]`.
+    fn breakable_space_position(
+        &self,
+        node: &Node<'pr>,
+        range_begin: usize,
+        substr: &str,
+    ) -> Option<usize> {
+        let limit = self.string_content_length(node, range_begin) as isize - 1;
+        let space_pos = rindex_whitespace(substr)?;
+        if space_pos as isize + 1 > limit {
+            if limit <= 0 {
+                return None;
+            }
+            let head: String = substr.chars().take(limit as usize).collect();
+            return rindex_whitespace(&head);
+        }
+        Some(space_pos)
+    }
+
+    /// `string_content_length(node)`: chars from the node's start to its
+    /// closing delimiter (`loc.end`), or to the node's end when it has none
+    /// (a dstr part).
+    fn string_content_length(&self, node: &Node<'pr>, range_begin: usize) -> usize {
+        let content_end = node
+            .as_string_node()
+            .and_then(|s| s.closing_loc())
+            .map(|c| c.start_offset())
+            .unwrap_or_else(|| node.location().end_offset());
+        char_count(&self.source[range_begin..content_end])
+    }
+
     /// `largest_possible_string` — the leading substring (as a `&str`) considered
     /// when choosing a break point.
     fn largest_possible_string(
@@ -1742,4 +1784,17 @@ mod tests {
         // Broken as a hash (no string delimiter).
         assert_eq!(r[0].2, "");
     }
+
+    // 1.91 `breakable_space_position`: a space that is the last character of
+    // the string content is no break point (the split would change nothing
+    // and loop); the previous space is used instead.
+    #[test]
+    fn split_string_skips_a_trailing_space_break_point() {
+        let src = "foo(\"aaaaaaaaaaaaaaaaaaaaaaaaa#{b} cc dd \" \\\n    \"ee\")\n";
+        let got = run(src, 40, true);
+        assert_eq!(got.len(), 1);
+        assert_eq!(got[0].0, 0);
+        assert_eq!(got[0].1, src.find("dd \"").unwrap());
+        assert_eq!(got[0].2, "\"");
+    }
 }

data/crates/shirobai-core/src/rules/ordered_magic_comments.rs

@@ -208,4 +208,13 @@ mod tests {
             Some((3, 2))
         );
     }
+
+    // 1.91: `warn_indent` is a magic comment (simple and Emacs forms).
+    #[test]
+    fn warn_indent_then_encoding() {
+        assert_eq!(run("# warn_indent: true\n# encoding: ascii\n"), Some((2, 1)));
+        assert_eq!(run("# warn-indent: true\n# encoding: ascii\n"), Some((2, 1)));
+        assert_eq!(run("# -*- warn_indent: true -*-\n# encoding: ascii\n"), Some((2, 1)));
+        assert_eq!(run("# encoding: ascii\n# warn_indent: true\n"), None);
+    }
 }

data/crates/shirobai-core/src/rules/parentheses_as_grouped_expression.rs

@@ -113,6 +113,14 @@ impl ParenthesesAsGroupedExpressionVisitor {
         let first_arg = &args[0];
         let Some(parens) = first_arg.as_parentheses_node() else { return; };
 
+        // `invalid_bare_argument?` (1.91): the parentheses are required when
+        // their (possibly re-parenthesised) sole expression could not stand as
+        // a bare argument — `and` / `or` / `not`, a modifier `rescue`, or a
+        // modifier `if` / `unless` / `while` / `until`.
+        if invalid_bare_argument(first_arg) {
+            return;
+        }
+
         // `node.operator_method?` / `node.setter_method?` — outer method name.
         // The `ParenthesesNode` gate already rejects block / chain / hash /
         // ternary / unparenthesised range first arguments by construction
@@ -149,6 +157,78 @@ impl ParenthesesAsGroupedExpressionVisitor {
     }
 }
 
+/// Stock's `invalid_bare_argument?`:
+///
+/// ```ruby
+/// node = node.children.first while node&.begin_type? && node.children.one?
+/// return false unless node
+/// keyword_operator?(node) || modifier_expression?(node)
+/// ```
+///
+/// Parser wraps `(...)` in a `begin` whose children are the statements; prism
+/// gives a `ParenthesesNode` whose `body` is a `StatementsNode`. Peeling a
+/// single-statement parenthesis repeatedly lands on the innermost expression
+/// (or on nothing for `()`).
+fn invalid_bare_argument(node: &Node<'_>) -> bool {
+    if let Some(parens) = node.as_parentheses_node() {
+        // `()`: `children.first` is nil.
+        let Some(body) = parens.body() else { return false };
+        if let Some(stmts) = body.as_statements_node() {
+            let children: Vec<Node<'_>> = stmts.body().iter().collect();
+            if children.len() == 1 {
+                return invalid_bare_argument(&children[0]);
+            }
+        }
+        // A multi-statement `begin` is neither a keyword operator nor a
+        // modifier expression.
+        return false;
+    }
+    keyword_operator(node) || modifier_expression(node)
+}
+
+/// `keyword_operator?`: `(operator_keyword? && semantic_operator?)` — an
+/// `and` / `or` spelled with the keyword — or a modifier `rescue`, or a `not`
+/// call (`send_type? && prefix_not?`).
+fn keyword_operator(node: &Node<'_>) -> bool {
+    if let Some(n) = node.as_and_node() {
+        return n.operator_loc().as_slice() == b"and";
+    }
+    if let Some(n) = node.as_or_node() {
+        return n.operator_loc().as_slice() == b"or";
+    }
+    if node.as_rescue_modifier_node().is_some() {
+        return true;
+    }
+    if let Some(c) = node.as_call_node() {
+        // `prefix_not?` = `keyword_not?`: the selector is spelled `not`.
+        return c.message_loc().is_some_and(|m| m.as_slice() == b"not");
+    }
+    false
+}
+
+/// `modifier_expression?`: `type?(:if, :while, :until) && modifier_form?`. In
+/// prism a modifier form has its keyword after the node's start (the body
+/// comes first). `begin ... end while x` is parser's `while_post`, which
+/// `type?(:while)` does not match, so the begin-modifier flag excludes it.
+fn modifier_expression(node: &Node<'_>) -> bool {
+    let node_start = node.location().start_offset();
+    if let Some(n) = node.as_if_node() {
+        return n
+            .if_keyword_loc()
+            .is_some_and(|k| k.start_offset() > node_start);
+    }
+    if let Some(n) = node.as_unless_node() {
+        return n.keyword_loc().start_offset() > node_start;
+    }
+    if let Some(n) = node.as_while_node() {
+        return !n.is_begin_modifier() && n.keyword_loc().start_offset() > node_start;
+    }
+    if let Some(n) = node.as_until_node() {
+        return !n.is_begin_modifier() && n.keyword_loc().start_offset() > node_start;
+    }
+    false
+}
+
 /// rubocop-ast `OPERATOR_METHODS` — every operator that can be defined as a
 /// method. Identical to the table in `nested_parenthesized_calls`. The list is
 /// closed (no Ruby version adds new ones in practice), so we encode it
@@ -407,4 +487,21 @@ mod tests {
         // selector `func` ends at 6, arg `(x)` starts at 9.
         assert_eq!(off, vec![(6, 9, 9, 12)]);
     }
+
+    // 1.91 `invalid_bare_argument?`: parentheses around an `and` / `or` /
+    // `not`, a modifier `rescue` or a modifier conditional are required, so
+    // they are not a grouped expression; `&&` still is.
+    #[test]
+    fn accepts_parentheses_required_by_keyword_operators_and_modifiers() {
+        assert!(detect("false? (foo and bar)\n").is_empty());
+        assert!(detect("false? (foo or bar)\n").is_empty());
+        assert!(detect("false? (not foo)\n").is_empty());
+        assert!(detect("false? (foo rescue bar)\n").is_empty());
+        assert!(detect("false? (foo if bar)\n").is_empty());
+        assert!(detect("false? (foo unless bar)\n").is_empty());
+        assert!(detect("false? (foo while bar)\n").is_empty());
+        assert!(detect("false? ((foo and bar))\n").is_empty());
+        assert_eq!(detect("false? (foo && bar)\n"), vec![(6, 7, 7, 19)]);
+        assert_eq!(detect("false? (!foo)\n"), vec![(6, 7, 7, 13)]);
+    }
 }

data/crates/shirobai-core/src/rules/space_around_operators.rs

@@ -108,8 +108,10 @@ pub struct SpaceAroundOperatorsOffense {
 }
 
 /// Whether an operator routes through the assignment alignment path (`:assignment`)
-/// or the generic operator alignment path (everything else). Stock distinguishes
-/// only these two for `excess_leading_space?`.
+/// or the generic operator alignment path (everything else). Stock's
+/// `excess_leading_space?` distinguishes `:assignment`, `:special_asgn` (which
+/// joins the assignment path only under `ForceEqualSignAlignment`, 1.91) and
+/// the rest.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum AlignType {
     /// `on_assignment` for a plain assignment (`lvasgn` / `casgn` / ... /
@@ -117,8 +119,9 @@ enum AlignType {
     /// diverts `op_asgn_type?` — the arithmetic `+=` family — to
     /// `:special_asgn`.
     Assignment,
-    /// Everything else (binary, ternary, pair, class, setter, `+=`-style
-    /// op-assign, ...).
+    /// `:special_asgn`: the `+=`-style op-assign family and setter methods.
+    SpecialAsgn,
+    /// Everything else (binary, ternary, pair, class, ...).
     Other,
 }
 
@@ -501,7 +504,11 @@ fn excess_leading_space(
     if !config.allow_for_alignment {
         return false;
     }
-    if align_type != AlignType::Assignment {
+    // `grouped_alignment_type?(type)` (1.91): `:assignment`, or `:special_asgn`
+    // when `Layout/ExtraSpacing` forces equal-sign alignment.
+    let grouped = align_type == AlignType::Assignment
+        || (align_type == AlignType::SpecialAsgn && config.force_equal_sign_alignment);
+    if !grouped {
         // `!aligned_with_operator?(operator)`.
         return !aligner.aligned_with_operator(op_start, op_end);
     }
@@ -777,7 +784,7 @@ impl Visitor<'_> {
             if let Some(arg) = self.first_argument(node) {
                 let (rs, re) = (arg.start_offset(), arg.end_offset());
                 self.check_operator(
-                    AlignType::Other,
+                    AlignType::SpecialAsgn,
                     eq.start_offset(),
                     eq.end_offset(),
                     rs,
@@ -1017,10 +1024,10 @@ impl Visitor<'_> {
         );
     }
 
-    /// `on_assignment` for an op-assign (`op_asgn_type?`): :special_asgn (Other).
+    /// `on_assignment` for an op-assign (`op_asgn_type?`): :special_asgn.
     fn check_op_assign<'pr>(&mut self, op: Location<'pr>, right: Location<'pr>) {
         self.check_operator(
-            AlignType::Other,
+            AlignType::SpecialAsgn,
             op.start_offset(),
             op.end_offset(),
             right.start_offset(),
@@ -1266,4 +1273,19 @@ end
         assert!(off.iter().any(|o| o.2 == MessageKind::Missing
             && &"uri.path+= '/'\n".as_bytes()[o.0..o.1] == b"+="));
     }
+
+    /// 1.91 `grouped_alignment_type?`: under `ForceEqualSignAlignment` an
+    /// op-assign (`:special_asgn`) takes the assignment alignment path, so a
+    /// `+=` aligned with a preceding `=` is accepted; without it the generic
+    /// operator rule still flags the padding.
+    #[test]
+    fn op_assign_aligned_with_preceding_assignment_under_force_alignment() {
+        let src = "aaaa = 1\nfoo\nb   += 2\n";
+        let forced = Config {
+            force_equal_sign_alignment: true,
+            ..default_cfg()
+        };
+        assert!(run(src, forced).is_empty());
+        assert_eq!(run(src, default_cfg()).len(), 1);
+    }
 }

data/ext/shirobai/src/lib.rs

@@ -2658,21 +2658,22 @@ fn check_line_end_concatenation(source: RString) -> Vec<(usize, usize, String, u
 
 /// Ruby entry point for `Layout/ArgumentAlignment`. Takes the source, the
 /// enforced style (0=with_first_argument, 1=with_fixed_indentation), the
-/// configured indentation width and whether autocorrect is incompatible with
-/// `Layout/HashAlignment`'s separator styles (which disables this cop's
-/// autocorrect). Returns `[[start, end, column_delta, autocorrect], ...]`.
+/// configured indentation width and whether `Layout/HashAlignment` aligns on
+/// separators (`enforce_hash_argument_with_separator?`; with
+/// `with_first_argument` that disables the cop). Returns
+/// `[[start, end, column_delta, autocorrect], ...]`.
 fn check_argument_alignment(
     source: RString,
     style: u8,
     indent_width: usize,
-    incompatible: bool,
+    hash_separator: bool,
 ) -> Vec<(usize, usize, isize, bool)> {
     map_argument_alignment(
         shirobai_core::rules::argument_alignment::check_argument_alignment(
             bytes(&source),
             style,
             indent_width,
-            incompatible,
+            hash_separator,
         ),
     )
 }

data/lib/shirobai/cop/layout/argument_alignment.rb

@@ -27,20 +27,23 @@ module Shirobai
         def self.badge = RuboCop::Cop::Badge.parse("Layout/ArgumentAlignment")
 
         # Packed args for the bundled run: `[style, indentation_width,
-        # incompatible]`. `incompatible` replicates the instance derivation
-        # exactly: it is only true for the explicit `with_first_argument` style
-        # combined with a separator-aligned `Layout/HashAlignment`.
+        # hash_separator]`. `hash_separator` is stock's
+        # `enforce_hash_argument_with_separator?` (a separator-aligned
+        # `Layout/HashAlignment`). Rust derives the rest from it: with
+        # `with_first_argument` it disables the cop
+        # (`autocorrect_incompatible_with_other_cops?`); with
+        # `with_fixed_indentation` a trailing braceless hash's pairs are left
+        # to HashAlignment (1.91).
         def self.bundle_args(config)
           cop_config = config.for_badge(badge)
           enforced_style = cop_config["EnforcedStyle"]
-          incompatible = enforced_style == "with_first_argument" &&
-                         RuboCop::Cop::Layout::HashAlignment::SEPARATOR_ALIGNMENT_STYLES.any? do |sep_style|
-                           config.for_enabled_cop("Layout/HashAlignment")[sep_style]&.include?("separator")
-                         end
+          hash_separator = RuboCop::Cop::Layout::HashAlignment::SEPARATOR_ALIGNMENT_STYLES.any? do |sep_style|
+            config.for_enabled_cop("Layout/HashAlignment")[sep_style]&.include?("separator")
+          end
           [
             enforced_style == "with_fixed_indentation" ? 1 : 0,
             cop_config["IndentationWidth"] || config.for_cop("Layout/IndentationWidth")["Width"] || 2,
-            incompatible
+            hash_separator
           ]
         end
 

data/lib/shirobai/cop/layout/hash_alignment.rb

@@ -91,8 +91,10 @@ module Shirobai
                 if has_value
                   correct_key_value(corrector, buffer, off, deltas, key, op, value)
                 else
-                  # `correct_no_value`: adjust the whole node by the key delta.
-                  adjust(corrector, deltas[0], range)
+                  # `correct_no_value`: adjust the whole node by the key delta,
+                  # clamped so the node is not shifted past the start of its
+                  # line (`clamped_key_delta`, 1.91).
+                  adjust(corrector, clamped_key_delta(deltas[0], range.column), range)
                 end
               end
             rescue Parser::ClobberingError
@@ -109,17 +111,21 @@ module Shirobai
           key_delta, separator_delta, value_delta = deltas
           key_start, _key_end, key_column = key
 
-          key_delta = -key_column if key_delta < -key_column
-
           key_range = Parser::Source::Range.new(buffer, off[key_start], off[key[1]])
           op_range = Parser::Source::Range.new(buffer, off[op[0]], off[op[1]])
           value_range = Parser::Source::Range.new(buffer, off[value[0]], off[value[1]])
 
-          adjust(corrector, key_delta, key_range)
+          adjust(corrector, clamped_key_delta(key_delta, key_column), key_range)
           adjust(corrector, separator_delta, op_range)
           adjust(corrector, value_delta, value_range)
         end
 
+        # Stock's `clamped_key_delta`: never remove more characters than the
+        # key has before it on its line.
+        def clamped_key_delta(key_delta, key_column)
+          [key_delta, -key_column].max
+        end
+
         # Mirrors stock's `adjust`: insert spaces for a positive delta, remove
         # `delta.abs` characters before the range for a negative one.
         def adjust(corrector, delta, range)

data/lib/shirobai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Shirobai
-  VERSION = "2026.0905.1300"
+  VERSION = "2026.0920.1100"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shirobai
 version: !ruby/object:Gem::Version
-  version: 2026.0905.1300
+  version: 2026.0920.1100
 platform: ruby
 authors:
 - fusagiko / takayamaki
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.90.0
+        version: 1.91.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.90.0
+        version: 1.91.0
 executables: []
 extensions:
 - ext/shirobai/extconf.rb