yoshiki 11.0.0.pre.7 → 11.0.0.pre.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d220afa1f162c7d97efcab1ceeaac3c137a6c0577c82457df40d06266b8a7fca
-  data.tar.gz: 0f5246cd97229c9c360333ef540e33858460396250cae3f058aec766fbd2f074
+  metadata.gz: 94f5b98825fc1b7b536720e8e7b0357924b84084fccd31c46b0a61edab59c4ec
+  data.tar.gz: fc265b7932404fa8820b90e06a1b58c3b05c24a55de8bf83e95e068ba361a450
 SHA512:
-  metadata.gz: 697454ec8255d170136feeff721b6699d64f3bb2d8014aeb5968018a3f25aa7b1fb3e2bd45044bcde5dd8d096e61f24858cc1faa1e768e5fa6589afa42be334e
-  data.tar.gz: f455dcd95cc45f3b8f1468427082725b058203a228d8e6ed372e9edad888c49078e65003fc50295637c9ddaaf9080013f8ecfc26b3ce83569b6a850b0b96b6aa
+  metadata.gz: 2280c3f8309b8330f930b62b10484376b4258745046d030b08619587b174f06beae39c321f705a29c78e790476851cb58460fe4a0d3d3370dae9f3a4155dc7dc
+  data.tar.gz: 95caa06f31683f9c1676d1802cfc6eb66e29fb6bdea94b5d67e722399fcc68c914f047a25984071b236b44767bc5a6d6ef68ae9a0db8ff21de04353449eb9048

data/.rubocop-defaults-rails.yml

@@ -105,6 +105,8 @@ Rails/SquishedSQLHeredocs: # new in 2.8
   Enabled: true
 Rails/StripHeredoc: # new in 2.15
   Enabled: true
+Rails/StrongParametersExpect: # new in 2.29
+  Enabled: true # requires rails 8.0+
 Rails/TimeZoneAssignment: # new in 2.10
   Enabled: true
 Rails/ThreeStateBooleanColumn: # new in 2.19

data/.rubocop-defaults.yml

@@ -271,8 +271,6 @@ Style/InPatternThen: # new in 1.16
   Enabled: true
 Style/ItAssignment: # new in 1.70
   Enabled: true
-Style/ItBlockParameter: # new in 1.75
-  Enabled: true
 Style/KeywordArgumentsMerging: # new in 1.68
   Enabled: true
 Style/MagicCommentFormat: # new in 1.35

data/.yoshiki-haml.yml

@@ -0,0 +1,10 @@
+plugins:
+  - rubocop-haml
+
+require:
+  - rubocop/cop/yoshiki/haml/sibling_blank_lines
+
+Yoshiki/Haml/SiblingBlankLines:
+  Enabled: true
+  Include:
+    - '**/*.haml'

data/.yoshiki-rails.yml

@@ -40,8 +40,6 @@ Rails/ShortI18n: # new in 2.7
   EnforcedStyle: aggressive # default is `conservative`
 Rails/SkipsModelValidations:
   Enabled: false
-Rails/StrongParametersExpect: # new in 2.29
-  Enabled: false # requires rails 8.0+
 Rails/ToFormattedS: # new in 2.15
   Enabled: false # prefer to_s(:format)
 Rails/ToSWithArgument: # new in 2.16
@@ -63,11 +61,15 @@ Style/Documentation: # this isn't a rails cop, but this config only makes sense
     - app/jobs/application_job.rb
     - app/mailers/application_mailer.rb
     - app/models/application_record.rb
+    - app/models/current.rb
+    - app/models/session.rb
+    - app/models/user.rb
     - config/application.rb
     - db/migrate/**/*
     - lib/application_responder.rb
     - spec/**/*
     - test/**/*
+
 Style/EmptyMethod:
   Exclude:
     - app/controllers/**/*_controller.rb

data/.yoshiki-ruby.yml

@@ -1,3 +1,6 @@
+require:
+  - yoshiki
+
 AllCops:
   DisplayCopNames: true
   DisplayStyleGuide: true
@@ -131,6 +134,8 @@ Style/DoubleNegation:
 Style/FrozenStringLiteralComment:
   EnforcedStyle: never # huzzah for ruby 3.4
   SafeAutoCorrect: true # default is `false`
