rubocop-rubomatic 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b38508a5a6a0a201969e34ab81bfcd8aba925a8c3d657400bba7e31a40c36c4
-  data.tar.gz: fe005603fa46c66d9c86963820a9c9a4eb8c835ba928240ebbe39e86095a3847
+  metadata.gz: c3b05a9731b1dfb618eb19eb33b00d4b5d63104cd18a3d5e7e71b2f822087c7e
+  data.tar.gz: eaca1d9e94d174c4ddac433aa6997f7b36e96b4750a44daca7bbeead97d735fb
 SHA512:
-  metadata.gz: ed2af4ecdf6f3ce9a05ea9d95aa34aa1d4b29739fcb5e6dba413e7ec465e03b47619a78e33e06435039b46bb252acdf4bef3baa79c2a3ac397293a0db417acb7
-  data.tar.gz: e7b2ecd1aba276241814f8ff4b4bf77998362557fe53a0dbeef31df742729786572b3bb681314e0a797d784bb24dc116a51112e007eef72d35fd7ebcd3245530
+  metadata.gz: 219090ec2a3b3e880a8e6a5f25606fee0f2b725d61b2ba7d7c2e1ef6825c9562937d6692d2ac54d8431989407959e9d4d43e474094e91548c52a491104616d24
+  data.tar.gz: a1bf2e76d8bb68907b837d72bd728dcbc4f7d972440c6957f22c48dafd48711f4ac2a2e62528422e8bbacc673421a976c001ff4b80cf2b954a4c8006318cd1aa

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Unreleased changes
 
+## 2.2.0
+
+### RSpec
+
+* Added `Rubomatic/RSpec/DescribeBlockLength`
+
+### Style
+
+* Added `Rubomatic/Style/NoEmptyJoin`
+* Added `Rubomatic/Style/NoEmptySplit`
+
 ## 2.1.1
 
 ### MISC

data/README.md

@@ -75,6 +75,7 @@ Rubomatic/Style/DisallowedMethods:
 ## Departments
 
 * [`Layout`](./docs/cops/layout/README.md)
+* [`RSpec`](./docs/cops/rspec/README.md)
 * [`Style`](./docs/cops/style/README.md)
 
 ## Contributing

data/config/default.yml

@@ -3,5 +3,40 @@ Rubomatic/Layout/MultilineArrayLineBreaks:
   AllowMultilineFinalElement: true
   AllowPercentArray: true
 
+Rubomatic/RSpec/DescribeBlockLength:
+  Description: 'Limit nested `describe` block length so long ones get extracted into their own spec file.'
+  Enabled: pending
+  VersionAdded: '<<next>>'
+  CountComments: false  # count full line comments?
+  Max: 300
+  CountAsOne:
+    - 'array'
+    - 'heredoc'
+    - 'hash'
+  Include:
+    - 'spec/**/*.rb'
+
 Rubomatic/Style/DisallowedMethods:
   Enabled: true
+
+Rubomatic/Style/NoEmptyJoin:
+  Description: 'Require a separator argument for `Array#join`.'
+  Enabled: pending
+  Safe: false
+  SafeAutoCorrect: false
+  VersionAdded: '<<next>>'
+
+Rubomatic/Style/NoEmptySplit:
+  Description: 'Require a separator argument for `String#split`.'
+  Enabled: pending
+  Safe: false
+  SafeAutoCorrect: false
+  VersionAdded: '<<next>>'
+
+Rubomatic/Style/RequireBracesAroundHash:
+  Description: 'Require `{}` around a hash passed to a method that takes an options hash instead of keywords.'
+  Enabled: pending
+  SafeAutoCorrect: false
+  VersionAdded: '<<next>>'
+  Exclude:
+    - '**/db/**/*.rb'

data/config/rubomatic/rspec.yml

@@ -0,0 +1,10 @@
+Rubomatic/RSpec/DescribeBlockLength:
+  Enabled: true
+  CountComments: false
+  Max: 300
+  CountAsOne:
+    - 'array'
+    - 'heredoc'
+    - 'hash'
+  Include:
+    - 'spec/**/*.rb'

data/config/rubomatic/rubocop.yml

@@ -2,4 +2,5 @@ plugins: rubocop-rubomatic
 
 inherit_from:
   - ./layout.yml
