rubocop-fourshark 0.8.6 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bdc31121f34ef40cca25af1bc804caafecc8b8f58fd2996457cd01d82b98502
-  data.tar.gz: 26bbc30201fe22eef3477a20ce1eaf7016ee020a1ed93f53134429654da4a11d
+  metadata.gz: 6c6c6460f92a176876caceeea69665b587c8df4502c09ed2ac8472113a0cabbb
+  data.tar.gz: 3b5ce9b992dce38aa64163363b2495b1dc1f9a6af2373d2b23b296e3f9242169
 SHA512:
-  metadata.gz: ce23cde85c85d07932802b8bc89aa7c48f047cd274f59ff7d8c32b5e5e490e4bc46f118bb0e6216796cc774f9dc7c687bc464d33ac59361885a8bab2dd865edb
-  data.tar.gz: 616ed09b7f636b5cc4931894d86063a62b9e7357cf35802dee67f6d4a2c77ab8523131519ced29806cb6e1bd862ce8771931401411b3b1e0d59ebe6fabc5b575
+  metadata.gz: d4c6340581cd762875dbdeead991ea6d6f6ddadf420a5261345ef396ba8b1ca6bedd148d411c7b061615486cfbfb44e84983acd940f5d0ab632d99af97c2100c
+  data.tar.gz: bfc42021a9aba8b72ecdded7a31f6965bd9eb6d31408762e9d2621cfc60597df16c81ede7f9b9c6b9112f80587c7b62e3cff2d7d02c331345f2ea64934733d0e

data/.grant.yaml

@@ -0,0 +1,28 @@
+# License allow-list enforced by `grant` over the Syft SBOM (see .github/workflows/main.yml).
+# Mirrors the licenses the 4Shark Ruby projects permit. require-license/require-known-license
+# are false so a dependency with no declared license or a non-SPDX license string still passes.
+allow:
+  - MIT
+  - Apache-2.0
+  - "BSD-2-Clause"
+  - "BSD-3-Clause"
+  - "BSD"
+  - "BSD 2-Clause"
+  - ISC
+  - Ruby
+  - ruby
+  - "same as ruby's"
+  - Zlib
+  - "LGPL-2.1*"
+  - "LGPL-3.0*"
+  - MPL-2.0
+  - "Artistic-*"
+  - "Brakeman Public Use License"
+  - "GPL-2.0*"
+  - "GPL-3.0*"
+  - GPLv2
+  - WTFPL
+  - "Prosperity*"
+
+require-license: false
+require-known-license: false

data/.ruby-version

@@ -1 +1 @@
-4.0.5
+4.0.6

data/CHANGELOG.md

@@ -1,3 +1,44 @@
+## [0.10.0] - 2026-10-02
+
+### Added
+
+- License compliance verification
+
+### Changed
+
+- Gem update pull requests limited to the named gem
+- Minimum release age verification across lockfiles and manifests
+- License check fails at a failed tool install
+- `Style/DisallowDelegate` accepts a constant the object supplies to the collaborator
+
+## [0.9.0] - 2026-08-31
+
+### Added
+
+- `Layout/EmptyLineBeforeGuardClause` — a guard clause that follows ordinary code must be preceded by a blank line
+- Automated dependency-update runs
+- Minimum-age verification on pull requests, re-evaluated daily
+- `Layout/SingleLineStatementSpacing` — a blank line between two consecutive single-line statements is removed
+- `Style/OrderedConstants` — a run of consecutive constant assignments must be sorted alphabetically
+
+### Changed
+
+- Development Ruby version to 4.0.6
+
+### Fixed
+
+- Weekly transitive dependency updates
+- Transitive dependency pull request now covers every lockfile the update touched
+- Lockfile discovery no longer publishes a short set when the search itself fails
+- Transitive resolution no longer runs on a short lockfile set when the search itself fails
+- Lockfile discovery skips the bundles vendored under node_modules
+- Held-back gem list pinned to the collation that sorted it
+- Daily dependency age re-check leaving pull requests without the status they need to merge
+- Dependency age checks running with no configured minimum
+- Minimum release age applied to the weekly transitive dependency update
+- Ruby setup action pinned like every other action in the workflows
+- Minimum-age check no longer errors on the gem's own unreleased version
+
 ## [0.8.6] - 2026-08-08
 
 ### Fixed