+Style/ItBlockParameter: # new in 1.75
+  Enabled: false # Yoshiki/Style/ItBlockParameter (force_single_line)
 Style/MethodDefParentheses:
   EnforcedStyle: require_no_parentheses
 Style/MixinUsage:
@@ -177,3 +182,18 @@ Style/SymbolArray:
   MinSize: 3 # default is `2`
 Style/TrailingUnderscoreVariable:
   AllowNamedUnderscoreVariables: false # defaults to `true`
+
+Yoshiki/Layout/HangingKeywordArguments:
+  Enabled: true
+  MinKeywords: 2
+Yoshiki/Lint/ParenthesizeValueOmission:
+  Enabled: true
+  MinKeywords: 1
+Yoshiki/Style/ItBlockParameter:
+  Enabled: true
+  EnforcedStyle: force_single_line
+  SupportedStyles:
+    - force_single_line
+Yoshiki/Style/SortedKeywordArguments:
+  Enabled: true
+  MinKeywords: 2

data/Gemfile

@@ -9,8 +9,10 @@ gem 'rake'
 gem 'rspec'
 
 # For developing optional configs (not runtime deps of the gem)
+gem 'haml'
 gem 'rubocop-capybara',    '3.0.0'
 gem 'rubocop-factory_bot', '2.28.0'
+gem 'rubocop-haml',        '0.3.1'
 gem 'rubocop-minitest',    '0.40.0'
 gem 'rubocop-rails',       '2.36.0'
 gem 'rubocop-rspec',       '3.10.2'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    yoshiki (11.0.0.pre.7)
+    yoshiki (11.0.0.pre.8)
       rubocop (= 1.89.0)
       rubocop-performance (= 1.26.1)
       rubocop-rake (= 0.7.1)
@@ -31,6 +31,13 @@ GEM
     date (3.5.1)
     diff-lcs (1.6.2)
     drb (2.2.3)
+    haml (7.4.1)
+      prism (>= 1.1.0)
+      temple (>= 0.8.2)
+      thor
+      tilt
+    hamli (0.6.0)
+      temple
     i18n (1.15.2)
       concurrent-ruby (~> 1.0)
     io-console (0.8.2)
@@ -94,6 +101,10 @@ GEM
     rubocop-factory_bot (2.28.0)
       lint_roller (~> 1.1)
       rubocop (~> 1.72, >= 1.72.1)
+    rubocop-haml (0.3.1)
+      hamli (~> 0.5)
+      lint_roller (>= 1.1)
+      rubocop (>= 1.72.1)
     rubocop-minitest (0.40.0)
       lint_roller (~> 1.1)
       rubocop (>= 1.75.0, < 2.0)
@@ -122,6 +133,9 @@ GEM
     ruby-progressbar (1.13.0)
     securerandom (0.4.1)
     stringio (3.2.0)
+    temple (0.10.7)
+    thor (1.5.0)
+    tilt (2.9.0)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
     unicode-display_width (3.2.0)
@@ -134,12 +148,14 @@ PLATFORMS
   arm64-darwin-25
 
 DEPENDENCIES
+  haml
   pry
   psych
   rake
   rspec
   rubocop-capybara (= 3.0.0)
   rubocop-factory_bot (= 2.28.0)
+  rubocop-haml (= 0.3.1)
   rubocop-minitest (= 0.40.0)
   rubocop-rails (= 2.36.0)
   rubocop-rspec (= 3.10.2)

data/README.md

@@ -56,6 +56,19 @@ inherit_gem:
     - .yoshiki-minitest.yml
 ```
 
+Haml — add the plugin, then inherit:
+
+```ruby
+gem 'rubocop-haml'
+```
+
+```yaml
+inherit_gem:
+  yoshiki:
+    - .yoshiki-ruby.yml # or .yoshiki-rails.yml
+    - .yoshiki-haml.yml
+```
+
 Capybara — add the plugin, then inherit:
 
 ```ruby

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