+  - ./rspec.yml
   - ./style.yml

data/config/rubomatic/style.yml

@@ -1,2 +1,13 @@
 Rubomatic/Style/DisallowedMethods:
   Enabled: true
+
+Rubomatic/Style/NoEmptyJoin:
+  Enabled: true
+
+Rubomatic/Style/NoEmptySplit:
+  Enabled: true
+
+Rubomatic/Style/RequireBracesAroundHash:
+  Enabled: true
+  Exclude:
+    - '**/db/**/*.rb'

data/docs/cops/rspec/README.md

@@ -0,0 +1,7 @@
+# RSpec
+
+RSpec cops check for stylistic consistency of your specs
+
+## Cops
+
+* [`RSpec/DescribeBlockLength`](./describe_block_length/README.md)

data/docs/cops/rspec/describe_block_length/README.md

@@ -0,0 +1,39 @@
+# `RSpec/DescribeBlockLength`
+
+## Description
+
+Checks if a nested `describe` block is longer than `Max` lines. A long nested `describe` should be extracted into its
+own spec file. Top-level `describe` blocks are not checked; `Metrics/BlockLength` covers those. Blocks inside
+`shared_examples`, `shared_examples_for`, and `shared_context` are skipped.
+
+Subclass of `Metrics/BlockLength`, so `CountComments` and `CountAsOne` work the same way.
+
+## Examples
+
+```ruby
+# Bad
+# issue_spec.rb
+RSpec.describe(PMS::Issue) do
+  describe('.create!') do
+    # 350 lines of tests
+  end
+end
+
+# Good
+# issue/create_spec.rb
+RSpec.describe(PMS::Issue, '.create!') do
+  # 350 lines of tests
+end
+```
+
+## Configurable Attributes
+
+| Name          | Default value                  | Configurable values |
+| ------------- | ------------------------------ | ------------------- |
+| Max           | 300                            | Integer             |
+| CountComments | false                          | Boolean             |
+| CountAsOne    | `['array', 'heredoc', 'hash']` | Array               |
+
+## References
+
+https://github.com/BrandsInsurance/expert-chainsaw/issues/1741

data/docs/cops/style/README.md

@@ -5,3 +5,6 @@ Style cops check for stylistic consistency of your code
 ## Cops
 
 * [`Style/DisallowedMethods`](./disallowed_methods/README.md)
+* [`Style/NoEmptyJoin`](./no_empty_join/README.md)
+* [`Style/NoEmptySplit`](./no_empty_split/README.md)
+* [`Style/RequireBracesAroundHash`](./require_braces_around_hash/README.md)

data/docs/cops/style/no_empty_join/README.md

@@ -0,0 +1,30 @@
+# `Style/NoEmptyJoin`
+
+## Description
+
+`Array#join` should always be passed a separator. Without one, Ruby falls back to `$,`, and only uses `''` when `$,` is
+also `nil`. Passing the separator explicitly makes the intent clear and doesn't depend on global state.
+
+Autocorrection (`join` -> `join('')`) is unsafe because the receiver may not be an `Array` (e.g. `Thread#join`).
+
+## Examples
+
+```ruby
+# Bad
+[1, 2, 3].join
+[1, 2, 3].join()
+the_var&.join
+
+# Good
+[1, 2, 3].join('')
+[1, 2, 3].join(', ')
+the_var&.join(' ')
+```
+
+## Configurable Attributes
+
+There are no configurable attributes
+
+## References
+
+* https://github.com/BrandsInsurance/expert-chainsaw/issues/214

data/docs/cops/style/no_empty_split/README.md

@@ -0,0 +1,31 @@
+# `Style/NoEmptySplit`
+
+## Description
+
+`String#split` should always be passed a separator. Without one, Ruby falls back to `$;`, which is normally `nil`
+(split on whitespace) but can be overridden, and this behavior has changed between Ruby versions. Passing the separator
+explicitly makes the intent clear and doesn't depend on global state.
+
+Autocorrection (`split` -> `split(' ')`) is unsafe because the receiver may not be a `String`.
+
+## Examples
+
+```ruby
+# Bad
+'the string'.split
+'the string'.split()
+the_var&.split
+
+# Good
+'the string'.split(' ')
+'a,b,c'.split(',')
+the_var&.split(' ')
+```
+
+## Configurable Attributes
+
+There are no configurable attributes
+
+## References
+
+* https://github.com/BrandsInsurance/expert-chainsaw/issues/213

