kaizo 0.8.0 → 0.9.2

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

@@ -0,0 +1,117 @@
+module RuboCop
+  module Cop
+    module Kaizo
+      # Requires the unit under test to be declared with `subject`, not `let`.
+      # `subject` is RSpec's name for the object being specified; hiding it in a
+      # `let` obscures which object the examples are about and forfeits
+      # `is_expected`/one-liner syntax.
+      #
+      # A `let` (or `let!`) is flagged when the value it returns is confidently
+      # an instance of the class under test: the block's final expression is a
+      # `.new` call on `described_class`, on the constant named by an enclosing
+      # `describe`/`context` (full or short name), or on a constant matching the
+      # spec's file name (`pool_spec.rb` names `Pool`, `api_client_spec.rb`
+      # names `APIClient`).
+      #
+      # A `let` that builds a second instance on purpose -- an `other` for an
+      # equality spec, say -- is exempted through `AllowedMethods` or
+      # `AllowedPatterns`, both matched against the `let` name.
+      #
+      # There is no autocorrection: renaming the helper every example refers to
+      # is a change the spec's author should make deliberately.
+      #
+      # == Configuration
+      #
+      # [+AllowedMethods+] `let` names never flagged. Default: none.
+      # [+AllowedPatterns+] Regexps matched against the `let` name; a match is
+      #                     exempt. Default: none.
+      # [+Include+] Files the cop runs on. Default: <tt>**/*_spec.rb</tt>.
+      #
+      #   Kaizo/SpecSubject:
+      #     AllowedMethods:
+      #       - other       # a second instance for equality specs
+      #     AllowedPatterns:
+      #       - '\Aother_'
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe Session::Pool do
+      #     let(:pool) { described_class.new }
+      #   end
+      #
+      #   # good
+      #   RSpec.describe Session::Pool do
+      #     subject(:pool) { described_class.new }
+      #   end
+      #
+      # @example AllowedMethods: ['other'] (default: [])
+      #   # good - a deliberate second instance
+      #   RSpec.describe Session::Pool do
+      #     subject(:pool) { described_class.new }
+      #
+      #     let(:other) { described_class.new }
+      #   end
+      #
+      class SpecSubject < Base
+        include AllowedMethods
+        include AllowedPattern
+
+        MSG = "Declare the unit under test with `subject(:%<name>s)`, not `let`.".freeze
+
+        # @!method let_declaration(node)
+        def_node_matcher :let_declaration, <<~PATTERN
+          (block (send nil? {:let :let!} (sym $_)) _ $_)
+        PATTERN
+
+        # @!method constructed_class(node)
+        def_node_matcher :constructed_class, <<~PATTERN
+          (send ${(send nil? :described_class) (const _ _)} :new ...)
+        PATTERN
+
+        # @!method described_constant(node)
+        def_node_matcher :described_constant, <<~PATTERN
+          (block (send {(const {nil? cbase} :RSpec) nil?} {:describe :context} $(const ...) ...) ...)
+        PATTERN
+
+        def on_block(node)
+          name, body = let_declaration(node)
+          return unless name
+          return if allowed_method?(name) || matches_allowed_pattern?(name.to_s)
+          return unless unit_under_test?(node, final_expression(body))
+
+          add_offense(node.send_node.loc.selector, message: format(MSG, name:))
+        end
+
+        private
+
+        def final_expression(body)
+          body&.begin_type? ? body.children.last : body
+        end
+
+        def unit_under_test?(node, expression)
+          receiver = expression && constructed_class(expression)
+          return false unless receiver
+          return true if receiver.send_type?
+
+          described?(node, receiver)
+        end
+
+        def described?(node, const_node)
+          described_constants(node).any? do |described|
+            described.const_name == const_node.const_name ||
+              described.short_name == const_node.short_name
+          end || file_named_after?(const_node.short_name)
+        end
+
+        def described_constants(node)
+          node.each_ancestor(:block).filter_map { |ancestor| described_constant(ancestor) }
+        end
+
+        def file_named_after?(short_name)
+          base = processed_source.file_path&.[](%r{([^/]+)_spec\.rb\z}, 1)
+          base && short_name.to_s.downcase == base.delete("_")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module RuboCop
+  module Cop
+    module Kaizo
+      # Requires temporary files to be created with block-form `Tempfile.create`,
+      # and flags `Tempfile.new`, `Tempfile.open`, and blockless `Tempfile.create`.
+      #
+      # Only the block form cleans up deterministically: the file is closed and
+      # removed when the block returns, however it returns. A `Tempfile` built
+      # with `.new` or `.open` is removed by a GC finalizer that runs at some
+      # unpredictable point -- possibly never -- and blockless `Tempfile.create`
+      # hands back a plain `File` that is never removed automatically at all.
+      #
+      # There is no autocorrection: moving the file's users into the block is a
+      # restructuring, and the block's return value replaces the handle the old
+      # code held onto.
+      #
+      # == Configuration
+      #
+      # No cop-specific options; the standard per-cop settings (+Enabled+,
+      # +Severity+, +Include+/+Exclude+) apply.
+      #
+      # @example
+      #   # bad
+      #   file = Tempfile.new("report")
+      #   file = Tempfile.open("report")
+      #   file = Tempfile.create("report")
+      #
+      #   # good
+      #   Tempfile.create("report") do |file|
+      #     file.write(data)
+      #   end
+      #
+      class TempfileCreate < Base
+        MSG = "Use `Tempfile.create` with a block instead of `Tempfile.%<method>s`; " \
+              "finalizer-based cleanup is unpredictable.".freeze
+        BLOCKLESS_CREATE_MSG = "Pass a block to `Tempfile.create`; " \
+                               "without one the file is never removed.".freeze
+
+        RESTRICT_ON_SEND = %i[new open create].freeze
+
+        # @!method tempfile_call?(node)
+        def_node_matcher :tempfile_call?, <<~PATTERN
+          (send (const {nil? cbase} :Tempfile) _ ...)
+        PATTERN
+
+        def on_send(node)
+          return unless tempfile_call?(node)
+          return if node.method?(:create) && block_given_to?(node)
+
+          range = node.receiver.source_range.join(node.loc.selector)
+          add_offense(range, message: message_for(node))
+        end
+
+        private
+
+        def message_for(node)
+          return BLOCKLESS_CREATE_MSG if node.method?(:create)
+
+          format(MSG, method: node.method_name)
+        end
+
+        def block_given_to?(node)
+          return true if node.last_argument&.block_pass_type?
+
+          parent = node.parent
+          parent&.any_block_type? && parent.send_node.equal?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -12,6 +12,24 @@ module RuboCop
       # `initialize` of a `Struct.new`/`Data.define` block is exempt, since those
       # parameters mirror the value object's attributes.
       #