@@ -0,0 +1,165 @@
+require 'haml'
+
+module RuboCop
+  module Cop
+    module Yoshiki
+      module Haml
+
+        # Walk a Haml AST and rewrite sibling blank lines.
+        class SiblingBlankSource
+
+          MSG_MISSING = 'Add a blank line between sibling layout elements.'.freeze
+          MSG_EXTRA   = 'Remove the blank line between packed sibling leaves.'.freeze
+          CONTROL     = %w[else elsif when rescue ensure].freeze
+
+          def rewrite source
+            apply(source.lines, events_for(operations(source))).join
+          end
+
+          def operations source
+            ast = parse(source)
+            return [] unless ast
+
+            ops = []
+            collect(ast, source.lines, ops)
+            ops
+          end
+
+        private
+
+          def parse source
+            ::Haml::Parser.new({}).call(source)
+          rescue ::Haml::Error
+            nil
+          end
+
+          def collect node, lines, ops
+            node.children.each_cons(2) { |left, right| pair(left, right, lines, ops) }
+            node.children.each { collect(it, lines, ops) }
+          end
+
+          def pair left, right, lines, ops
+            return unless left.line && right.line
+
+            expected = expected_blanks(left, right)
+            blanks   = blank_lines(left, right, lines)
+            return if blanks.size == expected
+
+            ops << offense(right.line, expected, blanks)
+          end
+
+          def offense line, expected, blanks
+            if blanks.size < expected
+              { kind: :missing, line:, message: MSG_MISSING }
+            else
+              { kind: :extra, line:, message: MSG_EXTRA, remove: blanks.drop(expected) }
+            end
+          end
+
+          def expected_blanks left, right
+            return 0 if packed?(left) || packed?(right)
+            return 0 if leaf?(left) && leaf?(right)
+
+            1
+          end
+
+          def packed? node
+            node.type == :doctype ||
+              (node.type == :silent_script && CONTROL.include?(node.value[:keyword].to_s))
+          end
+
+          def leaf? node
+            node.type != :filter && node.children.empty?
+          end
+
+          def blank_lines left, right, lines
+            first = finish(left) + 1
+            last  = right.line - 1
+            return [] if last < first
+
+            (first..last).select { lines[it - 1].to_s.strip.empty? }
+          end
+
+          def finish node
+            extra = node.type == :filter ? node.value[:text].to_s.lines.size : 0
+            last  = (node.line || 0) + extra
+            node.children.reduce(last) { |memo, child| [ memo, finish(child) ].max }
+          end
+
+          def events_for ops
+            ops.flat_map { events_for_op(it) }
+               .sort_by { |lineno, kind| [ lineno, kind == :delete ? 0 : 1 ] }
+               .reverse
+          end
+
+          def events_for_op operation
+            return [ [ operation[:line], :insert ] ] if operation[:kind] == :missing
+
+            operation[:remove].map { [ it, :delete ] }
+          end
+
+          def apply lines, events
+            events.each do |lineno, kind|
+              if kind == :delete
+                lines.delete_at(lineno - 1)
+              else
+                lines.insert(lineno - 1, "\n")
+              end
+            end
+            lines
+          end
+
+        end
+
+        # Blank line between layout siblings; packed leaf units stay packed.
+        class SiblingBlankLines < Base
+
+          include RangeHelp
+
+          MSG_MISSING = SiblingBlankSource::MSG_MISSING
+          MSG_EXTRA   = SiblingBlankSource::MSG_EXTRA
+
+          def on_new_investigation
+            inspect_haml
+          end
+
+          def on_other_file
+            inspect_haml
+          end
+
+          def rewrite_source source
+            SiblingBlankSource.new.rewrite(source)
+          end
+
+        private
+
+          def inspect_haml
+            original = @current_original
+            return unless original&.path&.end_with?('.haml')
+            return if original.instance_variable_get(:@_haml_sibling_blank_lines)
+
+            original.instance_variable_set(:@_haml_sibling_blank_lines, true)
+            ops = SiblingBlankSource.new.operations(original.raw_source)
+            ops.each { add_offense(line_range(original, it[:line]), message: it[:message]) }
+            write_corrected(original, ops)
+          end
+
+          def write_corrected original, ops
+            return if ops.empty? || !@options[:autocorrect] || @options[:stdin]
+
+            path = original.file_path
+            return unless path && File.exist?(path)
+
+            File.write(path, SiblingBlankSource.new.rewrite(original.raw_source))
+          end
+
+          def line_range original, lineno
+            source_range(original.buffer, lineno, 0)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yoshiki/keyword_only_arguments.rb