data/docs/cops/style/require_braces_around_hash/README.md

@@ -0,0 +1,61 @@
+# `Style/RequireBracesAroundHash`
+
+## Description
+
+Requires `{}` around a hash argument when the called method takes it as a positional options hash instead of keyword
+arguments. The braces tell the caller it's an options hash and not keywords.
+
+The method is looked up in the project index, so the cop does nothing unless `AllCops/UseProjectIndex` is enabled. A
+call is only flagged when the method is found and none of its definitions accept keywords (`a:`, `a: 1`, `**kwargs`, or
+`...`). Calls whose method can't be found (unknown methods, unresolved constants, locals, and chained receivers) are not
+flagged.
+
+The method is looked up on:
+
+* a constant receiver's class methods (`Service.call`), or its `initialize` for `new`
+* the enclosing class for bare and `self.` calls, on the class side inside the class body, `def self.`, and
+  `class << self`, and on the instance side inside instance methods
+* `Object` for bare calls outside a class
+
+Autocorrection is unsafe because wrapping the hash changes behavior for `ruby2_keywords` delegators, which pass a
+braceless hash on as keywords but a braced hash as a positional argument.
+
+## Examples
+
+```ruby
+def foo(options = { a: 0 }); end
+def bar(a: 0); end
+
+class Service
+  def self.call(options = {}); end
+
+  def initialize(options = {}); end
+end
+
+# Bad
+foo(a: 1)
+foo a: 1
+foo(**options)
+Service.call(a: 1)
+Service.new(a: 1)
+
+# Good
+foo({ a: 1 })
+foo({ **options })
+Service.call({ a: 1 })
+Service.new({ a: 1 })
+
+# Good - `bar` takes keywords
+bar(a: 1)
+bar(**options)
+```
+
+## Configurable Attributes
+
+There are no configurable attributes
+
+Requires `AllCops/UseProjectIndex: true` and the `rubydex` gem (Ruby 3.2+)
+
+## References
+
+* https://github.com/BrandsInsurance/expert-chainsaw/issues/150

