rubocop-fourshark 0.11.0 → 0.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d37d6aedd6756dcc500a7295b9f03dd99f413d12375c29826d5ac6970e11aacc
-  data.tar.gz: 7e406a1cb9ddde1f494a3e6d1c90561c87b6bf2d19cc585d69c25c43516a39ea
+  metadata.gz: ff1f92dab1c4c499529e7729afcfe28e449879582f476e2a911952ec3140f8df
+  data.tar.gz: 17f2ab8e91dd9392f74bc0cf333dcf58b54b847e67bd05224ad4394857b583b8
 SHA512:
-  metadata.gz: ac6cbcbeaa39f99a6e548b93a7ad05c2cc204013210dbb50686252c3e0c7285d419daf306d53aedc00080d295b7c61efd016f59276e48a0519391e427e287e5c
-  data.tar.gz: 540e6ea1264bcf27eeb261546ab74bd75c165bb19488e7098dd358d303e10e162d120c3ef0ea5b3698077bb03cc3a18e59af2ae7f009f24020463ebc3956d8e2
+  metadata.gz: ad46dc84d1c4930addcb691f17b405685d684eaaa2fe12eb45353ce366ad352e9bc2c79ed65bc9e5b8da4c94579bebcaba65e1170ac809df467dde62d69c8196
+  data.tar.gz: f7a40f52df08988e967789e44bd7d74271a9074e14819bfc3e3c315afb7b07a6c0fdc9bba256a021b579c480158956aec9ef5066ba05c5210463d0c53fd1695d

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [0.11.2] - 2026-10-07
+
+### Added
+
+- `Layout/SingleLineStatementSpacing` coverage for RSpec cops that forbid consecutive one-liners
+
+### Fixed
+
+- `Layout/SingleLineStatementSpacing` — the blank line after a module inclusion or attribute accessor run is no longer removed
+
+## [0.11.1] - 2026-10-07
+
+### Fixed
+
+- `Layout/SingleLineStatementSpacing` — the blank line after a `let`, `subject`, hook or example run is no longer removed
+- `Layout/SingleLineStatementSpacing` — the blank line between two gem sections is no longer removed
+- `Layout/SingleLineStatementSpacing` — the blank line after a hook or example written with a numbered or `it` block parameter is no longer removed
+- `Layout/SingleLineStatementSpacing` — the blank line between two subjects or after a one-line example group is no longer removed
+- `Layout/SingleLineStatementSpacing` — consecutive one-line hooks and examples are joined only while their RSpec cop allows it
+
 ## [0.11.0] - 2026-10-07
 
 ### Changed

data/lib/rubocop/cop/layout/single_line_statement_spacing.rb

@@ -8,7 +8,9 @@ module RuboCop
       # Forbids a blank line between two consecutive single-line statements —
       # they are one run, so the blank reveals nothing. A blank that separates
       # code from an adjacent comment is kept, as is one owned by another cop
-      # (a guard clause, a flow-control statement, an access modifier) or one
+      # (a guard clause, a flow-control statement, an access modifier, the end
+      # of an RSpec `let`/`subject`/hook/example run, the end of a module
+      # inclusion or attribute accessor run, a Bundler gem section) or one
       # beside a multi-line or heredoc neighbour. Autocorrects by removing it.
       class SingleLineStatementSpacing < ::RuboCop::Cop::Base
         extend ::RuboCop::Cop::AutoCorrector
@@ -16,11 +18,67 @@ module RuboCop
         FLOW_CONTROL_METHODS = %i[raise fail throw].freeze
         FLOW_CONTROL_TYPES = %i[return next break redo retry].freeze
         MSG = 'Remove the blank line between consecutive single-line statements.'