data/README.md

@@ -80,12 +80,15 @@ Where a 4Shark cop supersedes or contradicts a stock cop, `config/default.yml` t
 | `Style/DisallowSafeNavigation` | Flags safe navigation (`&.`). 4Shark rejects it — a `&.` chain silently swallows a `nil` that usually signals a real bug. Use an explicit conditional so the `nil` case is handled on purpose. |
 | `Style/DisallowTernary` | Flags the ternary conditional (`cond ? a : b`). `?` and `:` are punctuation that already mean other things in Ruby (`valid?`, `:symbol`), and the ternary hides a branch inside an expression where skimming misses it. Use an explicit `if`/`else`. |
 | `Style/DisallowTry` | Flags `try` / `try!`. Same rationale — it hides the `nil`/missing-method case instead of handling it explicitly. |
+| `Style/OrderedConstants` | A run of consecutive constant assignments must be sorted alphabetically by name. A lone constant is never flagged, and any non-constant statement breaks the run. Flags without autocorrecting — a constant can reference one declared above it, so a human decides the order. Experimental. |
 
 ### Layout
 
 | Cop | Intent |
 |---|---|
+| `Layout/EmptyLineBeforeGuardClause` | Requires a blank line before a guard clause that follows ordinary code, so a clause that breaks the flow is findable at a glance instead of read for. Consecutive guard clauses are one block and stay glued together — only the first of a run needs the blank line, and a clause that opens a body needs none. Mirrors the stock `Layout/EmptyLineAfterGuardClause`, which sets the run off below; enable both. |
 | `Layout/MultilineStatementSpacing` | Requires a blank line between two consecutive statements when either spans multiple lines, so multi-line statements read as distinct units. |
+| `Layout/SingleLineStatementSpacing` | Forbids a blank line between two consecutive single-line statements — they are one run, so the blank reveals nothing. The complement of `Layout/MultilineStatementSpacing`; the two never fire on the same pair. Autocorrects by removing the blank. |
 
 ### Naming
 

data/Rakefile

@@ -9,9 +9,7 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
 end
 
 RuboCop::RakeTask.new
-
 task default: %i[spec rubocop]
-
 desc 'Generate a new cop with a template'
 
 task :new_cop, [:cop] do |_task, args|
@@ -23,11 +21,9 @@ task :new_cop, [:cop] do |_task, args|
   end
 
   generator = RuboCop::Cop::Generator.new(cop_name)
-
   generator.write_source
   generator.write_spec
   generator.inject_require(root_file_path: 'lib/rubocop/cop/fourshark_cops.rb')
   generator.inject_config(config_file_path: 'config/default.yml')
-
   puts generator.todo
 end

data/config/default.yml

@@ -3,11 +3,25 @@
 # so the names read like any other cop. Where a 4Shark cop supersedes or
 # contradicts a stock cop, the stock cop is disabled here (see the bottom block).
 
+# Mirrors the stock `Layout/EmptyLineAfterGuardClause` rather than replacing it:
+# that one sets the run off below, this one above, and both are wanted.
+Layout/EmptyLineBeforeGuardClause:
+  Description: 'Add a blank line before a guard clause that follows ordinary code.'
+  Enabled: true
+  VersionAdded: '0.9.0'
+
 Layout/MultilineStatementSpacing:
   Description: 'Add a blank line between consecutive statements when either spans multiple lines.'
   Enabled: true
   VersionAdded: '0.2.0'
 
+# The complement of Layout/MultilineStatementSpacing: no blank line between two
+# single-line statements. Autocorrects (removing a blank has no placement ambiguity).
+Layout/SingleLineStatementSpacing:
+  Description: 'Do not put a blank line between two consecutive single-line statements.'
+  Enabled: true
+  VersionAdded: '0.9.0'
+
 # Stock cop configured (not a 4Shark cop): enforce the `indented` style for
 # multiline method-call chains — continuation calls are indented one step from
 # the receiver instead of aligning with the first call.
@@ -42,6 +56,11 @@ Style/DisallowTry:
   Enabled: true
   VersionAdded: '0.1.0'
 
+Style/OrderedConstants:
+  Description: 'Sort a run of consecutive constant assignments alphabetically by name.'
+  Enabled: true
+  VersionAdded: '0.9.0'
+
 Rails/MandatoryInverseOf:
   Description: 'Every association must declare `inverse_of` (stricter than stock `Rails/InverseOf`).'
   Enabled: true

