kaizo 0.7.0 → 0.9.2

data/config/default.yml

@@ -7,26 +7,84 @@
 
 # The `Kaizo/*` cops check `def`, `def self.`, `define_method`, and
 # `define_singleton_method`. `*rest`, `**keyword-rest`, and `&block` parameters
-# are not counted. The defaults are deliberately strict -- at most one positional
-# and one keyword argument -- to apply maximum pressure; loosen them if that is
-# too aggressive for your codebase.
+# are not counted. Operator methods (`[]=`, `[]`, `<=>`, ...) and the `initialize`
+# of a `Struct.new`/`Data.define` block are exempt -- their arity is fixed by Ruby
+# syntax or by the value object's members, not by a modeling choice. The defaults
+# are deliberately strict -- at most one positional and one keyword argument -- to
+# apply maximum pressure; loosen them if that is too aggressive for your codebase.
+# Exempt individual methods by name (`AllowedMethods`, e.g. `initialize`) or by
+# regexp (`AllowedPatterns`).
+#
+# The keyword-counting cops (`KeywordArguments`, `TotalArguments`) skip `spec/`
+# and `test/` trees: wide keyword interfaces are the testing idiom there
+# (FactoryBot-style `create`/`build` helpers), and the total bound would
+# re-police the keywords the exemption frees. `PositionalArguments` runs
+# everywhere -- positional arguments communicate nothing unless they are solo.
 Kaizo/KeywordArguments:
   Description: 'Checks that a method does not declare too many keyword arguments.'
   Enabled: true
   VersionAdded: '0.1'
+  VersionChanged: '0.9.1'
   Max: 1
+  AllowedMethods: []
+  AllowedPatterns: []
+  Exclude:
+    - '**/spec/**/*'
+    - '**/test/**/*'
+
+# `Kaizo/PluralCollectionName` flags a method that hands back an array under a
+# singular name. Ruby has no return types, so this is a heuristic, and it errs
+# toward silence: a method is flagged only when every value it can return is
+# unambiguously an array. `ArrayMethods` is the set whose result is an `Array`
+# whatever the receiver -- `select` and `reject` are absent on purpose, since on
+# a `Hash` they return a `Hash`; extend it (with `inherit_mode: merge`) to
+# cover your own collection-returning helpers. A name counts as plural when it
+# ends in `s` or appears in `IrregularPlurals`.
+Kaizo/PluralCollectionName:
+  Description: 'Checks that a method returning a collection is named in the plural.'
+  Enabled: true
+  VersionAdded: '0.8'
+  VersionChanged: '0.9'
+  AllowedMethods: []
+  ArrayMethods:
+    - map
+    - flat_map
+    - collect
+    - collect_concat
+    - to_a
+    - entries
+    - sort
+    - sort_by
+    - zip
+  IrregularPlurals:
+    - people
+    - children
+    - men
+    - women
+    - data
+    - media
+    - criteria
 
 Kaizo/PositionalArguments:
   Description: 'Checks that a method does not declare too many positional arguments.'
   Enabled: true
   VersionAdded: '0.1'
+  VersionChanged: '0.9'
   Max: 1
+  AllowedMethods: []
+  AllowedPatterns: []
 
 Kaizo/TotalArguments:
   Description: 'Checks that a method does not declare too many arguments in total.'
   Enabled: true
   VersionAdded: '0.1'
+  VersionChanged: '0.9.1'
   Max: 2
+  AllowedMethods: []
+  AllowedPatterns: []
+  Exclude:
+    - '**/spec/**/*'
+    - '**/test/**/*'
 
 # `Kaizo/AgentNounClassName` flags `class` definitions and
 # `Struct.new`/`Data.define`/`Class.new` assignments whose name ends in `er`/`or`
@@ -114,12 +172,18 @@ Kaizo/NestedMethodCalls:
 # example. Magic comments, `# rubocop:` directives, and shebangs are exempt;
 # add more exemptions with `AllowedPatterns`. Broaden `Include` (e.g. add
 # `**/spec/**/*` or `**/*_test.rb`) to cover support files or Minitest.
