yoshiki 11.0.0.pre.10 → 11.0.0.pre.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bf1901967e5f7d00c6463a17508751166e6981eb1edac1172e52c44c0623580
-  data.tar.gz: 2c82f7056a5fa916ff1eff0d54c688113ff285fac49f8b7d0fe8469ebce33e70
+  metadata.gz: 624a862271fe20d1e371ee54c2369d19fa1ad88e447ac5a489870f6c59f5c456
+  data.tar.gz: 23b13cb682477e168ae3379fc5b3b8b25122c2a5ce9b11821763f8cae7aa7b7c
 SHA512:
-  metadata.gz: ed3f86f1b4cf9bacb1ca3da1793f2b5a9fe6e0ff2b76b486600b59a81f574ef869234a7a47720be1a0f6958ef8ec47d2b947310993fb013ccb5a604fd88c87de
-  data.tar.gz: '00294aa60e50cb7d4152902b0de1b4b22145c6fafc55f76ecbb71a7fa28aea2ba80083af30cc3708f95bcd88ded99d7a0e8066613d74c5ef91661851acb2b25c'
+  metadata.gz: 64ad4e0a64799205605bf6a2b3f174d9ed17018920ff5db7321cc56eafc1f8e8c4c71d17fc87f320379e0123355477f33d2805a4c6a1ad3e64be8fe4e131ecbe
+  data.tar.gz: e512b198eb7714d85ff507b6dfa243f10ca386a99e30d1e69aa1d988daa5c0816faf6a2bbda5c10be3c84c6f4fe2f4fb8f18629643d76c657ea5c0d307bf4266

