rubocop-fourshark 0.11.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d37d6aedd6756dcc500a7295b9f03dd99f413d12375c29826d5ac6970e11aacc
-  data.tar.gz: 7e406a1cb9ddde1f494a3e6d1c90561c87b6bf2d19cc585d69c25c43516a39ea
+  metadata.gz: 69cc71527797fec14e62169599832f3807636964ae36c971a625002392f2eb8f
+  data.tar.gz: b48916db29a2562de541d537a5204c2a11029cff89f91b2d8bd90c932dbeabc6
 SHA512:
-  metadata.gz: ac6cbcbeaa39f99a6e548b93a7ad05c2cc204013210dbb50686252c3e0c7285d419daf306d53aedc00080d295b7c61efd016f59276e48a0519391e427e287e5c
-  data.tar.gz: 540e6ea1264bcf27eeb261546ab74bd75c165bb19488e7098dd358d303e10e162d120c3ef0ea5b3698077bb03cc3a18e59af2ae7f009f24020463ebc3956d8e2
+  metadata.gz: 74d395cab432995d01f8b5b7a86c3fbe1bb3bab3f4166452fc01c72ff18d3ef07d177bbeb4970d797a48812028c5c84e82e1623c0e860022d9baca5c530ea960
+  data.tar.gz: 3ac8c3575cbbefc7bbfd843cb6c21a651a80e15ff60a8eb89442e86e60b7f241917eface0fc2db701678647f60160ef8d3d37aff96c98cabac9b043ea1a649f3

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [Unreleased]
+
+### Added
+
+- `Layout/SingleLineStatementSpacing` coverage for RSpec cops that forbid consecutive one-liners
+
+## [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,19 +8,65 @@ 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
-      # beside a multi-line or heredoc neighbour. Autocorrects by removing it.
+      # (a guard clause, a flow-control statement, an access modifier, the end
+      # of an RSpec `let`/`subject`/hook/example 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
         ACCESS_MODIFIERS = %i[private protected public module_function].freeze
         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
 
         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) || gem_section_boundary?(first, second)
 
             blanks = removable_blank_lines(first, second)
 
@@ -64,6 +110,51 @@ 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
+
+        # `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.1'
   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.1
 platform: ruby
 authors:
 - Paulo Ribeiro