data/lib/rubocop/cop/rubomatic/rspec/describe_block_length.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rubomatic::RSpec
+      # Checks if a nested `describe` block is longer than `Max` lines. A long nested `describe` should be extracted
+      # into its own spec file. Top-level `describe` blocks are not checked; `Metrics/BlockLength` covers those.
+      # Blocks inside `shared_examples`, `shared_examples_for`, and `shared_context` are skipped.
+      # Configured the same way as `Metrics/BlockLength`.
+      #
+      # @example Max: 300 (default)
+      #   # bad - issue_spec.rb
+      #   RSpec.describe(PMS::Issue) do
+      #     describe('.create!') do
+      #       # 350 lines of tests
+      #     end
+      #   end
+      #
+      #   # good - issue/create_spec.rb
+      #   RSpec.describe(PMS::Issue, '.create!') do
+      #     # 350 lines of tests
+      #   end
+      #
+      class DescribeBlockLength < RuboCop::Cop::Metrics::BlockLength
+        LABEL = 'Nested `describe` block'
+        EXAMPLE_GROUPS = %i[describe context feature].to_set.freeze
+        SHARED_GROUPS = %i[shared_examples shared_examples_for shared_context].to_set.freeze
+
+        # @!method describe?(node)
+        def_node_matcher :describe?, <<~PATTERN
+          (any_block (send {nil? (const {nil? cbase} :RSpec)} :describe ...) ...)
+        PATTERN
+
+        # @see super
+        def on_block(node)
+          return unless describe?(node)
+          return unless nested?(node)
+
+          super
+        end
+        # Re-aliased so they hit this `on_block`, not the parent's
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        # Public because `Lint/UnusedPrivateMethod` can't see that the parent calls it
+        #
+        # @see super
+        #
+        def cop_label
+          LABEL
+        end
+
+        private
+
+          # Shared groups are skipped; they belong in their own file instead
+          #
+          # @return [Boolean] is the block inside another example group and not a shared group
+          #
+          def nested?(node)
+            ancestors = node.each_ancestor(:any_block).map(&:method_name)
+            return false if ancestors.any? { |name| SHARED_GROUPS.include?(name) }
+
+            ancestors.any? { |name| EXAMPLE_GROUPS.include?(name) }
+          end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rubomatic/style/no_empty_join.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rubomatic::Style
+      # @safety
+      #   This cop is unsafe because the receiver may not be an `Array`
+      #   (e.g. `Thread#join`), so offenses may be false positives and adding a
+      #   separator changes behavior.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].join
+      #
+      #   # good
+      #   [1, 2, 3].join('args')
+      #
+      class NoEmptyJoin < Base
+        MSG = 'Pass an argument `Array#join` instead of no arguments.'
+
+        # `on_send` will only be called if the method name is in this list
+        RESTRICT_ON_SEND = %i[join].freeze
+
+        extend AutoCorrector
+
+        # @!method argless_join?(node)
+        def_node_matcher :argless_join?, <<~PATTERN
+          (call !nil? :join)
+        PATTERN
+
+        # Called on every `send` node (method call) while walking the AST.
+        # TODO: remove this method if inspecting `send` nodes is unneeded for your cop.
+        # By default, this is aliased to `on_csend` as well to handle method calls
+        # with safe navigation, remove the alias if this is unnecessary.
+        # If kept, ensure your tests cover safe navigation as well!
+        def on_send(node)
+          return unless argless_join?(node)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node.loc.selector.join(node.source_range.end), "join('')")
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rubomatic/style/no_empty_split.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rubomatic::Style
+      # @safety
+      #   This cop is unsafe because the receiver may not be a `String`
+      #   (e.g. `Banana#split`), so offenses may be false positives and adding a
+      #   separator changes behavior.
+      #
+      # @example
+      #   # bad
+      #   'the string'.split
+      #
+      #   # good
+      #   'the string'.split(' ')
+      #
+      class NoEmptySplit < Base
+        MSG = 'Pass an argument `String#split` instead of no arguments.'
+
+        # `on_send` will only be called if the method name is in this list
+        RESTRICT_ON_SEND = %i[split].freeze
+
+        extend AutoCorrector
+
+        # @!method argless_split?(node)
+        def_node_matcher :argless_split?, <<~PATTERN
+          (call !nil? :split)
+        PATTERN
+
+        # Called on every `send` node (method call) while walking the AST.
+        # TODO: remove this method if inspecting `send` nodes is unneeded for your cop.
+        # By default, this is aliased to `on_csend` as well to handle method calls
+        # with safe navigation, remove the alias if this is unnecessary.
+        # If kept, ensure your tests cover safe navigation as well!
+        def on_send(node)
+          return unless argless_split?(node)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node.loc.selector.join(node.source_range.end), "split(' ')")
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rubomatic/style/require_braces_around_hash.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rubomatic::Style
+      # Requires `{}` around a hash argument when the called method takes it as a positional options hash instead of
+      # keyword arguments. The braces tell the caller it's an options hash and not keywords.
+      #
+      # The method is looked up in the project index (`AllCops/UseProjectIndex`), so the cop does nothing without it.
+      # A call is only flagged when the method is found and none of its definitions accept keywords (`a:`, `a: 1`,
+      # `**kwargs`, or `...`). Calls whose method can't be found (unknown methods, unresolved constants, locals, and
+      # chained receivers) are not flagged.
+      #
+      # The method is looked up on:
+      #
+      # - a constant receiver's class methods (`Service.call`), or its `initialize` for `new`
+      # - the enclosing class for bare and `self.` calls, on the class side inside the class body, `def self.`, and
+      #   `class << self`, and on the instance side inside instance methods
+      # - `Object` for bare calls outside a class
+      #
+      # @safety
+      #   Autocorrection is unsafe because wrapping the hash changes behavior for `ruby2_keywords` delegators, which
+      #   pass a braceless hash on as keywords but a braced hash as a positional argument.
+      #
+      # @example
+      #   def foo(options = { a: 0 }); end
+      #   def bar(a: 0); end
+      #
+      #   # bad
+      #   foo(a: 1)
+      #   foo a: 1
+      #   foo(**options)
+      #
+      #   # good
+      #   foo({ a: 1 })
+      #   foo({ **options })
+      #
+      #   # good - `bar` takes keywords
+      #   bar(a: 1)
+      #   bar(**options)
+      #
+      # @example
+      #   class Service
+      #     def self.call(options = {}); end
+      #
+      #     def initialize(options = {}); end
+      #   end
+      #
+      #   # bad
+      #   Service.call(a: 1)
+      #   Service.new(a: 1)
+      #
+      #   # good
+      #   Service.call({ a: 1 })
+      #   Service.new({ a: 1 })
+      #
+      class RequireBracesAroundHash < Base
+        MSG = 'Wrap options hash in `{}`.'
+
+        extend AutoCorrector
+        include ProjectIndexHelp
+
+        # :nodoc:
+        def on_send(node)
+          return unless project_index
+          # `Foo[a: 1]` has no parens to add, so the correction would swallow the `]`
+          return if node.method?(:[]) || node.method?(:[]=)
+
+          hashes = node.arguments.select { |arg| arg.hash_type? && !arg.braces? }
+          return if hashes.empty?
+
+          definitions = method_definitions(node)
+          return if definitions.empty?
+          return if accepts_keywords?(definitions)
+
+          hashes.each do |arg|
+            add_offense(arg) do |corrector|
+              wrap_in_braces(corrector, node, arg)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+          # Whether any indexed definition of the called method accepts keyword arguments
+          #
+          # @param definitions [Array<Rubydex::MethodDefinition>]
+          #
+          # @return [Boolean]
+          #
+          def accepts_keywords?(definitions)
+            definitions.any? do |definition|
+              definition.signatures.any? { |signature| keyword_signature?(signature) }
+            end
+          end
+
+          # @return [Boolean] does the signature take `a:`, `a: 1`, `**kwargs`, or `...`
+          def keyword_signature?(signature)
+            !signature.keyword_parameters.empty? ||
+              !signature.optional_keyword_parameters.empty? ||
+              !signature.rest_keyword_parameter.nil? ||
+              !signature.forward_parameter.nil?
+          end
+
+          # The indexed definitions of the called method, or `[]` when it can't be found
+          #
+          # @param node [RuboCop::AST::SendNode]
+          #
+          # @return [Array<Rubydex::MethodDefinition>]
+          #
+          def method_definitions(node)
+            method = find_method(node)
+            return [] if method.nil?
+
+            method.definitions.grep(Rubydex::MethodDefinition)
+          end
+
+          # Looks up the called method on the receiver's class, or on the enclosing class for bare and `self.` calls.
+          # Class-side calls look on the singleton class, except `new`, which looks up `initialize`
+          #
+          # @param node [RuboCop::AST::SendNode]
+          #
+          # @return [Rubydex::Method, nil]
+          #
+          def find_method(node)
+            namespace, singleton = receiver_scope(node)
+            return unless namespace.is_a?(Rubydex::Namespace)
+
+            if singleton && node.method?(:new)
+              namespace.find_member('initialize()')
+            elsif singleton
+              indexed_singleton_member(namespace, "#{node.method_name}()")
+            else
+              namespace.find_member("#{node.method_name}()")
+            end
+          end
+
+          # The namespace to look the method up in, and whether the lookup is on its class side
+          #
+          # @param node [RuboCop::AST::SendNode]
+          #
+          # @return [Array(Rubydex::Declaration, Boolean), nil]
+          #
+          def receiver_scope(node)
+            receiver = node.receiver
+            return [resolve_constant_in_index(receiver), true] if receiver&.const_type?
+            return if receiver && !receiver.self_type?
+
+            scope_node = node.each_ancestor(:class, :module, :sclass).first
+            return [project_index['Object'], false] if scope_node.nil?
+            return [resolve_constant_in_index(scope_node.identifier), class_side?(node)] unless scope_node.sclass_type?
+            return unless scope_node.identifier.self_type?
+
+            class_node = scope_node.each_ancestor(:class, :module).first
+            [class_node && resolve_constant_in_index(class_node.identifier), true]
+          end
+
+          # @return [Boolean] is `self` the class itself (class body or `def self.`), not an instance
+          def class_side?(node)
+            !node.each_ancestor(:def, :defs).first&.def_type?
+          end
+
+          # Wraps the hash in braces, keeping the layout of the call
+          #
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param node [RuboCop::AST::SendNode]
+          # @param hash [RuboCop::AST::HashNode]
+          #
+          # @return [void]
+          #
+          def wrap_in_braces(corrector, node, hash)
+            if !node.parenthesized?
+              # `create :user, name: name` -> `create(:user, { name: name })`
+              corrector.replace(node.loc.selector.end.join(node.first_argument.source_range.begin), '(')
+              corrector.insert_before(hash, '{ ')
+              corrector.insert_after(hash, ' }')
+              corrector.insert_after(node.last_argument, ')')
+            elsif hash.first_line == node.loc.begin.line
+              # `User.new(name: name)` / `User.create(name: name,\n password: password)`
+              corrector.insert_before(hash, '{ ')
+              corrector.insert_after(hash, ' }')
+            elsif node.arguments.one?
+              # `User.new(\n  name: name,\n)` -> `User.new({\n  name: name,\n})`
+              corrector.insert_after(node.loc.begin, '{')
+              corrector.insert_before(node.loc.end, '}')
+            else
+              # `create(\n  :user,\n  name: name,\n)` -> hash gets its own `{` / `}` lines, pairs indented one level
+              indent = ' ' * hash.loc.column
+              corrector.insert_before(hash, "{\n#{indent}  ")
+              hash.children.drop(1).each do |child|
+                corrector.insert_before(child, '  ') if begins_its_line?(child.source_range)
+              end
+              corrector.insert_after(hash, ",\n#{indent}}")
+            end
+          end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rubomatic_cops.rb

