rubocop-vicenzo 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5b813b05ed3c69c557d8b01bb90a4f142cbbb4ff06240d2df571f23ca5b720b
-  data.tar.gz: c121942b02a939b96de5a264fd53db21ebba6dd85e85c9e95424538e59c5240c
+  metadata.gz: 4f7a8f58f53c6f2e6b50f1645a55cb401cd33b1f2654c793eaecd52cbf879153
+  data.tar.gz: f2eaba7a6bbb615190abf109a64681372988e3f8cea255c6055f6ae40698c7e2
 SHA512:
-  metadata.gz: 3d6832e1b1d8a011f1ded3b21451e79f1722234bd7424ccf418a59550a79b20edd4b8a3632345df748982b356b32d868d530fe96267ce5b81689f32d8e9559ae
-  data.tar.gz: b2513e3ab2f35243a88029d8f08ff2bd1bd29c08552c305e919cb76b10717e113cccf837276bc77b390bb87b5f34b276b08415adc1fd64c05566028107f65471
+  metadata.gz: '0258853f6e8d32fb88d7d4c53fb5520e2c828bd31d5968be91008ab34c13a729188c802e91539ef95eef937c56dc584cb59c7dbb9ddcc8c50e3cd6e991eb49a1'
+  data.tar.gz: c8a4a8d41af0c5d5f294acfd9361f1226f002590b051508b97a6fbcb9f3f36dbe695a6ae6efbccb7c122395bc9dd76e83f7cffc9a026f3d822954e20236483df

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.9.0"
+  ".": "0.10.0"
 }

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.10.0](https://github.com/bvicenzo/rubocop-vicenzo/compare/v0.9.0...v0.10.0) (2026-10-23)
+
+
+### Features
+
+* add Vicenzo/RSpec/LetAliasingSubject cop ([#44](https://github.com/bvicenzo/rubocop-vicenzo/issues/44)) ([a8cebd3](https://github.com/bvicenzo/rubocop-vicenzo/commit/a8cebd3c0237e8805a58ff9efa7ca34f6beb34b0)), closes [#42](https://github.com/bvicenzo/rubocop-vicenzo/issues/42)
+* add Vicenzo/Style/PreferManyOverSizeComparison cop ([#38](https://github.com/bvicenzo/rubocop-vicenzo/issues/38)) ([910ea02](https://github.com/bvicenzo/rubocop-vicenzo/commit/910ea026f7e4c46f9de27db580e6330cf845bfe7))
+
+
+### Bug Fixes
+
+* report subjects that derive from an allowed method in SubjectIsMethodResult ([#41](https://github.com/bvicenzo/rubocop-vicenzo/issues/41)) ([a5efd33](https://github.com/bvicenzo/rubocop-vicenzo/commit/a5efd3330b32dd24b4291121a64e378091297a57)), closes [#40](https://github.com/bvicenzo/rubocop-vicenzo/issues/40)
+* see subjects declared in shared groups in LetIsMethodResult and LetAliasingSubject ([#45](https://github.com/bvicenzo/rubocop-vicenzo/issues/45)) ([a98039e](https://github.com/bvicenzo/rubocop-vicenzo/commit/a98039e2cbea568267d8b7832b4717b763678d14)), closes [#43](https://github.com/bvicenzo/rubocop-vicenzo/issues/43)
+
 ## [0.9.0](https://github.com/bvicenzo/rubocop-vicenzo/compare/v0.8.0...v0.9.0) (2026-09-23)
 
 

data/README.md

@@ -11,7 +11,7 @@ Add it to the `development`/`test` group of your `Gemfile`:
 <!-- x-release-please-start-version -->
 ```ruby
 group :development, :test do
-  gem 'rubocop-vicenzo', '~> 0.9.0', require: false
+  gem 'rubocop-vicenzo', '~> 0.10.0', require: false
 end
 ```
 <!-- x-release-please-end-version -->

data/config/default.yml

@@ -127,6 +127,17 @@ Vicenzo/RSpec/LeakyDefinition:
     - '**/spec/support/**/*'
     - '**/spec/factories/**/*'
 
+Vicenzo/RSpec/LetAliasingSubject:
+  Description: 'A let must not hold the subject itself under another name.'
+  Enabled: true
+  Severity: convention
+  Include:
+    - '**/spec/**/*_spec.rb'
+  Exclude:
+    - '**/spec/support/**/*'
+    - '**/spec/factories/**/*'
+  VersionAdded: '0.10.0'
+
 Vicenzo/RSpec/LetIsMethodResult:
   Description: 'A let under an example group describing a method must not hold the result of calling that method on the subject.'
   Enabled: true
@@ -244,3 +255,10 @@ Vicenzo/Style/MultilineMethodCallParentheses:
   Enabled: true
   AllowedMethods: []
   VersionAdded: '0.3.0'
+
+Vicenzo/Style/PreferManyOverSizeComparison:
+  Description: 'Use many? instead of comparing size or length with one.'
+  Enabled: true
+  Severity: convention
+  SafeAutoCorrect: false
+  VersionAdded: '0.10.0'

data/lib/rubocop/cop/vicenzo/rspec/let_aliasing_subject.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative 'returned_chain'
+require_relative 'mixin/premise_tracking'
+require_relative 'mixin/subject_reference'
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module RSpec
+        # A `let` whose value is the subject itself is the subject under another name. Refer to the subject by
+        # its own name instead.
+        #
+        # The subject is who the sentences are about. A second name for it splits that across two
+        # declarations: the examples reading `hunter` no longer say they are about the subject, and every cop
+        # that recognises the subject by its name stops recognising it there. In "the cat caught the ball",
+        # calling the cat `hunter` in half of the sentences does not add a character - it hides one.
+        #
+        # A subject that was declared without a name and is then given one by a `let` is the same thing the
+        # other way round: the name belongs to the subject's declaration, `subject(:hunter) { ... }`. Inside a
+        # shared group that declares no named subject, the declaration lives where the group is included, so
+        # the subject is referred to as `subject`.
+        #
+        # This composes with `Vicenzo/RSpec/LetIsMethodResult`: once the alias is gone, a `let` that called
+        # the described method through it calls it on the subject, and that cop reports it.
+        #
+        # Only a value that is the subject and nothing more counts. A `let` deriving something from the
+        # subject, such as `cat.name`, is a premise, not an alias.
+        #
+        # @example
+        #   # bad - `hunter` is the cat
+        #   describe '#catch' do
+        #     subject(:cat) { Cat.new(name: 'Bixano') }
+        #
+        #     let(:hunter) { cat }
+        #
+        #     it { expect(hunter.catch(object: Ball.new)).to eq(:success) }
+        #   end
+        #
+        #   # good - one name for the subject
+        #   describe '#catch' do
+        #     subject(:cat) { Cat.new(name: 'Bixano') }
+        #
+        #     it { expect(cat.catch(object: Ball.new)).to eq(:success) }
+        #   end
+        #
+        # @example an anonymous subject named by a let
+        #   # bad - the name belongs to the subject's declaration
+        #   describe '#catch' do
+        #     subject { Cat.new(name: 'Bixano') }
+        #
+        #     let(:hunter) { subject }
+        #   end
+        #
+        #   # good
+        #   describe '#catch' do
+        #     subject(:hunter) { Cat.new(name: 'Bixano') }
+        #   end
+        #
+        # @example a shared group naming the subject of whoever includes it
+        #   # bad - the subject is declared where the group is included, under a name it cannot know
+        #   shared_examples 'a hunter' do
+        #     let(:hunter) { subject }
+        #
+        #     it { expect(hunter.catch(object: Ball.new)).to eq(:success) }
+        #   end
+        #
+        #   # good - `subject` holds wherever the group is included
+        #   shared_examples 'a hunter' do
+        #     it { expect(subject.catch(object: Ball.new)).to eq(:success) }
+        #   end
+        class LetAliasingSubject < RuboCop::Cop::RSpec::Base
+          include PremiseTracking
+          include SubjectReference
+
+          MSG = 'Let `:%<name>s` is the subject under another name. Refer to the subject as `%<subject>s`.'
+          UNNAMED_MSG = 'Let `:%<name>s` is the subject under another name. Name the subject `%<name>s` instead.'
+
+          def on_block(node)
+            return unless let?(node)
+
+            reference = sole_call(node.body)
+            return unless reference
+
+            names = subject_names(node)
+            return unless subject_reference?(reference, names)
+
+            add_offense(node.send_node, message: message(node, reference.method_name, names))
+          end
+
+          alias on_numblock on_block
+          alias on_itblock on_block
+
+          private
+
+          def sole_call(body)
+            calls = ReturnedChain.new(body).to_a
+
+            calls.first if calls.one?
+          end
+
+          # `subject` points at the nearest named subject when there is one; without it, the alias is the name
+          # the subject was missing. Inside a shared group the subject is declared where the group is included,
+          # under a name this group cannot know, so `subject` is the one name that holds everywhere.
+          def message(node, reference_name, names)
+            name = premise_name(node)
+            subject = reference_name == :subject ? names.find { |candidate| candidate != :subject } : reference_name
+            return format(MSG, name:, subject:) if subject
+            return format(MSG, name:, subject: :subject) if inside_shared_group?(node)
+
+            format(UNNAMED_MSG, name:)
+          end
+
+          def inside_shared_group?(node)
+            node.each_ancestor(:any_block).any? { |ancestor| shared_group?(ancestor) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vicenzo/rspec/let_is_method_result.rb

@@ -2,6 +2,7 @@
 
 require_relative 'mixin/described_method'
 require_relative 'mixin/premise_tracking'
+require_relative 'mixin/subject_reference'
 
 module RuboCop
   module Cop
@@ -21,8 +22,10 @@ module RuboCop
         #
         # Only calls on the subject count, which is what separates the result from the setup: a `let`
         # calling the described method on some other object is building a premise, not the outcome the
-        # example is about. `AllowedMethods` is shared with the sibling cop and ships empty, for the
-        # layers whose convention is a single entry point.
+        # example is about. A `let` that only renames the subject is `Vicenzo/RSpec/LetAliasingSubject`'s
+        # to report; once it is gone, the call goes through the subject's own name and is reported here.
+        # `AllowedMethods` is shared with the sibling cop and ships empty, for the layers whose convention
+        # is a single entry point.
         #
         # @example
         #   # bad - the expectation asserts on a name; the cat never catches anything in the example
@@ -51,6 +54,7 @@ module RuboCop
         class LetIsMethodResult < RuboCop::Cop::RSpec::Base
           include DescribedMethod
           include PremiseTracking
+          include SubjectReference
 
           MSG = 'Let `:%<name>s` holds what `%<method>s` returned. Undo it and call `%<method>s` on the ' \
                 'subject inside the expectation.'
@@ -72,39 +76,16 @@ module RuboCop
 
           private
 
+          # The receiver is read from the chain itself, the call right after the invocation, so that a subject
+          # passed along through a local variable or parentheses is still the subject.
           def invocation_on_subject(node, method_name)
             names = subject_names(node)
 
-            call_in_chain(node.body) do |call|
-              call.method?(method_name) && subject_reference?(call.receiver, names)
+            call, = ReturnedChain.new(node.body).each_cons(2).find do |invocation, receiver|
+              invocation.method?(method_name) && subject_reference?(receiver, names)
             end
-          end
-
-          # `subject` always refers to the subject, declared or implicit; a named one answers to its name
-          # as well.
-          def subject_names(node)
-            names = Set[:subject]
-
-            node.each_ancestor(:any_block).each do |ancestor|
-              next unless example_group?(ancestor)
-
-              each_child_block(ancestor) { |child| names << subject_name(child) if subject?(child) }
-            end
-
-            names
-          end
-
-          # An anonymous `subject!` is still read as `subject`.
-          def subject_name(node)
-            name = premise_name(node).to_sym
-
-            name == :subject! ? :subject : name
-          end
-
-          def subject_reference?(receiver, names)
-            return false unless receiver&.send_type? && receiver.receiver.nil? && receiver.arguments.empty?
 
-            names.include?(receiver.method_name)
+            call
           end
         end
       end

data/lib/rubocop/cop/vicenzo/rspec/mixin/described_method.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../returned_chain'
+
 module RuboCop
   module Cop
     module Vicenzo
@@ -42,27 +44,11 @@ module RuboCop
             cop_config.fetch('AllowedMethods', [])
           end
 
-          # Walks the expression a definition returns down its receiver chain, yielding each call, so that
-          # `Cat.new.catch(ball).to_s` is seen as built on `catch` while `Cat.new(catches: other.catch)`
-          # is not - there, nothing of `catch` reaches the value.
-          def call_in_chain(body)
-            node = returned_expression(body)
-
-            while node
-              node = node.send_node if node.any_block_type?
-              break unless node.type?(:call)
-              return node if yield(node)
-
-              node = node.receiver
-            end
-
-            nil
-          end
-
-          def returned_expression(body)
-            return if body.nil?
-
-            body.begin_type? ? body.children.last : body
+          # The first call the value of a definition is built on that satisfies the block, seen from the outside in:
+          # `Cat.new.catch(ball).to_s` is built on `catch` while `Cat.new(catches: other.catch)` is not - there,
+          # nothing of `catch` reaches the value. See `ReturnedChain`.
+          def call_in_chain(body, &)
+            ReturnedChain.new(body).find(&)
           end
         end
       end

data/lib/rubocop/cop/vicenzo/rspec/mixin/subject_reference.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module RSpec
+        # Shared helpers for the cops that ask whether a definition reads the subject: which names answer to it
+        # where the definition sits, and whether a call is a bare reference to one of them.
+        #
+        # Meant for cops inheriting from `RuboCop::Cop::RSpec::Base` and including `PremiseTracking`:
+        # `spec_group?` and `subject?` come from the former, `each_child_block` and `premise_name` from the
+        # latter.
+        module SubjectReference
+          private
+
+          # `subject` always refers to the subject, declared or implicit; a named one answers to its name
+          # as well. A definition is read in every group below the one declaring it, so the subjects
+          # declared down there - the "abstract let" shape - answer too. Names come nearest group first, after
+          # `subject`.
+          #
+          # Shared groups count as groups, around the definition and below it: RSpec only lets a shared group
+          # be included under the group defining it, and a subject declared in one is the subject wherever it
+          # is included.
+          def subject_names(node)
+            names = Set[:subject]
+            groups = node.each_ancestor(:any_block).select { |ancestor| spec_group?(ancestor) }
+
+            collect_subject_names(groups.first, names, nested: true) if groups.any?
+            groups.drop(1).each { |group| collect_subject_names(group, names) }
+
+            names
+          end
+
+          def collect_subject_names(group, names, nested: false)
+            each_child_block(group) do |child|
+              if subject?(child)
+                names << subject_name(child)
+              elsif nested && spec_group?(child)
+                collect_subject_names(child, names, nested:)
+              end
+            end
+          end
+
+          # An anonymous `subject!` is still read as `subject`, so it never passes for a name the subject was
+          # given.
+          def subject_name(node)
+            name = premise_name(node).to_sym
+
+            name == :subject! ? :subject : name
+          end
+
+          def subject_reference?(receiver, names)
+            return false unless receiver.send_type? && receiver.receiver.nil? && receiver.arguments.empty?
+
+            names.include?(receiver.method_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vicenzo/rspec/returned_chain.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module RSpec
+        # The calls the value of a block body is built on, outermost first: `Cat.new.catch(ball).to_s` yields `to_s`,
+        # `catch` and `new`, while `Cat.new(catches: other.catch)` yields only `new` - nothing of `catch` reaches the
+        # value.
+        #
+        # The walk starts at the statement the body returns and follows its receivers, seeing through what only
+        # passes a value along: parentheses, an assignment, and a local variable, which answers to its latest
+        # assignment among the statements before the one reading it.
+        class ReturnedChain
+          include Enumerable
+
+          attr_reader :expression
+
+          def initialize(body)
+            @statements = statements_of(body)
+            @expression = @statements.last
+          end
+
+          def each
+            node = expression
+            reach = @statements.size - 1
+
+            while node
+              node, reach = value_of(node, reach)
+              node = node.send_node if node&.any_block_type?
+              break unless node&.type?(:call)
+
+              yield node
+              node = node.receiver
+            end
+          end
+
+          private
+
+          def statements_of(body)
+            return [] if body.nil?
+
+            body.begin_type? ? body.children : [body]
+          end
+
+          # `reach` is the index of the statement the node is read in: a variable only answers to an assignment made
+          # before it, which keeps `caught = caught.to_s` from answering to itself.
+          def value_of(node, reach)
+            loop do
+              case node&.type
+              when :begin then node = node.children.last
+              when :lvasgn then node = node.expression
+              when :lvar
+                reach = assignment_before(node.name, reach)
+                node = reach && @statements[reach]
+              else return [node, reach]
+              end
+            end
+          end
+
+          def assignment_before(name, reach)
+            (reach - 1).downto(0).find do |index|
+              statement = @statements[index]
+              statement.lvasgn_type? && statement.name == name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vicenzo/rspec/subject_is_method_result.rb

@@ -24,7 +24,11 @@ module RuboCop
         # (a service object always invoked through `call`, for instance). `AllowedMethods` exists
         # for those and ships empty: the convention belongs to the project that adopts it, not to
         # this gem. Declaring it there - or excluding a whole directory through the standard
-        # `Exclude` - keeps the exemption visible and reviewable in `.rubocop.yml`.
+        # `Exclude` - keeps the exemption visible and reviewable in `.rubocop.yml`. The exemption
+        # covers the result itself, not what is derived from it: a subject that chains anything
+        # after the allowed call - a projection such as `map`, or unwrapping a monad through
+        # `value` - is still reported, since it drops the data the examples end up calling the
+        # method again to reach.
         #
         # An inline disable directive is not that: it is an exemption nobody reviewed. Dropping
         # the `#` from the description is not either - the cop reads bare descriptions too, and the
@@ -59,26 +63,54 @@ module RuboCop
         #   describe '.call' do
         #     subject(:result) { described_class.(object: Ball.new) }
         #   end
+        #
+        #   # bad - the subject is derived from the result, not the result itself
+        #   describe '.call' do
+        #     subject(:ids) { described_class.().map(&:id) }
+        #   end
+        #
+        #   # bad - unwrapping the monad keeps only a part of the result
+        #   describe '.call' do
+        #     subject(:value) { described_class.(object: Ball.new).value }
+        #   end
         class SubjectIsMethodResult < RuboCop::Cop::RSpec::Base
           include DescribedMethod
 
           MSG = 'Subject holds what `%<method>s` returned, not the object under test. ' \
                 'Make the subject the object that receives `%<method>s`, and call it inside the example.'
+          DERIVED_MSG = 'Subject derives from what `%<method>s` returned. ' \
+                        'Keep the subject as the result of `%<method>s`, and derive from it inside the example.'
 
           def on_block(node)
             return unless subject?(node)
 
             method_name = described_method_name(node)
-            return if method_name.nil? || allowed_methods.include?(method_name)
+            return if method_name.nil?
 
-            invocation = call_in_chain(node.body) { |call| call.method?(method_name) }
-            return unless invocation
+            chain = ReturnedChain.new(node.body)
+            invocations = chain.select { |call| call.method?(method_name) }
+            return if invocations.empty?
 
-            add_offense(invocation, message: format(MSG, method: method_name))
+            if allowed_methods.include?(method_name)
+              check_derivation(chain, invocations.last, method_name)
+            else
+              add_offense(invocations.first, message: format(MSG, method: method_name))
+            end
           end
 
           alias on_numblock on_block
           alias on_itblock on_block
+
+          private
+
+          # An allowed method may be the subject only as the returned expression itself: its innermost
+          # invocation has to be the outermost call of the chain. A block handed to it still belongs to the
+          # call; anything chained after it - calling the result again included - does not.
+          def check_derivation(chain, innermost_invocation, method_name)
+            return if chain.first.equal?(innermost_invocation)
+
+            add_offense(chain.expression, message: format(DERIVED_MSG, method: method_name))
+          end
         end
       end
     end

data/lib/rubocop/cop/vicenzo/style/prefer_many_over_size_comparison.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module Style
+        # Enforces `many?` over comparing `size` or `length` with one.
+        #
+        # Active Support's `Enumerable#many?` exists precisely to name the
+        # "more than one element" question that `size > 1` only spells out.
+        # RuboCop's own `Style/CollectionQuerying` already covers `count > 1`, but
+        # leaves `size` and `length` alone, which is the form most often written.
+        # This cop closes that gap.
+        #
+        # Only an explicit receiver calling `size` or `length` without arguments is
+        # flagged, compared with one through `>` or with two through `>=`, on
+        # either side of the operator. Like `Style/CollectionQuerying`, the cop
+        # only runs when `AllCops: ActiveSupportExtensionsEnabled` is on, since
+        # `many?` comes from Active Support. `rubocop-rails` turns it on.
+        #
+        # @safety
+        #   The cop is unsafe because the receiver might not include `Enumerable`.
+        #   `String`, for instance, responds to `size` and `length` but not to
+        #   `many?`. The same holds for any object with its own `count`, which is
+        #   why `Style/CollectionQuerying` is unsafe as well.
+        #
+        # @example
+        #   # bad
+        #   items.size > 1
+        #   items.length >= 2
+        #   1 < items.size
+        #
+        #   # good
+        #   items.many?
+        class PreferManyOverSizeComparison < Base
+          extend AutoCorrector
+
+          MSG = 'Use `many?` instead of `%<comparison>s`.'
+
+          RESTRICT_ON_SEND = %i[> >= < <=].freeze
+
+          # @!method size_comparison(node)
+          def_node_matcher :size_comparison, <<~PATTERN
+            {
+              (call $(call !nil? {:size :length}) {:> (int 1) | :>= (int 2)})
+              (call {(int 1) :< | (int 2) :<=} $(call !nil? {:size :length}))
+            }
+          PATTERN
+
+          def on_send(node)
+            return unless active_support_extensions_enabled?
+            return unless (size_node = size_comparison(node))
+
+            message = format(MSG, comparison: comparison_source(node, size_node))
+
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, "#{size_node.receiver.source}#{size_node.loc.dot.source}many?")
+            end
+          end
+          alias on_csend on_send
+
+          private
+
+          def comparison_source(node, size_node)
+            size_source = size_node.method_name
+
+            if node.receiver.equal?(size_node)
+              "#{size_source} #{node.method_name} #{node.first_argument.source}"
+            else
+              "#{node.receiver.source} #{node.method_name} #{size_source}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vicenzo_cops.rb

@@ -13,6 +13,7 @@ require_relative 'vicenzo/rspec/nested_context_improper_start'
 require_relative 'vicenzo/rspec/nested_let_redefinition'
 require_relative 'vicenzo/rspec/nested_subject_redefinition'
 require_relative 'vicenzo/rspec/leaky_definition'
+require_relative 'vicenzo/rspec/let_aliasing_subject'
 require_relative 'vicenzo/rspec/subject_defined_as_let'
 require_relative 'vicenzo/rspec/subject_is_method_result'
 require_relative 'vicenzo/rspec/top_level_context'
@@ -27,3 +28,4 @@ require_relative 'vicenzo/naming/anonymous_unused_name'
 require_relative 'vicenzo/naming/short_name'
 require_relative 'vicenzo/style/json_parse_symbolize_names'
 require_relative 'vicenzo/style/multiline_method_call_parentheses'
+require_relative 'vicenzo/style/prefer_many_over_size_comparison'

data/lib/rubocop/vicenzo/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Vicenzo
-    VERSION = '0.9.0'
+    VERSION = '0.10.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-vicenzo
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Bruno Vicenzo
@@ -86,15 +86,18 @@ files:
 - lib/rubocop/cop/vicenzo/rspec/inconsistent_sibling_structure.rb
 - lib/rubocop/cop/vicenzo/rspec/iteration_inside_example.rb
 - lib/rubocop/cop/vicenzo/rspec/leaky_definition.rb
+- lib/rubocop/cop/vicenzo/rspec/let_aliasing_subject.rb
 - lib/rubocop/cop/vicenzo/rspec/let_is_method_result.rb
 - lib/rubocop/cop/vicenzo/rspec/mixin/described_method.rb
 - lib/rubocop/cop/vicenzo/rspec/mixin/expectation_target.rb
 - lib/rubocop/cop/vicenzo/rspec/mixin/premise_tracking.rb
+- lib/rubocop/cop/vicenzo/rspec/mixin/subject_reference.rb
 - lib/rubocop/cop/vicenzo/rspec/mixin/top_level_definition.rb
 - lib/rubocop/cop/vicenzo/rspec/mutated_premises.rb
 - lib/rubocop/cop/vicenzo/rspec/nested_context_improper_start.rb
 - lib/rubocop/cop/vicenzo/rspec/nested_let_redefinition.rb
 - lib/rubocop/cop/vicenzo/rspec/nested_subject_redefinition.rb
+- lib/rubocop/cop/vicenzo/rspec/returned_chain.rb
 - lib/rubocop/cop/vicenzo/rspec/subject_defined_as_let.rb
 - lib/rubocop/cop/vicenzo/rspec/subject_is_method_result.rb
 - lib/rubocop/cop/vicenzo/rspec/top_level_context.rb
@@ -105,6 +108,7 @@ files:
 - lib/rubocop/cop/vicenzo/rspec/unnested_context_improper_start.rb
 - lib/rubocop/cop/vicenzo/style/json_parse_symbolize_names.rb
 - lib/rubocop/cop/vicenzo/style/multiline_method_call_parentheses.rb
+- lib/rubocop/cop/vicenzo/style/prefer_many_over_size_comparison.rb
 - lib/rubocop/cop/vicenzo_cops.rb
 - lib/rubocop/vicenzo.rb
 - lib/rubocop/vicenzo/plugin.rb