@@ -0,0 +1,76 @@
+module RuboCop
+  module Cop
+    module Yoshiki
+      # Shared helpers for Yoshiki cops that inspect keyword-only method calls.
+      module KeywordOnlyArguments
+
+      private
+
+        def keyword_only_call? node, min_keywords:
+          return false unless node.arguments.one?
+
+          arg = node.arguments.first
+          return false unless arg.hash_type? && !arg.braces?
+          return false if arg.children.any? { !it.pair_type? }
+
+          arg.pairs.size >= min_keywords
+        end
+
+        def keyword_hash node
+          node.arguments.first
+        end
+
+        def value_omission? node
+          keyword_hash(node).pairs.any?(&:value_omission?)
+        end
+
+        def first_arg_on_method_line? node
+          first_pair = keyword_hash(node).pairs.first
+          same_line?(node.loc.selector, first_pair)
+        end
+
+        def braced_block? node
+          node.block_node&.braces?
+        end
+
+        def comments_inside? node
+          range = node.source_range
+          processed_source.comments.any? { range.contains?(it.loc.expression) }
+        end
+
+        def syntax_like_method_call? node
+          node.implicit_call? || node.operator_method?
+        end
+
+        def disallowed_call? node
+          allowed_method?(node.method_name) ||
+            braced_block?(node) ||
+            comments_inside?(node) ||
+            syntax_like_method_call?(node)
+        end
+
+        def pair_key_name pair
+          key = pair.key
+          return key.value.to_s if key.sym_type?
+          return key.source if key.respond_to?(:source)
+
+          key.inspect
+        end
+
+        def hanging_indent node
+          # Align under the first keyword: one char after method name (` ` or `(`).
+          ' ' * (node.loc.selector.column + node.method_name.size + 1)
+        end
+
+        def render_pairs pairs, indent
+          lines        = pairs.map { it.source.strip }
+          first, *rest = lines
+          return first if rest.empty?
+
+          ([ first ] + rest.map { "#{ indent }#{ it }" }).join(",\n")
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+module RuboCop
+  module Cop
+    module Yoshiki
+      module Layout
+        # Prefers multiline keyword-only method calls in hanging form: first
+        # keyword on the same line as the method, continuations aligned under
+        # the first keyword.
+        #
+        # Ordinary kwargs omit parentheses. Hash value omission (`key:`) keeps
+        # parentheses (see Yoshiki/Lint/ParenthesizeValueOmission); this cop only
+        # hangs inside existing parens for those calls.
+        #
+        # Key order is Yoshiki/Style/SortedKeywordArguments. Padding is
+        # Layout/HashAlignment.
+        #
+        # @example
+        #   # bad
+        #   annotations(
+        #     read_only_hint: true,
+        #     destructive_hint: false
+        #   )
+        #
+        #   # good
+        #   annotations read_only_hint: true,
+        #               destructive_hint: false
+        #
+        # @example Hash value omission (parentheses required; hang inside them)
+        #   # bad
+        #   annotations(
+        #     destructive_hint:,
+        #     read_only_hint:
+        #   )
+        #
+        #   # good
+        #   annotations(destructive_hint:,
+        #               read_only_hint:)
+        class HangingKeywordArguments < Base
+
+          include AllowedMethods
+          include KeywordOnlyArguments
+          include ReparsedEquivalence
+          extend AutoCorrector
+
+          MSG_OMIT_PARENS = [
+            'Use hanging keyword arguments ',
+            '(first kwarg on the method line, no parentheses).'
+          ].join.freeze
+          MSG_KEEP_PARENS = [
+            'Use hanging keyword arguments with parentheses ',
+            'when using hash value omission ',
+            '(first kwarg on the method line).'
+          ].join.freeze
+
+          def on_send node
+            return unless eligible?(node)
+
+            (@pending ||= []) << node
+          end
+          alias on_csend on_send
+
+          def on_investigation_end
+            verified_by_reparse(@pending || []).each do |node|
+              add_offense(offense_range(node), message: message_for(node)) do |corrector|
+                autocorrect(corrector, node)
+              end
+            end
+            @pending = []
+
+            super
+          end
+
+        private
+
+          def apply_reparse_correction corrector, node
+            autocorrect(corrector, node)
+          end
+
+          def eligible? node
+            return false unless keyword_only_call?(node, min_keywords: min_keywords)
+            return false unless multiline_keywords?(node)
+            return false if first_arg_on_method_line?(node)
+            return false if disallowed_call?(node)
+
+            # Value omission must stay parenthesized; only restyle when parens exist.
+            return false if value_omission?(node) && !node.parenthesized?
+
+            true
+          end
+
+          def multiline_keywords? node
+            node.multiline? || keyword_hash(node).multiline?
+          end
+
+          def min_keywords
+            cop_config.fetch('MinKeywords', 2)
+          end
+
+          def message_for node
+            value_omission?(node) ? MSG_KEEP_PARENS : MSG_OMIT_PARENS
+          end
+
+          def offense_range node
+            if node.parenthesized?
+              node.loc.begin.join(node.loc.end)
+            else
+              keyword_hash(node).source_range
+            end
+          end
+
+          def autocorrect corrector, node
+            rendered = render_pairs(keyword_hash(node).pairs.to_a, hanging_indent(node))
+            if value_omission?(node)
+              replace_keep_parens(corrector, node, rendered)
+            elsif node.parenthesized?
+              replace_omit_parens(corrector, node, rendered)
+            else
+              corrector.replace(keyword_hash(node).source_range, rendered)
+            end
+          end
+
+          def replace_omit_parens corrector, node, rendered
+            range = node.loc.selector.end.join(node.loc.end)
+            corrector.replace(range, " #{ rendered }")
+          end
+
+          def replace_keep_parens corrector, node, rendered
+            range = node.loc.begin.join(node.loc.end)
+            corrector.replace(range, "(#{ rendered })")
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yoshiki/lint/parenthesize_value_omission.rb