+# `spec/helpers` and `spec/support` hold infrastructure, not specs, so they
+# are excluded by default; override `Exclude` to change that.
 Kaizo/SpecComment:
   Description: 'Avoid comments in spec files; express the intent as well-structured specs.'
   Enabled: true
   VersionAdded: '0.5'
+  VersionChanged: '0.9'
   Include:
     - '**/*_spec.rb'
+  Exclude:
+    - '**/spec/helpers/**/*'
+    - '**/spec/support/**/*'
   AllowedPatterns: []
 
 # `Kaizo/ExplicitBegin` requires an explicit `begin`/`end` block when a method
@@ -153,17 +217,31 @@ Kaizo/NextInNonVoidEnumerable:
 # `.rubocop.yml` at your peril.
 Style/RedundantBegin:
   Enabled: false
+
+# Prefer Ruby 3.1's hash-value shorthand -- `Session.new(table:)` over
+# `Session.new(table: table)` -- everywhere key and value name match. Shipped on
+# by default because kaizo targets modern Ruby; override in your own config if
+# you want the explicit form.
+Style/HashSyntax:
+  EnforcedShorthandSyntax: always
+
 # `Kaizo/SpecDescriptionProse` requires RSpec `it`/`context` descriptions to
-# read as one-behavior prose: no commas, conjunctions (`Conjunctions`), or code
-# in an `it` description; `context` descriptions carry no code and open with a
-# `ContextPrefixes` word. `describe` strings are exempt. No autocorrection.
+# read as one-behavior prose: no commas, none of the `ForbiddenWords`
+# (conjunctions and conditionals whose presence signals a hidden split), and no
+# code in an `it` description; `context` descriptions carry no code and must
+# open with one of the `RequiredContextPrefixes`. Error class names
+# (`Foo::Error`) read as prose, since the error is part of the specified
+# behavior. Exempt whole descriptions with `AllowedPatterns`. `describe`
+# strings are exempt. No autocorrection.
 Kaizo/SpecDescriptionProse:
   Description: 'Require RSpec it/context descriptions to read as one-behavior prose.'
   Enabled: true
   VersionAdded: '0.6'
+  VersionChanged: '0.9'
   Include:
     - '**/*_spec.rb'
-  Conjunctions:
+  AllowedPatterns: []
+  ForbiddenWords:
     - and
     - but
     - or
@@ -179,12 +257,28 @@ Kaizo/SpecDescriptionProse:
     - because
     - although
     - though
-  ContextPrefixes:
+  RequiredContextPrefixes:
     - when
     - with
     - without
     - after
 
+# `Kaizo/SpecSubject` requires the unit under test to be declared with
+# `subject`, not `let`. A `let`/`let!` is flagged when its block confidently
+# builds the class under test: a `.new` on `described_class`, on the constant
+# an enclosing `describe`/`context` names (full or short name), or on a
+# constant matching the spec's file name. Deliberate second instances (an
+# `other` in an equality spec) are exempted with `AllowedMethods` /
+# `AllowedPatterns`, matched against the `let` name. No autocorrection.
+Kaizo/SpecSubject:
+  Description: 'Declare the unit under test with subject, not let.'
+  Enabled: true
+  VersionAdded: '0.9'
+  Include:
+    - '**/*_spec.rb'
+  AllowedMethods: []
+  AllowedPatterns: []
+
 # `Kaizo/FileUtilsInclusion` requires `FileUtils` to be mixed in with `include`
 # or `extend` once it is used more than once in a class or module, instead of
 # repeating the `FileUtils.` receiver. The namespace is reported once. A single
@@ -195,6 +289,16 @@ Kaizo/FileUtilsInclusion:
   Enabled: true
   VersionAdded: '0.6'
 