data/lib/rubocop/cop/factory_bot/association_in_factory.rb

@@ -23,16 +23,16 @@ module RuboCop
       #   end
       #
       class AssociationInFactory < ::RuboCop::Cop::Base
-        MSG = 'Do not declare associations in factories — set them manually in the spec.'
-
         CONTAINER_METHODS = %i[factory trait].freeze
         # FactoryBot DSL methods that are bare calls but are NOT associations.
         DSL_KEYWORDS = %i[skip_create initialize_with].freeze
+        MSG = 'Do not declare associations in factories — set them manually in the spec.'
 
         def on_block(node)
           return unless container_block?(node)
 
           body = node.body
+
           return unless body
 
           statements = if body.begin_type?

data/lib/rubocop/cop/fourshark_cops.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require_relative 'factory_bot/association_in_factory'
+require_relative 'layout/empty_line_before_guard_clause'
 require_relative 'layout/multiline_statement_spacing'
+require_relative 'layout/single_line_statement_spacing'
 require_relative 'rails/bidirectional_association'
 require_relative 'rails/mandatory_inverse_of'
 require_relative 'rails/optional_belongs_to'
@@ -14,3 +16,4 @@ require_relative 'style/disallow_delegate'
 require_relative 'style/disallow_safe_navigation'
 require_relative 'style/disallow_ternary'
 require_relative 'style/disallow_try'
+require_relative 'style/ordered_constants'

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Layout
+      # Requires a blank line before a guard clause that follows ordinary code.
+      # A guard clause breaks the flow, so it has to be findable at a glance
+      # rather than read for — the same reason a multi-line statement is set off
+      # from its neighbours.
+      #
+      # Consecutive guard clauses are one block and stay glued together: the run
+      # is what the reader scans, and blank lines inside it would break the shape
+      # instead of revealing it. Only the first clause of a run needs the blank
+      # line above, and a guard that opens a body needs none because the `def`
+      # or `do` already delimits it.
+      #
+      # What counts as a guard clause is `guard_clause?` from `rubocop-ast`,
+      # which covers `return`, `break`, `next`, `raise` and `fail`.
+      #
+      # The blank line *after* the run is the stock
+      # `Layout/EmptyLineAfterGuardClause`, which this cop mirrors rather than
+      # replaces — enable both to get a run that is set off on both sides.
+      #
+      # Detection-only (no autocorrect), matching the sibling
+      # `Layout/MultilineStatementSpacing`: where a comment sits above the
+      # clause the blank line belongs above the comment, and that placement
+      # needs validation against the real repos before it is applied for anyone.
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     bar
+      #     return if baz?
+      #
+      #     qux
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     bar
+      #
+      #     return if baz?
+      #
+      #     qux
+      #   end
+      #
+      #   # good — a run of guard clauses stays together
+      #   def foo
+      #     return if baz?
+      #     return if qux?
+      #
+      #     bar
+      #   end
+      #
+      #   # good — nothing above it to separate from
+      #   def foo
+      #     return if baz?
+      #
+      #     bar
+      #   end
+      #
+      class EmptyLineBeforeGuardClause < ::RuboCop::Cop::Base
+        MSG = 'Add a blank line before the guard clause.'
+
+        def on_begin(node)
+          node.children.each_cons(2) do |previous, current|
+            next unless guard_clause?(current)
+            next if guard_clause?(previous)
+            next if blank_line_between?(previous, current)
+
+            add_offense(current)
+          end
+        end
+
+        private
+
+        def guard_clause?(node)
+          return false unless node.is_a?(::RuboCop::AST::Node)
+          return false unless node.if_type?
+
+          branch = node.if_branch
+
+          return false if branch.nil?
+
+          branch.guard_clause?
+        end
+
+        def blank_line_between?(previous, current)
+          return false if current.first_line - previous.last_line < 2
+
+          ((previous.last_line + 1)...current.first_line).any? do |line|
+            processed_source.lines[line - 1].strip.empty?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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.
+      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.'
+
+        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)
+
+            blanks = removable_blank_lines(first, second)
+
+            next if blanks.empty?
+
+            add_offense(second) do |corrector|
+              blanks.each { |line| corrector.remove(line_range_with_newline(line)) }
+            end
+          end
+        end
+
+        private
+
+        # A statement whose surrounding blank another cop owns, or which reads as
+        # a block. Its blank is preserved: this cop only glues ordinary runs.
+        def structural?(node)
+          multiline_or_heredoc?(node) || flow_control?(node) || guard_clause?(node) || access_modifier?(node)
+        end
+
+        def multiline_or_heredoc?(node)
+          node.multiline? || node.each_node(:any_str).any?(&:heredoc?)
+        end
+
+        def flow_control?(node)
+          return true if FLOW_CONTROL_TYPES.include?(node.type)
+
+          node.send_type? && node.receiver.nil? && FLOW_CONTROL_METHODS.include?(node.method_name)
+        end
+
+        def guard_clause?(node)
+          return false unless node.if_type?
+
+          branch = node.if_branch
+
+          return false if branch.nil?
+
+          branch.guard_clause?
+        end
+
+        def access_modifier?(node)
+          node.send_type? && node.receiver.nil? && ACCESS_MODIFIERS.include?(node.method_name)
+        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.
+        def removable_blank_lines(first, second)
+          gap = (first.last_line + 1)...second.first_line
+
+          gap.select do |line|
+            blank_line?(line) && same_kind_neighbours?(line, first.last_line, second.first_line)
+          end
+        end
+
+        def same_kind_neighbours?(line, floor, ceiling)
+          above = nearest_non_blank(line - 1, floor, -1)
+          below = nearest_non_blank(line + 1, ceiling, 1)
+          line_kind(above) == line_kind(below)
+        end
+
+        def nearest_non_blank(start_line, boundary, step)
+          line = start_line
+          line += step while line != boundary && blank_line?(line)
+          line
+        end
+
+        def line_kind(line)
+          return :comment if processed_source.lines[line - 1].strip.start_with?('#')
+
+          :code
+        end
+
+        def blank_line?(line)
+          processed_source.lines[line - 1].strip.empty?
+        end
+
+        def line_range_with_newline(line)
+          line_range = processed_source.buffer.line_range(line)
+          line_range.resize(line_range.length + 1)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/bidirectional_association.rb