@@ -0,0 +1,90 @@
+module RuboCop
+  module Cop
+    module Yoshiki
+      module Lint
+        # Requires parentheses around method calls that use hash value omission
+        # (`key:`). Bare forms can absorb a following expression as the last
+        # keyword's value (silent semantic change).
+        #
+        # Layout (hanging first kwarg) is Yoshiki/Layout/HangingKeywordArguments.
+        # Key order is Yoshiki/Style/SortedKeywordArguments.
+        #
+        # @example
+        #   # bad
+        #   annotations destructive_hint:,
+        #               read_only_hint:
+        #
+        #   # good
+        #   annotations(destructive_hint:,
+        #               read_only_hint:)
+        #
+        # @example
+        #   # bad
+        #   annotations destructive_hint:, read_only_hint:
+        #
+        #   # good
+        #   annotations(destructive_hint:, read_only_hint:)
+        class ParenthesizeValueOmission < Base
+
+          include AllowedMethods
+          include KeywordOnlyArguments
+          include ReparsedEquivalence
+          extend AutoCorrector
+
+          MSG = [
+            'Parenthesize method calls that use hash value omission ',
+            '(`key:`) so a following expression is not absorbed as a value.'
+          ].join.freeze
+
+          def on_send node
+            return unless eligible?(node)
+
+            (@pending ||= []) << node
+          end
+          alias on_csend on_send
+
+          def on_investigation_end
+            verified_by_reparse(@pending || []).each do |node|
+              add_offense(offense_range(node), message: MSG) do |corrector|
+                autocorrect(corrector, node)
+              end
+            end
+            @pending = []
+
+            super
+          end
+
+        private
+
+          def apply_reparse_correction corrector, node
+            autocorrect(corrector, node)
+          end
+
+          def eligible? node
+            return false if node.parenthesized?
+            return false unless keyword_only_call?(node, min_keywords: min_keywords)
+            return false unless value_omission?(node)
+            return false if disallowed_call?(node)
+
+            true
+          end
+
+          def min_keywords
+            cop_config.fetch('MinKeywords', 1)
+          end
+
+          def offense_range node
+            keyword_hash(node).source_range
+          end
+
+          def autocorrect corrector, node
+            hash  = keyword_hash(node)
+            range = node.loc.selector.end.join(hash.source_range)
+            corrector.replace(range, "(#{ hash.source })")
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+module RuboCop
+  module Cop
+    module Yoshiki
+      module Style
+        # Checks for blocks with one argument where `it` block parameter can be used.
+        #
+        # `force_single_line` requires a single-line one-parameter block to use `it`.
+        # Multi-line blocks may keep a named parameter.
+        #
+        # @example EnforcedStyle: force_single_line
+        #   # bad
+        #   block { |named_param| do_something(named_param) }
+        #   block { do_something(_1) }
+        #
+        #   # good
+        #   block { do_something(it) }
+        #   block do |named_param|
+        #     do_something(named_param)
+        #   end
+        #
+        class ItBlockParameter < Base
+
+          include ConfigurableEnforcedStyle
+          extend TargetRubyVersion
+          extend AutoCorrector
+
+          MSG_USE_IT_PARAMETER = 'Use `it` block parameter.'.freeze
+
+          minimum_target_ruby_version 3.4
+
+          def on_block node
+            return unless force_single_line?
+            return unless node.single_line?
+            return unless node.arguments.one?
+            return unless node.first_argument.arg_type?
+
+            each_block_variable(node, node.first_argument.source) do |variable|
+              add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
+                remove_block_arguments(corrector, node)
+                corrector.replace(variable, 'it')
+              end
+            end
+          end
+
+          def on_numblock node
+            return unless force_single_line?
+            return unless node.single_line?
+            return unless node.children[1] == 1
+
+            each_block_variable(node, '_1') do |variable|
+              add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
+                corrector.replace(variable, 'it')
+              end
+            end
+          end
+
+        private
+
+          def force_single_line?
+            style == :force_single_line
+          end
+
+          def remove_block_arguments corrector, node
+            range = node.arguments.source_range
+            range = range.adjust(end_pos: 1) if range.source_buffer.source[range.end_pos] == ' '
+            corrector.remove(range)
+          end
+
+          def each_block_variable node, name, &block
+            find_block_variables(node, name).each(&block)
+          end
+
+          def find_block_variables node, name
+            return [] unless node.body
+
+            vars = node.body.each_descendant(:lvar).select { it.source == name }
+            vars.unshift(node.body) if node.body.lvar_type? && node.body.source == name
+            vars
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+module RuboCop
+  module Cop
+    module Yoshiki
+      module Style
+        # Enforces alphabetical order for keyword-only method call arguments.
+        #
+        # Layout is Yoshiki/Layout/HangingKeywordArguments. Value-omission
+        # parentheses are Yoshiki/Lint/ParenthesizeValueOmission. Padding is
+        # Layout/HashAlignment.
+        #
+        # @example
+        #   # bad
+        #   annotations read_only_hint: true,
+        #               destructive_hint: false
+        #
+        #   # good
+        #   annotations destructive_hint: false,
+        #               read_only_hint: true
+        #
+        # @example
+        #   # bad
+        #   annotations(read_only_hint:, destructive_hint:)
+        #
+        #   # good
+        #   annotations(destructive_hint:, read_only_hint:)
+        class SortedKeywordArguments < Base
+
+          include AllowedMethods
+          include KeywordOnlyArguments
+          include ReparsedEquivalence
+          extend AutoCorrector
+
+          MSG = 'Sort keyword arguments alphabetically by key name.'.freeze
+
+          def on_send node
+            return unless eligible?(node)
+
+            (@pending ||= []) << node
+          end
+          alias on_csend on_send
+
+          def on_investigation_end
+            verified_by_reparse(@pending || []).each do |node|
+              add_offense(offense_range(node), message: MSG) do |corrector|
+                autocorrect(corrector, node)
+              end
+            end
+            @pending = []
+
+            super
+          end
+
+        private
+
+          def apply_reparse_correction corrector, node
+            autocorrect(corrector, node)
+          end
+
+          def eligible? node
+            return false unless keyword_only_call?(node, min_keywords: min_keywords)
+            return false if disallowed_call?(node)
+            return false if sorted?(node)
+
+            true
+          end
+
+          def min_keywords
+            cop_config.fetch('MinKeywords', 2)
+          end
+
+          def sorted? node
+            names = keyword_hash(node).pairs.map { pair_key_name(it) }
+            names == names.sort
+          end
+
+          def offense_range node
+            keyword_hash(node).source_range
+          end
+
+          def autocorrect corrector, node
+            hash   = keyword_hash(node)
+            sorted = hash.pairs.to_a.sort_by { pair_key_name(it) }
+            corrector.replace(hash.source_range, replacement_for(node, hash, sorted))
+          end
+
+          def replacement_for node, hash, pairs
+            return single_line_replacement(pairs) unless multiline_call?(node, hash)
+
+            multiline_replacement(node, hash, pairs)
+          end
+
+          def single_line_replacement pairs
+            pairs.map { it.source.strip }.join(', ')
+          end
+
+          def multiline_replacement node, hash, pairs
+            return render_pairs(pairs, hanging_indent(node)) if first_arg_on_method_line?(node)
+
+            # First arg on its own line inside parens: keep each pair on its own
+            # line with the original first-pair indentation.
+            indent = ' ' * hash.pairs.first.loc.expression.column
+            pairs.map { it.source.strip }.join(",\n#{ indent }")
+          end
+
+          def multiline_call? node, hash
+            node.multiline? || hash.multiline?
+          end
+
+          # Pair order is the only intentional AST change; normalize both sides.
+          def normalize_reparsed_ast node
+            return node unless node.is_a?(::Parser::AST::Node)
+
+            children = node.children.map { normalize_reparsed_ast(it) }
+            return sorted_hash_node(node, children) if node.type == :hash
+
+            node.updated(nil, children)
+          end
+
+          def sorted_hash_node node, children
+            pairs, others = children.partition { pair_node?(it) }
+            pairs         = pairs.sort_by { pair_sort_key(it) }
+            node.updated(nil, pairs + others)
+          end
+
+          def pair_node? node
+            node.is_a?(::Parser::AST::Node) && node.type == :pair
+          end
+
+          def pair_sort_key pair
+            key = pair.children.first
+            return key.children.first.to_s if key.is_a?(::Parser::AST::Node) && key.type == :sym
+
+            key.inspect
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/yoshiki/version.rb