@@ -1,4 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'rubomatic/layout/multiline_array_line_breaks'
+require_relative 'rubomatic/rspec/describe_block_length'
 require_relative 'rubomatic/style/disallowed_methods'
+require_relative 'rubomatic/style/no_empty_join'
+require_relative 'rubomatic/style/no_empty_split'
+require_relative 'rubomatic/style/require_braces_around_hash'

data/lib/rubocop/rubomatic/version.rb

@@ -4,8 +4,8 @@ module RuboCop
   module Rubomatic
     module VERSION
       MAJOR = 2
-      MINOR = 1
-      PATCH = 1
+      MINOR = 2
+      PATCH = 0
       TINY = PATCH
 
       # Set PRE to nil unless it's a pre-release (beta, rc, etc.)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rubomatic
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Brands Insurance
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-20 00:00:00.000000000 Z
+date: 2026-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lint_roller
@@ -131,6 +131,7 @@ files:
 - config/rspec.yml
 - config/rubocop.yml
 - config/rubomatic/layout.yml
+- config/rubomatic/rspec.yml
 - config/rubomatic/rubocop.yml
 - config/rubomatic/style.yml
 - config/security.yml
@@ -138,14 +139,23 @@ files:
 - config/thread_safety.yml
 - docs/cops/layout/README.md
 - docs/cops/layout/multiline_array_line_breaks/README.md