@@ -43,6 +43,7 @@ module RuboCop
             next if model_name.nil? || target_class.nil?
 
             opposite_model_path = File.join(Dir.pwd, "app/models/#{camel_to_snake(target_class)}.rb")
+
             next unless File.exist?(opposite_model_path)
 
             opposite_content = File.read(opposite_model_path)
@@ -81,7 +82,6 @@ module RuboCop
             assoc_name = literal_value(node.first_argument)
             inverse_name = extract_inverse_of(node)
             target_class = extract_class_name(node, assoc_name)
-
             [model_name, assoc_name, inverse_name, target_class]
           end
         end
@@ -107,6 +107,7 @@ module RuboCop
         # plain symbol (string keys, double-splats) are skipped rather than read.
         def option_pair(node, key)
           kwargs = node.last_argument
+
           return nil unless kwargs.respond_to?(:hash_type?) && kwargs.hash_type?
 
           kwargs.pairs.find { |pair| pair.key.sym_type? && pair.key.value == key }
@@ -125,6 +126,7 @@ module RuboCop
 
         def class_name_from_ast
           class_node = processed_source.ast.each_descendant(:class).first
+
           return nil unless class_node
 
           const_node = class_node.children.first

data/lib/rubocop/cop/rails/optional_belongs_to.rb

@@ -38,6 +38,7 @@ module RuboCop
 
         def optional_true?(node)
           kwargs = node.last_argument
+
           return false if !kwargs || !kwargs.hash_type?
 
           kwargs.pairs.any? { |pair| pair.key.value == :optional && pair.value.true_type? }

data/lib/rubocop/cop/rails/ordered_macros.rb

@@ -27,9 +27,8 @@ module RuboCop
       #   validates :name
       #
       class OrderedMacros < ::RuboCop::Cop::Base
-        MSG = 'Sort `%<macro>s` declarations alphabetically (`%<name>s` should come before `%<previous>s`).'
-
         MACROS = %i[belongs_to has_one has_many has_and_belongs_to_many validates scope].freeze