data/.grok/skills/write-cop/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: write-cop
+description: >
+  Add or change a Yoshiki RuboCop cop (custom cop, department naming,
+  HAML vs Ruby AST, CopHelper specs, inherit yml wiring). Use when adding
+  a cop, forking a stock cop, writing Yoshiki/Haml or Yoshiki/Style rules,
+  or when the user runs /write-cop.
+---
+
+# Write a Yoshiki cop
+
+Work in this gem. Apps inherit and bump; they do not grow `lib/rubocop` copies — Rails `autoload_lib` Zeitwerk-eager-loads those paths (CI especially) and blows up on `RuboCop::Cop::…`.
+
+One cop per commit. Version bump is a later commit, not this one.
+
+## Name
+
+| Kind | Name | Stock cop |
+|------|------|-----------|
+| Fork | `Yoshiki/<stock department>/<Cop>` | Disable it next to the Yoshiki cop |
+| New Ruby | `Yoshiki/Style/<Cop>` (or Layout, Lint) | Leave stock enabled |
+| Leaves Ruby (HAML tree, whole file) | `Yoshiki/Haml/<Cop>` | — |
+| Shared helper | `RuboCop::Cop::Yoshiki::<Name>` module, not `< Base` | — |
+
+Never `Yoshiki/Ruby/`. Nest under HAML (or another plugin) only when the cop is not a Ruby AST walker.
+
+Department is the class of offense, not the syntax it touches. Silent semantic change is Lint (bare `key:` can absorb the next expression → `Lint/ParenthesizeValueOmission`). Hang/indent is Layout. Order/preference is Style.
+
+One concern per cop. Keyword-only calls already split hang (`Layout/HangingKeywordArguments`), value-omission parens (`Lint/ParenthesizeValueOmission`), key order (`Style/SortedKeywordArguments`), padding (`Layout/HashAlignment`). Do not fold those back together.
+
+A new rule that *feeds* a stock cop is not a fork. HashSyntax still owns `:` vs `=>`; nesting hyphenated `data`/`aria` keys is `Yoshiki/Style/NestedHtmlOptionKeys`.
+
+## Template
+
+Copy the closest cop; do not invent a new shape.
+
+| Kind | Cop | Spec |
+|------|-----|------|
+| Fork | `lib/rubocop/cop/yoshiki/style/it_block_parameter.rb` | `spec/rubocop/cop/yoshiki/style/it_block_parameter_spec.rb` |
+| Layout / lint / style | `…/layout/hanging_keyword_arguments.rb`, `…/lint/parenthesize_value_omission.rb`, `…/style/sorted_keyword_arguments.rb` | matching `spec/…` |
+| HAML document | `…/haml/sibling_blank_lines.rb` | `spec/…/haml/sibling_blank_lines_spec.rb` (`investigate_fragments`, `.haml` path) |
+| Ruby hashes in HAML (extracted by `rubocop-haml`) | `…/style/nested_html_option_keys.rb` | CopHelper, no file path |
+| Mixin | `lib/rubocop/cop/yoshiki/keyword_only_arguments.rb` | — |
+
+`rubocop-haml` already feeds tag `{}` to `on_hash` / `on_send`. Walk the HAML parser only when fragments cannot see the rule (sibling blank lines).
+
+## Files
+
+```
+lib/rubocop/cop/yoshiki/<dept>/<cop>.rb
+spec/rubocop/cop/yoshiki/<dept>/<cop>_spec.rb
+```
+
+Split helpers into another class in the same department (or `<cop>/*.rb`) before `Metrics/ClassLength` 100. Do not disable the metric.
+
+Always-on Ruby: `require` in `lib/yoshiki.rb`, enable in `.yoshiki-ruby.yml`.
+
+HAML / Rails / other plugin inherit only: `require` + `Enabled` in `.yoshiki-haml.yml` / `.yoshiki-rails.yml` (etc.), with `Include` for those files. Do not require those cops from `yoshiki.rb` — a `data:` hash in Faraday is not HTML.
+
+Fork: disable the stock cop in the same yml (see `Style/ItBlockParameter` in `.yoshiki-ruby.yml`).
+
+## Specs
+
+Ruby AST: `include CopHelper` (`spec/support/cop_helper.rb`). Define `cop_class`, `cop_name`, `cop_defaults`. **No path** on `ProcessedSource` when `autocorrect: true` — Team would write that filename in cwd.
+
+Plugin-only cops are not loaded by `require 'yoshiki'`; `require` the cop file in the spec (see NestedHtmlOptionKeys).
+
+HAML document cops: `investigate_fragments` with original path ending `.haml`, as SiblingBlankLines does.
+
+Assert `corrector.rewrite` against the full expected source. Uncorrectable: offense present, source unchanged (`corrector` may be nil).
+
+## Autocorrect
+
+One `corrector.replace` per overlapping range. If an ancestor rewrite already rebuilds a child node, do not also correct the child.
+
+Pair-level edits when ranges do not overlap; rewrite the whole hash/send when keys must merge.
+
+Leave table padding and `:` vs `=>` to HashAlignment / HashSyntax.
+
+Collision or unsafe rewrite: `add_offense` without replacing.
+
+When autocorrect changes call shape (parens, hang, pair order), `include ReparsedEquivalence` so a non-equivalent rewrite is dropped. Copy that from the keyword-only cops.
+
+Do not rewrite an identifier if the replacement binds differently. `it` is per-block. Hash value omission stays `name: it`, not `it:` (`ItBlockParameter`).
+
+## Check
+
+asdf Ruby from `.tool-versions` (not the app's Docker):
+
+```bash
+asdf exec bundle exec rspec spec/rubocop/cop/yoshiki/<dept>/<cop>_spec.rb
+asdf exec bundle exec rubocop -a --force-exclusion lib/rubocop/cop/yoshiki/<dept>/<cop>.rb spec/rubocop/cop/yoshiki/<dept>/<cop>_spec.rb
+asdf exec bundle exec rspec
+```
+
+Match existing cop style (`MSG = '…'.freeze`, `Style/MethodDefParentheses`). Hand-fix what `-a` leaves.
+
+Commit message: `in which <model> & I add Yoshiki/<Dept>/<Cop>`.

data/.yoshiki-haml.yml

@@ -3,8 +3,16 @@ plugins:
 
 require:
   - rubocop/cop/yoshiki/haml/sibling_blank_lines
+  - rubocop/cop/yoshiki/style/nested_html_option_keys
 
 Yoshiki/Haml/SiblingBlankLines:
   Enabled: true
   Include:
     - '**/*.haml'
+Yoshiki/Style/NestedHtmlOptionKeys:
+  Enabled: true
+  Prefixes:
+    - data
+    - aria
+  Include:
+    - '**/*.haml'

data/.yoshiki-rails.yml

@@ -1,6 +1,18 @@
 plugins:
   - rubocop-rails
 
+require:
+  - rubocop/cop/yoshiki/style/nested_html_option_keys
+
+Yoshiki/Style/NestedHtmlOptionKeys:
+  Enabled: true
+  Prefixes:
+    - data
+    - aria
+  Include:
+    - '**/*.haml'
+    - 'app/helpers/**/*.rb'
+
 AllCops:
   Exclude:
     - db/schema.rb

data/.yoshiki-ruby.yml

@@ -183,6 +183,8 @@ Style/SymbolArray:
 Style/TrailingUnderscoreVariable:
   AllowNamedUnderscoreVariables: false # defaults to `true`
 
+Yoshiki/Layout/EmptyLineBeforeComment:
+  Enabled: true
 Yoshiki/Layout/HangingKeywordArguments:
   Enabled: true
   MinKeywords: 2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    yoshiki (11.0.0.pre.10)
+    yoshiki (11.0.0.pre.11)
       rubocop (= 1.89.0)
       rubocop-performance (= 1.26.1)
       rubocop-rake (= 0.7.1)

data/lib/rubocop/cop/yoshiki/haml/sibling_blank_lines.rb

@@ -58,7 +58,7 @@ module RuboCop
 
           def expected_blanks left, right
             return 0 if packed?(left) || packed?(right)
-            return 0 if leaf?(left) && leaf?(right)
+            return 0 if single_line?(left) && single_line?(right)
 
             1
           end
@@ -68,8 +68,8 @@ module RuboCop
               (node.type == :silent_script && CONTROL.include?(node.value[:keyword].to_s))
           end
 
-          def leaf? node
-            node.type != :filter && node.children.empty?
+          def single_line? node
+            finish(node) == node.line
           end
 
           def blank_lines left, right, lines
@@ -81,11 +81,16 @@ module RuboCop
           end
 
           def finish node
-            extra = node.type == :filter ? node.value[:text].to_s.lines.size : 0
-            last  = (node.line || 0) + extra
+            last = (node.line || 0) + filter_lines(node)
             node.children.reduce(last) { |memo, child| [ memo, finish(child) ].max }
           end
 
+          def filter_lines node
+            return 0 unless node.type == :filter
+
+            node.value[:text].to_s.lines.reverse.drop_while { it.strip.empty? }.size
+          end
+
           def events_for ops
             ops.flat_map { events_for_op(it) }
                .sort_by { |lineno, kind| [ lineno, kind == :delete ? 0 : 1 ] }
@@ -111,7 +116,7 @@ module RuboCop
 
         end
 
-        # Blank line between layout siblings; packed leaf units stay packed.
+        # Blank line between multi-line layout siblings; single-line siblings stay packed.
         class SiblingBlankLines < Base
 
           include RangeHelp

data/lib/rubocop/cop/yoshiki/layout/empty_line_before_comment.rb

@@ -0,0 +1,155 @@
+module RuboCop
+  module Cop
+    module Yoshiki
+      module Layout
+        # Requires a blank line before a full-line comment group when the
+        # previous physical line is code at the same indent.
+        #
+        # Consecutive `#` lines and a `=begin`/`=end` document are each one
+        # group: one blank before the first line, nothing inserted inside.
+        # `=begin` is always column 0, so it still gets a blank when the
+        # preceding code is indented.
+        #
+        # Trailing comments stay on their code line. A `#` comment that opens a
+        # body (`class` / `module` / `def` / `do` / `begin` / `{`) sits deeper
+        # than the opener, so it is left alone. Extra indent is not a
+        # substitute for a blank — `Layout/CommentIndentation` will pull those
+        # comments back.
+        #
+        # `# rubocop:` directives glue to the code they apply to.
+        # `# rubocop:enable` in particular frequently trails a region and
+        # must not grow a blank line.
+        #
+        # @example
+        #   # bad
+        #   include Foo
+        #   # associations
+        #   has_many :bars
+        #
+        #   # good
+        #   include Foo
+        #
+        #   # associations
+        #   has_many :bars
+        #
+        # @example
+        #   # good — first non-empty line of a body
+        #   def join!
+        #     # players
+        #     seats << player
+        #   end
+        #
+        # @example
+        #   # good — enable trails the disabled region
+        #   complicated_call(a, b, c)
+        #   # rubocop:enable Metrics/MethodLength
+        #
+        # @example
+        #   # good — disable glues to the following statement
+        #   simple_call
+        #   # rubocop:disable Metrics/MethodLength
+        #   complicated_call(a, b, c)
+        #
+        # @example
+        #   # bad
+        #   include Foo
+        #   =begin
+        #   associations
+        #   =end
+        #   has_many :bars
+        #
+        #   # good
+        #   include Foo
+        #
+        #   =begin
+        #   associations
+        #   =end
+        #   has_many :bars
+        #
+        class EmptyLineBeforeComment < Base
+
+          include RangeHelp
+          extend AutoCorrector
+
+          MSG = 'Add a blank line before this comment.'.freeze
+
+          def on_new_investigation
+            processed_source.comments.each { inspect_comment(it) }
+          end
+
+        private
+
+          def inspect_comment comment
+            return unless own_line_comment?(comment)
+            return if skip_comment?(comment)
+            return unless preceded_by_code?(comment)
+
+            add_offense(comment) { autocorrect(it, comment) }
+          end
+
+          def autocorrect corrector, comment
+            corrector.insert_before(line_begin(comment.loc.line), "\n")
+          end
+
+          def skip_comment? comment
+            magic_comment?(comment) || directive_comment?(comment)
+          end
+
+          def preceded_by_code? comment
+            previous = previous_line(comment)
+            return false unless previous
+            return false if blank?(previous)
+            return false if comment_line?(previous)
+            return true if comment.document?
+            return false if body_opener?(previous)
+
+            indent(previous) == indent(line_at(comment.loc.line))
+          end
+
+          def own_line_comment? comment
+            comment.document? || comment_line?(line_at(comment.loc.line))
+          end
+
+          def magic_comment? comment
+            MagicComment.parse(comment.text).any?
+          end
+
+          def directive_comment? comment
+            DirectiveComment.new(comment).start_with_marker?
+          end
+
+          def previous_line comment
+            return if comment.loc.line <= 1
+
+            line_at(comment.loc.line - 1)
+          end
+
+          def line_at lineno
+            processed_source.lines[lineno - 1]
+          end
+
+          def line_begin lineno
+            source_range(processed_source.buffer, lineno, 0)
+          end
+
+          def blank? line
+            line.strip.empty?
+          end
+
+          def comment_line? line
+            /\A\s*#/.match?(line) || /\A=begin\b/.match?(line) || /\A=end\b/.match?(line)
+          end
+
+          def body_opener? line
+            /\A\s*(else|elsif|when|in|rescue|ensure)\b/.match?(line)
+          end
+
+          def indent line
+            line[/\A[ \t]*/].length
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yoshiki/style/nested_html_option_keys/rewriter.rb

@@ -0,0 +1,281 @@
+module RuboCop
+  module Cop
+    module Yoshiki
+      module Style
+        class NestedHtmlOptionKeys < Base
+
+          # Rebuild a hash with hyphenated data/aria keys nested.
+          class Rewriter
+
+            def initialize node, prefixes
+              @node    = node
+              @forest  = Forest.new(node, prefixes)
+              @entries = @forest.entries
+            end
+
+            def offenses
+              changed? ? @forest.all_offenses : @forest.direct
+            end
+
+            def changed?
+              @forest.direct.any? && replacement != @node.source
+            end
+
+            def replacement
+              @replacement ||= Printer.new.render(@node, @entries)
+            end
+
+          end
+
+          # Walk pairs into a nestable entry list.
+          class Forest
+
+            attr_reader :entries, :direct, :all_offenses
+
+            def initialize node, prefixes
+              @prefixes     = prefixes
+              @direct       = []
+              @all_offenses = []
+              @tree         = Tree.new(self)
+              @entries      = build(node, mode_for(node), true)
+            end
+
+            def build node, mode, direct
+              node.children.each_with_object([]) do |child, entries|
+                push(entries, child, mode, direct)
+              end
+            end
+
+            def prefix? name
+              name && @prefixes.include?(name)
+            end
+
+            def note_offense pair, direct
+              range = pair.key.source_range
+              @all_offenses << range
+              @direct << range if direct
+            end
+
+          private
+
+            def mode_for node
+              pair = node.parent
+              return :inside_prefix if pair&.pair_type? && prefix?(key_name(pair))
+
+              :html_options
+            end
+
+            def push entries, child, mode, direct
+              name = child.pair_type? ? key_name(child) : nil
+              return @tree.append(entries, :raw, source: child.source) unless name
+
+              path = nest_path(name, mode)
+              return @tree.insert_path(entries, path, child, direct) if path
+              return @tree.merge_hash(entries, name, child, mode) if nestable_hash?(child, name, mode)
+
+              @tree.append(entries, :raw, name: name, source: child.source)
+            end
+
+            def nestable_hash? child, name, mode
+              child.value.hash_type? && (mode == :inside_prefix || prefix?(name))
+            end
+
+            def nest_path name, mode
+              return name.split('-') if mode == :inside_prefix && hyphenated_idents?(name)
+
+              prefixed_path(name) unless mode == :inside_prefix
+            end
+
+            def prefixed_path name
+              prefix, rest = split_prefixed(name)
+              return unless prefix && rest
+              return unless rest.split('-').all? { NestedHtmlOptionKeys::IDENT.match?(it) }
+
+              [ prefix ] + rest.split('-')
+            end
+
+            def split_prefixed name
+              @prefixes.each do |prefix|
+                next unless name.start_with?("#{ prefix }-")
+
+                return [ prefix, name.delete_prefix("#{ prefix }-") ]
+              end
+              nil
+            end
+
+            def hyphenated_idents? name
+              name.include?('-') && name.split('-').all? { NestedHtmlOptionKeys::IDENT.match?(it) }
+            end
+
+            def key_name pair
+              return unless pair&.pair_type?
+
+              key = pair.key
+              return key.value.to_s if key.sym_type?
+              return key.value if key.str_type?
+
+              nil
+            end
+
+          end
+
+          # Mutate an entry list: nest, merge, or keep the original pair.
+          class Tree
+
+            def initialize forest
+              @forest = forest
+            end
+
+            def insert_path entries, path, pair, direct
+              @forest.note_offense(pair, direct)
+              slot = ensure_branch(entries, path.first)
+              return if slot && merge_leaf?(slot[:children], path.drop(1), pair)
+
+              entries.delete(slot) if slot && slot[:children].empty?
+              append(entries, :raw, source: pair.source)
+            end
+
+            def merge_hash entries, name, pair, mode
+              nested = @forest.build(pair.value, (@forest.prefix?(name) ? :inside_prefix : mode), false)
+              slot   = find_named(entries, name)
+              return append(entries, :branch, name: name, children: nested, node: pair.value) if slot.nil?
+              return absorb(slot, nested, pair.value) if slot[:kind] == :branch
+
+              append(entries, :raw, source: pair.source)
+            end
+
+            def append entries, kind, **fields
+              entry = { kind: kind, **fields }
+              entries << entry
+              entry
+            end
+
+          private
+
+            def ensure_branch entries, name
+              slot = find_named(entries, name)
+              return append(entries, :branch, name: name, children: []) if slot.nil?
+              return slot if slot[:kind] == :branch
+
+              nil
+            end
+
+            def merge_leaf? entries, path, pair
+              first, *rest = path
+              return add_leaf?(entries, first, pair) if rest.empty?
+
+              slot = ensure_branch(entries, first) or return false
+              return true if merge_leaf?(slot[:children], rest, pair)
+
+              entries.delete(slot) if slot[:children].empty?
+              false
+            end
+
+            def add_leaf? entries, name, pair
+              return false if find_named(entries, name)
+
+              source = pair.value_omission? ? '' : pair.value.source
+              append(entries, :leaf, name: name, source: source)
+              true
+            end
+
+            def absorb slot, nested, hash
+              slot[:node] ||= hash
+              nested.each { merge_entry(slot[:children], it) }
+            end
+
+            def merge_entry entries, entry
+              if (existing = mergeable_branch(entries, entry))
+                (entry[:children] || []).each { merge_entry(existing[:children], it) }
+              elsif entry[:kind] != :raw && find_named(entries, entry[:name])
+                append(entries, :raw, source: entry[:source] || Printer.new.render_entry(entry))
+              else
+                entries << entry
+              end
+            end
+
+            def mergeable_branch entries, entry
+              return if entry[:kind] != :branch
+
+              existing = find_named(entries, entry[:name])
+              existing if existing && existing[:kind] == :branch
+            end
+
+            def find_named entries, name
+              entries.find { it[:name] == name }
+            end
+
+          end
+
+          # Format nested entries back into a hash literal.
+          class Printer
+
+            def render node, entries
+              parts = entries.map { render_entry(it) }
+              return multiline(node, parts) if node.multiline?
+              return "{ #{ parts.join(', ') } }" if node.braces?
+
+              parts.join(', ')
+            end
+
+            def render_entry entry
+              case entry[:kind]
+                when :raw  then entry[:source]
+                when :leaf then leaf_source(entry)
+                else "#{ entry[:name] }: #{ render_branch(entry) }"
+              end
+            end
+
+          private
+
+            def multiline node, parts
+              indent = ' ' * continuation_column(node)
+              return parts.join(",\n#{ indent }") unless node.braces?
+
+              braced_multiline(node, parts, indent)
+            end
+
+            def braced_multiline node, parts, indent
+              if node.children.first.source_range.line == node.loc.begin.line
+                same_line_brace(parts, indent)
+              else
+                close = ' ' * node.loc.end.column
+                "{\n#{ indent }#{ parts.join(",\n#{ indent }") }\n#{ close }}"
+              end
+            end
+
+            def same_line_brace parts, indent
+              rest = parts.drop(1)
+              return "{ #{ parts.first } }" if rest.empty?
+
+              "{ #{ parts.first },\n#{ indent }#{ rest.join(",\n#{ indent }") } }"
+            end
+
+            def continuation_column node
+              children = node.children
+              rest     = children[1]
+              if rest && rest.source_range.line != children.first.source_range.line
+                rest.source_range.column
+              else
+                children.first.source_range.column
+              end
+            end
+
+            def render_branch entry
+              children = entry[:children] || []
+              return render(entry[:node], children) if entry[:node]
+
+              "{ #{ children.map { render_entry(it) }.join(', ') } }"
+            end
+
+            def leaf_source entry
+              entry[:source].empty? ? "#{ entry[:name] }:" : "#{ entry[:name] }: #{ entry[:source] }"
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yoshiki/style/nested_html_option_keys.rb

@@ -0,0 +1,76 @@
+module RuboCop
+  module Cop
+    module Yoshiki
+      module Style
+        # Nests hyphenated `data-*` / `aria-*` keys so every key is a 1.9
+        # identifier. Rails and Haml flatten the nested hashes back to the
+        # same HTML (`data-game-live-target`, `aria-label`).
+        #
+        # This is not a HashSyntax replacement. HashSyntax still owns `:` vs
+        # `=>`. Nesting first is what lets HashSyntax stay in ruby19 form
+        # instead of mixed rockets or quoted-symbol keys.
+        #
+        # Keys whose hyphen segments are not identifiers (`1p-ignore`) stay.
+        # Real HTML attributes (`http-equiv`) stay. Stimulus controller names
+        # are not renamed — hyphens split in place.
+        #
+        # @example
+        #   # bad
+        #   { data: { controller: 'chat', 'chat-target' => 'input' } }
+        #   { 'aria-label' => placeholder }
+        #
+        #   # good
+        #   { data: { controller: 'chat', chat: { target: 'input' } } }
+        #   { aria: { label: placeholder } }
+        class NestedHtmlOptionKeys < Base
+
+          extend AutoCorrector
+
+          MSG   = 'Nest hyphenated HTML option keys as symbol hashes.'.freeze
+          IDENT = /\A[a-z_][a-z0-9_]*\z/
+
+          def on_hash node
+            (@hashes ||= []) << node
+          end
+
+          def on_investigation_end
+            flagged.each { register(it) }
+            @hashes = []
+
+            super
+          end
+
+        private
+
+          def prefixes
+            cop_config.fetch('Prefixes', %w[ data aria ])
+          end
+
+          def flagged
+            hashes = (@hashes || []).select { rewriter(it).offenses.any? }
+            hashes.reject! { it.each_ancestor(:hash).any? { rewriter(it).changed? } }
+            hashes
+          end
+
+          def rewriter node
+            Rewriter.new(node, prefixes)
+          end
+
+          def register node
+            built = rewriter(node)
+            built.offenses.each_with_index do |range, index|
+              add_offense(range) do |corrector|
+                next unless index.zero? && built.changed?
+
+                corrector.replace(node, built.replacement)
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end
+
+require_relative 'nested_html_option_keys/rewriter'

data/lib/yoshiki/version.rb

@@ -1,5 +1,5 @@
 module Yoshiki
 
-  VERSION = '11.0.0-10'.freeze
+  VERSION = '11.0.0-11'.freeze
 
 end

data/lib/yoshiki.rb

@@ -1,6 +1,7 @@
 require 'yoshiki/version'
 require 'rubocop'
 require 'rubocop/cop/yoshiki/keyword_only_arguments'
+require 'rubocop/cop/yoshiki/layout/empty_line_before_comment'
 require 'rubocop/cop/yoshiki/layout/hanging_keyword_arguments'
 require 'rubocop/cop/yoshiki/lint/parenthesize_value_omission'
 require 'rubocop/cop/yoshiki/style/it_block_parameter'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yoshiki
 version: !ruby/object:Gem::Version
-  version: 11.0.0.pre.10
+  version: 11.0.0.pre.11
 platform: ruby
 authors:
 - BM5k
@@ -61,6 +61,7 @@ files:
 - ".git-blame-ignore-revs"
 - ".gitignore"
 - ".gitlab-ci.yml"
+- ".grok/skills/write-cop/SKILL.md"
 - ".rspec"
 - ".rubocop-defaults-capybara.yml"
 - ".rubocop-defaults-minitest.yml"
@@ -85,9 +86,12 @@ files:
 - bin/console
 - lib/rubocop/cop/yoshiki/haml/sibling_blank_lines.rb
 - lib/rubocop/cop/yoshiki/keyword_only_arguments.rb
+- lib/rubocop/cop/yoshiki/layout/empty_line_before_comment.rb
 - lib/rubocop/cop/yoshiki/layout/hanging_keyword_arguments.rb
 - lib/rubocop/cop/yoshiki/lint/parenthesize_value_omission.rb
 - lib/rubocop/cop/yoshiki/style/it_block_parameter.rb
+- lib/rubocop/cop/yoshiki/style/nested_html_option_keys.rb
+- lib/rubocop/cop/yoshiki/style/nested_html_option_keys/rewriter.rb
 - lib/rubocop/cop/yoshiki/style/sorted_keyword_arguments.rb
 - lib/yoshiki.rb
 - lib/yoshiki/examples.rb