+# `Kaizo/TempfileCreate` requires block-form `Tempfile.create`, the only
+# temp-file API that closes and removes the file deterministically.
+# `Tempfile.new`/`Tempfile.open` rely on a GC finalizer that may run late or
+# never; blockless `Tempfile.create` returns a plain `File` that is never
+# removed automatically. No autocorrection.
+Kaizo/TempfileCreate:
+  Description: 'Use block-form Tempfile.create; Tempfile.new/open clean up unpredictably.'
+  Enabled: true
+  VersionAdded: '0.9'
+
 # `Kaizo/PreferPathname` flags calls to `File` class methods that have a
 # `Pathname` instance-method equivalent (`File.read`, `File.exist?`, `File.join`,
 # ...), preferring `Pathname`. Runs on `**/*.rb`; `exe/**/*` and `bin/**/*` are

data/lib/kaizo/version.rb

@@ -1,3 +1,3 @@
 module Kaizo
-  VERSION = "0.7.0".freeze
+  VERSION = "0.9.2".freeze
 end

data/lib/rubocop/cop/kaizo/agent_noun_class_name.rb

@@ -16,6 +16,29 @@ module RuboCop
       # assignments are both checked. There is no autocorrection: renaming a
       # class is a design decision.
       #
+      # == Configuration
+      #
+      # [+AllowedSuffixes+] Suffixes exempt from the `er`/`or` rule, matched
+      #                     against the end of the name (+Controller+ clears
+      #                     +UsersController+ too). Default: a broad list of
+      #                     legitimate `-er`/`-or` domain nouns and framework
+      #                     terms (+Adapter+, +Controller+, +Error+, +User+,
+      #                     ...) -- see +config/default.yml+ for all of them.
+      # [+ForbiddenSuffixes+] Suffixes always flagged, even when matched by
+      #                       +AllowedSuffixes+ -- which is how a default
+      #                       exemption is dropped. Default: +Service+, +Util+,
+      #                       +Utils+.
+      #
+      # Extend either list without restating it via RuboCop's
+      # <tt>inherit_mode: merge</tt>:
+      #
+      #   Kaizo/AgentNounClassName:
+      #     inherit_mode:
+      #       merge:
+      #         - AllowedSuffixes
+      #     AllowedSuffixes:
+      #       - Voucher     # PaymentVoucher now passes
+      #
       # @example
       #   # bad
       #   class PaymentProcessor
@@ -58,7 +81,7 @@ module RuboCop
         def check_name(name, location)
           return unless offending?(name)
 
-          add_offense(location, message: format(MSG, name: name))
+          add_offense(location, message: format(MSG, name:))
         end
 
         def offending?(name)

data/lib/rubocop/cop/kaizo/argument_counting.rb

@@ -6,30 +6,70 @@ module RuboCop
       # Walks method definitions written with `def`, `def self.`, `define_method`,
       # and `define_singleton_method`, and reports when the argument count
       # produced by the including cop exceeds the configured `Max`. Including cops
-      # must define a private `arity(arguments)` method and a `KIND` constant. The
-      # `initialize` of a `Struct.new`/`Data.define` block is exempt.
+      # must define a private `arity(arguments)` method and a `KIND` constant.
+      # Operator methods (`[]=`, `[]`, `<=>`, ...) and the `initialize` of a
+      # `Struct.new`/`Data.define` block are exempt.
       module ArgumentCounting
+        include AllowedMethods
+        include AllowedPattern
+
         POSITIONAL_TYPES = %i[arg optarg].freeze
         KEYWORD_TYPES = %i[kwarg kwoptarg].freeze
         DEFINE_METHODS = %i[define_method define_singleton_method].freeze
         STRUCT_OR_DATA = { "Struct" => :new, "Data" => :define }.freeze