+        MSG = 'Sort `%<macro>s` declarations alphabetically (`%<name>s` should come before `%<previous>s`).'
 
         def self.default_configuration
           super.merge('Include' => ['app/models/**/*.rb'])
@@ -37,6 +36,7 @@ module RuboCop
 
         def on_class(node)
           body = node.body
+
           return unless body
 
           statements = if body.begin_type?
@@ -68,6 +68,7 @@ module RuboCop
           calls.each_cons(2) do |previous, current|
             previous_name = macro_name(previous)
             current_name = macro_name(current)
+
             next if current_name >= previous_name
 
             add_offense(

data/lib/rubocop/cop/rspec/conditional_in_let.rb

@@ -25,14 +25,14 @@ module RuboCop
       #   end
       #
       class ConditionalInLet < ::RuboCop::Cop::Base
-        MSG = 'Do not put conditional logic in a `let` — use separate contexts.'
-
         LET_METHODS = %i[let let!].freeze
+        MSG = 'Do not put conditional logic in a `let` — use separate contexts.'
 
         def on_block(node)
           return unless let_block?(node)
 
           body = node.body
+
           return unless body
 
           body.each_node(:if, :case) do |conditional|

data/lib/rubocop/cop/rspec/factory_bot_in_before.rb

@@ -17,9 +17,8 @@ module RuboCop
       #   let(:user) { create(:user) }
       #
       class FactoryBotInBefore < ::RuboCop::Cop::Base
-        MSG = 'Do not create objects in `before` — use `let` for object creation.'
-
         CREATION_METHODS = %i[create build create_list build_list].freeze
+        MSG = 'Do not create objects in `before` — use `let` for object creation.'
 
         def on_block(node)
           return unless before_block?(node)

data/lib/rubocop/cop/rspec/inverse_of_matcher.rb

@@ -20,8 +20,8 @@ module RuboCop
       # model class (a linter runs without the Rails app booted).
       #
       class InverseOfMatcher < ::RuboCop::Cop::Base
-        MSG_MISSING_INVERSE   = 'Root models must include `.inverse_of` in association specs.'
         MSG_FORBIDDEN_INVERSE = 'Subclasses must NOT include `.inverse_of` in specs (it belongs to the parent).'
+        MSG_MISSING_INVERSE   = 'Root models must include `.inverse_of` in association specs.'
 
         def self.default_configuration
           super.merge(
@@ -33,12 +33,15 @@ module RuboCop
           return unless node.method?(:belong_to)
 
           model_name = model_class_from_spec
+
           return unless model_name
 
           association_name = association_name_from(node)
+
           return if association_name && polymorphic_in_model?(model_name, association_name)
 
           classification = classify_model(model_name)
+
           return if classification == :non_ar
 
           if classification == :root
@@ -66,6 +69,7 @@ module RuboCop
         # The association name passed to the matcher, e.g. belong_to(:user) -> :user
         def association_name_from(node)
           argument = node.first_argument
+
           return nil unless argument && argument.sym_type?
 
           argument.value
@@ -76,6 +80,7 @@ module RuboCop
         # and the declaration lives in the model, not in the spec matcher chain.
         def polymorphic_in_model?(model_name, association_name)
           content = model_source(model_name)
+
           return false unless content
 
           content.match?(/belongs_to\s+:#{Regexp.escape(association_name.to_s)}\b[^\n]*polymorphic:\s*true/)
@@ -84,12 +89,15 @@ module RuboCop
         # Convert spec file path into model class name
         def model_class_from_spec
           path = processed_source.file_path if processed_source && processed_source.buffer
+
           return nil unless path
 
           match = path.match(%r{spec/models/(.+)_spec\.rb})
+
           return nil unless match
 
           relative = match[1]
+
           return nil if relative.empty?
 
           relative.split('/').map { |part| part.split('_').map(&:capitalize).join }.join('::')
@@ -99,9 +107,11 @@ module RuboCop
         # model file statically (no class loading).
         def classify_model(model_name)
           content = model_source(model_name)
+
           return :non_ar unless content
 
           superclass = superclass_of(content, model_name)
+
           return :non_ar unless superclass
           return :root if superclass == 'ApplicationRecord'
           return :subclass if model_source(superclass)
@@ -113,6 +123,7 @@ module RuboCop
 
         def model_source(model_name)
           path = File.join(Dir.pwd, 'app/models', "#{camel_to_snake(model_name)}.rb")
+
           return File.read(path) if File.exist?(path)
 
           nil

data/lib/rubocop/cop/rspec/overwritten_let.rb

@@ -32,18 +32,19 @@ module RuboCop
       #   end
       #
       class OverwrittenLet < ::RuboCop::Cop::Base
-        MSG = 'Do not override the outer `let` `%<name>s`; use a distinct name or set the value in `before`.'
-
-        LET_METHODS = %i[let let!].freeze
         EXAMPLE_GROUP_METHODS = %i[describe context].freeze
+        LET_METHODS = %i[let let!].freeze
+        MSG = 'Do not override the outer `let` `%<name>s`; use a distinct name or set the value in `before`.'
 
         def on_send(node)
           return unless LET_METHODS.include?(node.method_name) && node.receiver.nil?
 
           name = let_name(node)
+
           return unless name
 
           immediate_group = node.each_ancestor(:block).find { |block| example_group?(block) }
+
           return unless immediate_group
           return unless outer_groups(immediate_group).any? { |group| defines_let?(group, name) }
 
@@ -63,6 +64,7 @@ module RuboCop
 
         def defines_let?(group, name)
           body = group.body
+
           return false unless body
 
           statements = if body.begin_type?
@@ -92,6 +94,7 @@ module RuboCop
 
         def let_name(node)
           first = node.first_argument
+
           return first.value if first && first.sym_type?
 
           nil

data/lib/rubocop/cop/style/disallow_delegate.rb

@@ -44,10 +44,10 @@ module RuboCop
       # contributes something the caller would otherwise have to reach in and
       # take, and the result is a simpler API on the object that owns the data.
       #
-      # Own state is an instance variable, `self`, or a receiverless call,
-      # reached directly, through a wrapper, or through a call on it — `record`,
-      # `record.owner_id` and `[record.owner_id]` all carry the object's own
-      # data. A method PARAMETER does not: it arrives as an `lvar`, so a setter
+      # Own state is an instance variable, `self`, a receiverless call, or a
+      # constant, reached directly, through a wrapper, or through a call on it —
+      # `record.owner_id` and `Settings.keep_alive` both carry data the object
+      # chose to supply. A method PARAMETER does not: it arrives as an `lvar`, so a setter
       # handing its argument to a collaborator stays flagged.
       #
       # Two limits keep the exemption from swallowing the rule.
@@ -120,15 +120,13 @@ module RuboCop
       #   end
       #
       class DisallowDelegate < ::RuboCop::Cop::Base
-        MACRO_MSG = 'Do not use automatic delegation. Delete the forwarder and let the caller navigate.'
-        FORWARDER_MSG = 'Do not forward a collaborator\'s message. Delete the forwarder and let the caller navigate.'
-
-        RESTRICT_ON_SEND = %i[delegate delegate_missing_to def_delegator def_delegators DelegateClass].freeze
-
         # An argument reaches the body wrapped in one of these when the call site
         # spreads or blocks it, and the wrapper says nothing about whose state it
         # carries.
         ARGUMENT_WRAPPERS = %i[hash pair array splat kwsplat block_pass].freeze
+        FORWARDER_MSG = 'Do not forward a collaborator\'s message. Delete the forwarder and let the caller navigate.'
+        MACRO_MSG = 'Do not use automatic delegation. Delete the forwarder and let the caller navigate.'
+        RESTRICT_ON_SEND = %i[delegate delegate_missing_to def_delegator def_delegators DelegateClass].freeze
 
         # @!method mixes_in_enumerable?(node)
         def_node_matcher :mixes_in_enumerable?, <<~PATTERN
@@ -170,6 +168,7 @@ module RuboCop
         # same thing and both are read as one.
         def own_class_target?(node)
           target = to_option(node) || leading_target(node)
+
           return false if target.nil?
           return false unless target.type?(:sym, :str)
 
@@ -199,6 +198,7 @@ module RuboCop
           return false unless node.method?(:each)
 
           enclosing = node.each_ancestor(:class, :module, :sclass).first
+
           return false if enclosing.nil?
           return false if enclosing.sclass_type?
 
@@ -224,8 +224,8 @@ module RuboCop
         end
 
         # A method parameter reaches the body as an `lvar`, so only an instance
-        # variable, `self`, or a receiverless call counts as the object's own
-        # state — read directly, through a wrapper, or through a call on it.
+        # variable, `self`, a receiverless call, or a constant counts as the
+        # object's own state — read directly, through a wrapper, or through a call on it.
         # Anything rooted at the collaborator is that collaborator's own data
         # coming back, which is the echo the rule forbids. The first guard
         # refuses anything that is not a node, which covers both the nil child
@@ -236,6 +236,7 @@ module RuboCop
           return false if argument == collaborator
           return true if argument.ivar_type?
           return true if argument.self_type?
+          return true if argument.const_type?
           return own_state?(argument.receiver, collaborator) if call_with_receiver?(argument)
           return true if argument.send_type?
           return argument.children.any? { |child| own_state?(child, collaborator) } if wrapper?(argument)

data/lib/rubocop/cop/style/disallow_try.rb

@@ -7,7 +7,6 @@ module RuboCop
     module Style
       class DisallowTry < ::RuboCop::Cop::Base
         MSG = 'Do not use `try` or `try!`. Use explicit conditionals instead.'
-
         RESTRICT_ON_SEND = %i[try try!].freeze
 
         def on_send(node)

data/lib/rubocop/cop/style/ordered_constants.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Style
+      # Requires a run of consecutive constant assignments to be sorted
+      # alphabetically by name. A lone constant is never flagged; a run is
+      # broken by any non-constant statement. Flags without autocorrecting — a
+      # constant may reference one declared above it, so a human decides the
+      # order. Experimental: if it flags more than it helps, drop it.
+      class OrderedConstants < ::RuboCop::Cop::Base
+        MSG = 'Sort constant assignments alphabetically (`%<name>s` should come before `%<previous>s`).'
+
+        def on_begin(node)
+          node.children.chunk { |child| constant_assignment?(child) }.each do |constants, run|
+            flag_unsorted(run) if constants
+          end
+        end
+
+        private
+
+        def flag_unsorted(run)
+          run.each_cons(2) do |previous, current|
+            previous_name = constant_name(previous)
+            current_name = constant_name(current)
+
+            next if current_name >= previous_name
+
+            add_offense(current.loc.name, message: format(MSG, name: current_name, previous: previous_name))
+          end
+        end
+
+        def constant_assignment?(node)
+          node.is_a?(::RuboCop::AST::Node) && node.casgn_type?
+        end
+
+        def constant_name(node)
+          node.name.to_s
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/fourshark/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Fourshark
-    VERSION = '0.8.6'
+    VERSION = '0.10.0'
   end
 end

data/lib/rubocop-fourshark.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 require 'rubocop'
-
 require_relative 'rubocop/fourshark'
 require_relative 'rubocop/fourshark/version'
 require_relative 'rubocop/fourshark/plugin'
-
 require_relative 'rubocop/cop/fourshark_cops'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-fourshark
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.10.0
 platform: ruby
 authors:
 - Paulo Ribeiro
@@ -127,6 +127,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".grant.yaml"
 - ".ruby-gemset"
 - ".ruby-version"
 - CHANGELOG.md
@@ -138,7 +139,9 @@ files:
 - lib/rubocop-fourshark.rb
 - lib/rubocop/cop/factory_bot/association_in_factory.rb
 - lib/rubocop/cop/fourshark_cops.rb
+- lib/rubocop/cop/layout/empty_line_before_guard_clause.rb
 - lib/rubocop/cop/layout/multiline_statement_spacing.rb
+- lib/rubocop/cop/layout/single_line_statement_spacing.rb
 - lib/rubocop/cop/rails/bidirectional_association.rb
 - lib/rubocop/cop/rails/mandatory_inverse_of.rb
 - lib/rubocop/cop/rails/optional_belongs_to.rb
@@ -151,6 +154,7 @@ files:
 - lib/rubocop/cop/style/disallow_safe_navigation.rb
 - lib/rubocop/cop/style/disallow_ternary.rb
 - lib/rubocop/cop/style/disallow_try.rb
+- lib/rubocop/cop/style/ordered_constants.rb
 - lib/rubocop/fourshark.rb
 - lib/rubocop/fourshark/plugin.rb
 - lib/rubocop/fourshark/version.rb
@@ -177,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: RuboCop extension enforcing 4Shark's Ruby, Rails, and RSpec conventions.
 test_files: []