+      # == Configuration
+      #
+      # [+Max+] Most arguments -- positional plus keyword -- a method may
+      #         declare. Default: +2+.
+      # [+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>, matching `KeywordArguments` -- a
+      #             total bound would re-police the keyword freedom tests get.
+      #             `PositionalArguments` alone still bounds positional
+      #             arguments there. Set it to <tt>[]</tt> to police tests too.
+      #
+      #   Kaizo/TotalArguments:
+      #     Max: 3
+      #     AllowedMethods:
+      #       - initialize
+      #
       # @example Max: 3
       #   # bad
       #   def calculate_volume(width, length, height, shape_type)

data/lib/rubocop/cop/kaizo_cops.rb

@@ -7,7 +7,9 @@ require_relative "kaizo/agent_noun_class_name"
 require_relative "kaizo/nested_method_calls"
 require_relative "kaizo/spec_comment"
 require_relative "kaizo/spec_description_prose"
+require_relative "kaizo/spec_subject"
 require_relative "kaizo/file_utils_inclusion"
 require_relative "kaizo/prefer_pathname"
 require_relative "kaizo/explicit_begin"
 require_relative "kaizo/next_in_non_void_enumerable"
+require_relative "kaizo/tempfile_create"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kaizo
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.2
 platform: ruby
 authors:
 - David Gillis
@@ -67,6 +67,8 @@ files:
 - lib/rubocop/cop/kaizo/prefer_pathname.rb
 - lib/rubocop/cop/kaizo/spec_comment.rb
 - lib/rubocop/cop/kaizo/spec_description_prose.rb
+- lib/rubocop/cop/kaizo/spec_subject.rb
+- lib/rubocop/cop/kaizo/tempfile_create.rb
 - lib/rubocop/cop/kaizo/total_arguments.rb
 - lib/rubocop/cop/kaizo_cops.rb
 homepage: https://github.com/flipmine/kaizo
@@ -91,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.17
+rubygems_version: 4.0.18
 specification_version: 4
 summary: A strict, punishing set of RuboCop design cops for AI-agent-authored Ruby.
 test_files: []