+
+        # Ruby's operator method names, mirroring the list behind RuboCop's
+        # `operator_method?` (private upstream, so it cannot be reused). Needed
+        # only for the `define_method(:[]=)` form, where the name being defined is
+        # a symbol argument rather than a `def` node we could ask directly.
+        OPERATOR_METHOD_NAMES = [
+          :!, :!=, :"!@", :!~, :%, :&, :*, :**, :+, :+@, :-, :-@, :/, :<, :<<, :<=,
+          :<=>, :==, :===, :=~, :>, :>=, :>>, :[], :[]=, :^, :`, :|, :~, :"~@"
+        ].freeze
         MSG = "Method has too many %<kind>s. [%<count>d/%<max>d]".freeze
 
         def on_def(node)
-          return if allowed_initialize?(node)
+          return if exempt?(node)
 
           check_arity(node)
         end
         alias on_defs on_def
 
         def on_block(node)
-          check_arity(node) if DEFINE_METHODS.include?(node.method_name)
+          return unless DEFINE_METHODS.include?(node.method_name)
+          return if exempt_defined_name?(node)
+
+          check_arity(node)
         end
         alias on_numblock on_block
         alias on_itblock on_block
 
         private
 
+        # A definition whose argument count is not a design choice. An operator
+        # method's arity is fixed by Ruby's syntax -- `[]=` takes the indices plus
+        # the assigned value, `<=>` takes its right-hand side -- so it cannot be
+        # modeled away, and a `Struct`/`Data` `initialize` just mirrors the members
+        # the value object was declared with.
+        def exempt?(node)
+          node.operator_method? || allowed_initialize?(node) || allowed_name?(node.method_name)
+        end
+
+        # The same exemptions for `define_method(:[]=)`, which names the method it
+        # defines with a symbol (or string) argument. A computed name is still
+        # checked -- we cannot know what it resolves to.
+        def exempt_defined_name?(node)
+          defined_name = node.send_node.first_argument
+          return false unless defined_name&.type?(:sym, :str)
+
+          name = defined_name.value.to_sym
+          OPERATOR_METHOD_NAMES.include?(name) || allowed_name?(name)
+        end
+
+        def allowed_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name.to_s)
+        end
+
         def positional_arity(arguments)
           arguments.count { |argument| POSITIONAL_TYPES.include?(argument.type) }
         end
@@ -43,8 +83,8 @@ module RuboCop
           count = arity(node.arguments)
           return unless max && count > max
 
-          message = format(MSG, kind: self.class::KIND, count: count, max: max)
-          add_offense(offense_location(node), message: message) { self.max = count }
+          message = format(MSG, kind: self.class::KIND, count:, max:)
+          add_offense(offense_location(node), message:) { self.max = count }
         end
 
         def offense_location(node)

data/lib/rubocop/cop/kaizo/explicit_begin.rb

@@ -15,6 +15,15 @@ module RuboCop
       # Modifier `rescue` expressions (`foo rescue nil`) and endless method
       # definitions are not flagged.
       #
+      # == Configuration
+      #
+      # No cop-specific options; the standard per-cop settings (+Enabled+,
+      # +Severity+, +AutoCorrect+, +Include+/+Exclude+) apply. Note that
+      # loading the kaizo plugin disables `Style/RedundantBegin`, this cop's
+      # exact inverse. To opt out of explicit begins, disable this cop;
+      # re-enable `Style/RedundantBegin` only alongside that, since with both
+      # enabled each flags the form the other mandates.
+      #
       # @safety
       #   Autocorrection is skipped when the body does not sit on its own lines
       #   between `def` and `end` (a single-line definition, for example), and

data/lib/rubocop/cop/kaizo/file_utils_inclusion.rb

@@ -19,6 +19,11 @@ module RuboCop
       # There is no autocorrection: whether to `include` or `extend`, and where
       # the mixin belongs, is a judgment call for a human.
       #
+      # == Configuration
+      #
+      # No cop-specific options; the standard per-cop settings (+Enabled+,
+      # +Severity+, +Include+/+Exclude+) apply.
+      #
       # @example
       #   # bad - the `FileUtils.` receiver is repeated
       #   class Backup
@@ -68,7 +73,7 @@ module RuboCop
           count = own_sends(node) { |send| file_utils_call?(send) }.size
           return if count < 2
 
-          add_offense(node.loc.name, message: format(MSG, count: count, scope: scope))
+          add_offense(node.loc.name, message: format(MSG, count:, scope:))
         end
 
         # Sends in `namespace`'s own body that match the block -- not its

data/lib/rubocop/cop/kaizo/keyword_arguments.rb

@@ -8,6 +8,23 @@ module RuboCop
       # (`kwarg`) and optional (`kwoptarg`) parameters are counted; `**rest` is
       # not.
       #
+      # == Configuration
+      #
+      # [+Max+] Most keyword arguments a method may declare. Default: +1+.
+      # [+AllowedMethods+] Method names exempt from the limit. Default: none.
+      # [+AllowedPatterns+] Regexps matched against the method name; a match is
+      #                     exempt. Default: none.
+      # [+Exclude+] Paths the cop skips. Default: <tt>**/spec/**/*</tt> and
+      #             <tt>**/test/**/*</tt> -- wide keyword interfaces are the
+      #             testing idiom (FactoryBot-style builders), so keyword
+      #             counts are not policed there. Set it to <tt>[]</tt> to
+      #             police tests too.
+      #
+      #   Kaizo/KeywordArguments:
+      #     Max: 2
+      #     AllowedMethods:
+      #       - initialize
+      #
       # @example Max: 2
       #   # bad
       #   def calculate_volume(width:, length:, height:)
@@ -17,6 +34,11 @@ module RuboCop
       #   def calculate_volume(shape)
       #   end
       #
+      # @example AllowedMethods: ['initialize'] (default: [])
+      #   # good - exempt by name
+      #   def initialize(host:, port:, ssl: true)
+      #   end
+      #
       class KeywordArguments < Base
         include ArgumentCounting
 

data/lib/rubocop/cop/kaizo/nested_method_calls.rb

@@ -5,8 +5,10 @@ module RuboCop
       #
       # A call whose arguments are themselves the results of other calls --
       # `foo(SomeClass.new(another("bar").chain))` -- packs several steps into one
-      # expression. Naming the intermediate results (or extracting a method) almost
-      # always reads better and is easier to debug than peeling parentheses apart.
+      # expression. Giving the intermediate results descriptive names (or extracting
+      # a method) almost always reads better and is easier to debug than peeling
+      # parentheses apart. The point is not the assignment but the name: it should
+      # say what the value is, so the step documents itself.
       #
       # Only nesting through *argument* positions is counted; a receiver chain such
       # as `user.account.owner.name` is a separate concern. Operator methods
@@ -14,6 +16,18 @@ module RuboCop
       # Depth is measured from each outermost call and reported once. There is no
       # autocorrection: choosing the intermediate name is a design decision.
       #
+      # == Configuration
+      #
+      # [+Max+] Deepest allowed nesting of calls in argument positions; +1+
+      #         permits one nested call. Default: +1+.
+      # [+AllowedMethods+] Calls to these methods neither count toward depth
+      #                    nor get flagged. Default: none.
+      #
+      #   Kaizo/NestedMethodCalls:
+      #     Max: 2
+      #     AllowedMethods:
+      #       - expect      # don't count RSpec's expect(...) wrapper
+      #
       # @example Max: 1 (default)
       #   # bad
       #   foo(SomeClass.new(another("bar").chain))
@@ -21,9 +35,9 @@ module RuboCop
       #   # bad
       #   wrap(parse(read(io)))
       #
-      #   # good - name the intermediate result
-      #   parsed = parse(read(io))
-      #   wrap(parsed)
+      #   # good - a name that documents what the value is
+      #   parsed_config = parse(read(io))
+      #   wrap(parsed_config)
       #
       #   # good - a single nested call is allowed
       #   puts compute(value)
@@ -48,7 +62,7 @@ module RuboCop
           depth = nesting_depth(node)
           return unless max && depth > max
 
-          add_offense(node, message: format(MSG, depth: depth, max: max)) do
+          add_offense(node, message: format(MSG, depth:, max:)) do
             self.max = depth
           end
         end

data/lib/rubocop/cop/kaizo/next_in_non_void_enumerable.rb

@@ -21,6 +21,17 @@ module RuboCop
       # clause might become a ternary, a `select`/`reject`, a `filter_map`, or a
       # restructured block.
       #
+      # == Configuration
+      #
+      # [+AllowedMethods+] Enumerable methods whose blocks may use `next`.
+      #                    Default: none.
+      # [+AllowedPatterns+] Regexps matched against the enumerable method's
+      #                     name; a match is exempt. Default: none.
+      #
+      #   Kaizo/NextInNonVoidEnumerable:
+      #     AllowedMethods:
+      #       - reduce      # allow `next acc` guards in reduce/inject
+      #
       # @example
       #   # bad
       #   array.map do |item|
@@ -113,11 +124,11 @@ module RuboCop
         private
 
         def flag_block_local_nexts(block_node, method)
-          message = format(MSG, method: method)
+          message = format(MSG, method:)
 
           block_node.each_child_node do |child|
             each_block_local_next(child) do |next_node|
-              add_offense(next_node.loc.keyword, message: message)
+              add_offense(next_node.loc.keyword, message:)
             end
           end
         end

data/lib/rubocop/cop/kaizo/plural_collection_name.rb

@@ -0,0 +1,139 @@
+module RuboCop
+  module Cop
+    module Kaizo
+      # Checks that a method returning a collection is named in the plural. A
+      # singular name on a method handing back an array (`def user` returning
+      # `[first, second]`) misdescribes what the caller gets; the plural does the
+      # documenting for free.
+      #
+      # Ruby has no return types, so "returns an array" is a heuristic, and this
+      # cop deliberately errs toward silence. A method is only flagged when
+      # *every* value it can return is unambiguously an array: an array literal,
+      # or a call to a method that returns an `Array` whatever its receiver
+      # (`ArrayMethods`, e.g. `map`, `to_a`, `sort`). One branch returning `nil`
+      # is enough to leave the method alone. Methods like `select` and `reject`
+      # are absent by design -- on a `Hash` they hand back a `Hash`.
+      #
+      # A name counts as plural when it ends in `s` or appears in
+      # `IrregularPlurals`. Predicate (`?`), writer (`=`), and operator methods
+      # are exempt, as is `initialize`, and `AllowedMethods` exempts names
+      # outright. There is no autocorrection: renaming a method is a design
+      # decision, and only its author knows the right plural.
+      #
+      # == Configuration
+      #
+      # [+ArrayMethods+] Calls treated as returning an +Array+ whatever their
+      #                  receiver. Default: +map+, +flat_map+, +collect+,
+      #                  +collect_concat+, +to_a+, +entries+, +sort+, +sort_by+,
+      #                  +zip+.
+      # [+IrregularPlurals+] Names accepted as plural despite not ending in
+      #                      +s+. Default: +people+, +children+, +men+,
+      #                      +women+, +data+, +media+, +criteria+.
+      # [+AllowedMethods+] Method names never flagged. Default: none.
+      #
+      # Extend a list without restating its default via RuboCop's
+      # <tt>inherit_mode: merge</tt>:
+      #
+      #   Kaizo/PluralCollectionName:
+      #     inherit_mode:
+      #       merge:
+      #         - ArrayMethods
+      #         - IrregularPlurals
+      #     ArrayMethods:
+      #       - fetch_all
+      #     IrregularPlurals:
+      #       - alumni
+      #
+      # @example
+      #   # bad
+      #   def user
+      #     [first_match, second_match]
+      #   end
+      #
+      #   # good
+      #   def users
+      #     [first_match, second_match]
+      #   end
+      #
+      # @example
+      #   # good - not confidently an array, so not flagged
+      #   def user
+      #     return nil if missing?
+      #
+      #     [first_match, second_match]
+      #   end
+      #
+      class PluralCollectionName < Base
+        include AllowedMethods
+
+        MSG = "Name a method that returns a collection in the plural. " \
+              "`%<name>s` returns an array.".freeze
+
+        # Methods whose result is an `Array` regardless of the receiver. Kept
+        # deliberately short: anything whose return type follows its receiver
+        # (`select` on a `Hash`) would turn this cop into a false-positive mill.
+        DEFAULT_ARRAY_METHODS = %i[
+          map flat_map collect collect_concat to_a entries sort sort_by zip
+        ].freeze
+
+        def on_def(node)
+          return if exempt?(node)
+          return unless returns_array?(node.body)
+
+          add_offense(node.loc.name, message: format(MSG, name: node.method_name))
+        end
+        alias on_defs on_def
+
+        private
+
+        def exempt?(node)
+          return true if node.predicate_method? || node.assignment_method?
+          return true if node.operator_method? || node.method?(:initialize)
+
+          plural?(node.method_name.to_s) || allowed_method?(node.method_name)
+        end
+
+        def plural?(name)
+          name.end_with?("s") || irregular_plurals.include?(name)
+        end
+
+        def irregular_plurals
+          Array(cop_config["IrregularPlurals"])
+        end
+
+        # Every value the method can hand back must be an array before it is
+        # worth flagging, so that a single `return nil` keeps the cop quiet.
+        def returns_array?(body)
+          return false unless body
+
+          results = [final_expression(body), *explicit_returns(body)]
+          results.all? { |result| array_result?(result) }
+        end
+
+        def final_expression(body)
+          body.begin_type? ? body.children.last : body
+        end
+
+        # The value of each `return`, with a bare `return` contributing `nil` --
+        # which is exactly what should stop the method being flagged.
+        def explicit_returns(body)
+          body.each_descendant(:return).map { |node| node.children.first }
+        end
+
+        # A block-bearing call (`rows.map { ... }`) is a block node wrapping the
+        # send, so the method name lives one level down.
+        def array_result?(node)
+          return false unless node
+          return true if node.array_type?
+
+          call = node.any_block_type? ? node.send_node : node
+          call.call_type? && array_methods.include?(call.method_name)
+        end
+
+        def array_methods
+          @array_methods ||= Array(cop_config.fetch("ArrayMethods", DEFAULT_ARRAY_METHODS)).map(&:to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/kaizo/positional_arguments.rb

@@ -8,6 +8,22 @@ module RuboCop
       # and optional (`optarg`) parameters are counted; `*rest` and `&block` are
       # not.
       #
+      # Unlike the keyword-counting cops, this one runs everywhere, spec and
+      # test trees included: positional arguments communicate nothing unless
+      # they are solo, in test code as much as anywhere else.
+      #
+      # == Configuration
+      #
+      # [+Max+] Most positional arguments a method may declare. Default: +1+.
+      # [+AllowedMethods+] Method names exempt from the limit. Default: none.
+      # [+AllowedPatterns+] Regexps matched against the method name; a match is
+      #                     exempt. Default: none.
+      #
+      #   Kaizo/PositionalArguments:
+      #     Max: 0        # force every argument to be a keyword
+      #     AllowedMethods:
+      #       - initialize
+      #
       # @example Max: 2
       #   # bad
       #   def move(x, y, z)

data/lib/rubocop/cop/kaizo/prefer_pathname.rb

@@ -15,6 +15,19 @@ module RuboCop
       # There is no autocorrection: rewriting `File.read(path)` as
       # `Pathname(path).read` changes the receiver and is left to a human.
       #
+      # == Configuration
+      #
+      # [+Include+] Files the cop runs on. Default: <tt>**/*.rb</tt>.
+      # [+Exclude+] Files the cop skips even when included. Default:
+      #             <tt>exe/**/*</tt> and <tt>bin/**/*</tt>.
+      #
+      #   Kaizo/PreferPathname:
+      #     inherit_mode:
+      #       merge:
+      #         - Exclude
+      #     Exclude:
+      #       - 'db/**/*'      # add your own
+      #
       # @example
       #   # bad
       #   File.read(path)