@@ -1,5 +1,5 @@
 module Yoshiki
 
-  VERSION = '11.0.0-7'.freeze
+  VERSION = '11.0.0-8'.freeze
 
 end

data/lib/yoshiki.rb

@@ -1,4 +1,10 @@
 require 'yoshiki/version'
+require 'rubocop'
+require 'rubocop/cop/yoshiki/keyword_only_arguments'
+require 'rubocop/cop/yoshiki/layout/hanging_keyword_arguments'
+require 'rubocop/cop/yoshiki/lint/parenthesize_value_omission'
+require 'rubocop/cop/yoshiki/style/it_block_parameter'
+require 'rubocop/cop/yoshiki/style/sorted_keyword_arguments'
 
 # Dev Fu! Style
 module Yoshiki

data/yoshiki.gemspec

@@ -11,9 +11,9 @@ Gem::Specification.new do |spec|
   spec.description   = 'Dev Fu! Style for rubocop.'
   spec.homepage      = 'https://gitlab.com/devfu/yoshiki'
   spec.license       = 'MIT'
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match %r{^(test|spec|features)/} }
+  spec.files         = `git ls-files -z`.split("\x0").reject { it.match %r{^(test|spec|features)/} }
   spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename f }
+  spec.executables   = spec.files.grep(%r{^exe/}) { File.basename it }
   spec.require_paths = %w[ lib ]
 
   spec.metadata['rubygems_mfa_required'] = 'true'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yoshiki
 version: !ruby/object:Gem::Version
-  version: 11.0.0.pre.7
+  version: 11.0.0.pre.8
 platform: ruby
 authors:
 - BM5k
@@ -69,6 +69,7 @@ files:
 - ".rubocop-defaults.yml"
 - ".rubocop.yml"
 - ".yoshiki-capybara.yml"
+- ".yoshiki-haml.yml"
 - ".yoshiki-minitest.yml"
 - ".yoshiki-rails-rspec.yml"
 - ".yoshiki-rails.yml"
@@ -82,6 +83,12 @@ files:
 - README.md
 - Rakefile
 - bin/console
+- lib/rubocop/cop/yoshiki/haml/sibling_blank_lines.rb
+- lib/rubocop/cop/yoshiki/keyword_only_arguments.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/sorted_keyword_arguments.rb
 - lib/yoshiki.rb
 - lib/yoshiki/examples.rb
 - lib/yoshiki/version.rb