+        ONE_LINER_RUN_COPS = { example: 'RSpec/EmptyLineAfterExample', hook: 'RSpec/EmptyLineAfterHook' }.freeze
+
+        RSPEC_KINDS = {
+          after: :hook,
+          append_after: :hook,
+          append_before: :hook,
+          around: :hook,
+          before: :hook,
+          context: :example_group,
+          describe: :example_group,
+          example: :example,
+          example_group: :example_group,
+          fcontext: :example_group,
+          fdescribe: :example_group,
+          feature: :example_group,
+          fexample: :example,
+          ffeature: :example_group,
+          fit: :example,
+          focus: :example,
+          fscenario: :example,
+          fspecify: :example,
+          it: :example,
+          its: :example,
+          let: :let,
+          let!: :let,
+          pending: :example,
+          prepend_after: :hook,
+          prepend_before: :hook,
+          scenario: :example,
+          shared_context: :example_group,
+          shared_examples: :example_group,
+          shared_examples_for: :example_group,
+          skip: :example,
+          specify: :example,
+          subject: :subject,
+          subject!: :subject,
+          xcontext: :example_group,
+          xdescribe: :example_group,
+          xexample: :example,
+          xfeature: :example_group,
+          xit: :example,
+          xscenario: :example,
+          xspecify: :example
+        }.freeze
+
+        STATEMENT_RUN_KINDS = {
+          attr: :attribute_accessor,
+          attr_accessor: :attribute_accessor,
+          attr_reader: :attribute_accessor,
+          attr_writer: :attribute_accessor,
+          extend: :module_inclusion,
+          include: :module_inclusion,
+          prepend: :module_inclusion
+        }.freeze
 
         def on_begin(node)
           node.children.each_cons(2) do |first, second|
             next unless first.is_a?(::RuboCop::AST::Node) && second.is_a?(::RuboCop::AST::Node)
             next if structural?(first) || structural?(second)
+            next if rspec_run_ends?(first, second) || statement_run_ends?(first, second)
+            next if gem_section_boundary?(first, second)
 
             blanks = removable_blank_lines(first, second)
 
@@ -64,6 +122,67 @@ module RuboCop
           node.send_type? && node.receiver.nil? && ACCESS_MODIFIERS.include?(node.method_name)
         end
 
+        # The `RSpec/EmptyLineAfter*` cops demand a blank after the last `let`,
+        # `subject`, hook, example or example group of a run; removing it makes the two cops fight.
+        def rspec_run_ends?(first, second)
+          kind = rspec_kind(first)
+
+          return false if kind.nil?
+          return true if kind != rspec_kind(second)
+
+          !one_liner_run_allowed?(kind)
+        end
+
+        # Only `let`s always run together; hooks and examples do while their cop keeps
+        # `AllowConsecutiveOneLiners`, and subjects and example groups never do.
+        def one_liner_run_allowed?(kind)
+          return true if kind == :let
+
+          cop_name = ONE_LINER_RUN_COPS[kind]
+
+          return false if cop_name.nil?
+
+          config.for_cop(cop_name).fetch('AllowConsecutiveOneLiners', true)
+        end
+
+        def rspec_kind(node)
+          call =
+            if node.any_block_type?
+              node.send_node
+            else
+              node
+            end
+
+          return nil if !call.send_type? || call.receiver
+
+          RSPEC_KINDS[call.method_name]
+        end
+
+        # `Layout/EmptyLinesAfterModuleInclusion` and `Layout/EmptyLinesAroundAttributeAccessor`
+        # demand a blank after the last `include`/`extend`/`prepend` or `attr_*` of a run.
+        def statement_run_ends?(first, second)
+          kind = statement_run_kind(first)
+
+          return false if kind.nil?
+
+          kind != statement_run_kind(second)
+        end
+
+        def statement_run_kind(node)
+          return nil if !node.send_type? || node.receiver
+
+          STATEMENT_RUN_KINDS[node.method_name]
+        end
+
+        # `Bundler/OrderedGems` reads a blank between two `gem` lines as a section break.
+        def gem_section_boundary?(first, second)
+          gem_declaration?(first) && gem_declaration?(second)
+        end
+
+        def gem_declaration?(node)
+          node.send_type? && node.receiver.nil? && node.method?(:gem)
+        end
+
         # A blank whose nearest non-blank line on each side is the same kind
         # (code-to-code or comment-to-comment). A blank on a code/comment border
         # separates the two deliberately and is left alone.

data/lib/rubocop/fourshark/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Fourshark
-    VERSION = '0.11.0'
+    VERSION = '0.11.2'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-fourshark
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.2
 platform: ruby
 authors:
 - Paulo Ribeiro