+- docs/cops/rspec/README.md
+- docs/cops/rspec/describe_block_length/README.md
 - docs/cops/style/README.md
 - docs/cops/style/disallowed_methods/README.md
+- docs/cops/style/no_empty_join/README.md
+- docs/cops/style/no_empty_split/README.md
+- docs/cops/style/require_braces_around_hash/README.md
 - lib/rubocop-rubomatic.rb
 - lib/rubocop/cop/rubomatic/generator.rb
 - lib/rubocop/cop/rubomatic/generator/cop_readme_injector.rb
 - lib/rubocop/cop/rubomatic/generator/dept_readme_injector.rb
 - lib/rubocop/cop/rubomatic/layout/multiline_array_line_breaks.rb
+- lib/rubocop/cop/rubomatic/rspec/describe_block_length.rb
 - lib/rubocop/cop/rubomatic/style/disallowed_methods.rb
+- lib/rubocop/cop/rubomatic/style/no_empty_join.rb
+- lib/rubocop/cop/rubomatic/style/no_empty_split.rb
+- lib/rubocop/cop/rubomatic/style/require_braces_around_hash.rb
 - lib/rubocop/cop/rubomatic_cops.rb
 - lib/rubocop/rubomatic.rb
 - lib/rubocop/rubomatic/plugin.rb
@@ -174,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Custom cops and shared config for BrandsInsurance