rubocop 0.93.1 → 1.79.2

data/lib/rubocop/cop/exclude_limit.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Allows specified configuration options to have an exclude limit
+  # ie. a maximum value tracked that it can be used by `--auto-gen-config`.
+  module ExcludeLimit
+    # Sets up a configuration option to have an exclude limit tracked.
+    # The parameter name given is transformed into a method name (eg. `Max`
+    # becomes `self.max=` and `MinDigits` becomes `self.min_digits=`).
+    def exclude_limit(parameter_name, method_name: transform(parameter_name))
+      define_method(:"#{method_name}=") do |value|
+        cfg = config_to_allow_offenses
+        cfg[:exclude_limit] ||= {}
+        current_max = cfg[:exclude_limit][parameter_name]
+        value = [current_max, value].max if current_max
+        cfg[:exclude_limit][parameter_name] = value
+      end
+    end
+
+    private
+
+    def transform(parameter_name)
+      parameter_name.gsub(/(?<!\A)(?=[A-Z])/, '_').downcase
+    end
+  end
+end

data/lib/rubocop/cop/force.rb

@@ -4,6 +4,16 @@ module RuboCop
   module Cop
     # A scaffold for concrete forces.
     class Force
+      # @api private
+      class HookError < StandardError
+        attr_reader :joining_cop
+
+        def initialize(joining_cop)
+          super
+          @joining_cop = joining_cop
+        end
+      end
+
       attr_reader :cops
 
       def self.all
@@ -31,7 +41,9 @@ module RuboCop
         cops.each do |cop|
           next unless cop.respond_to?(method_name)
 
-          cop.send(method_name, *args)
+          cop.public_send(method_name, *args)
+        rescue StandardError
+          raise HookError, cop
         end
       end
 

data/lib/rubocop/cop/gemspec/add_runtime_dependency.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Prefer `add_dependency` over `add_runtime_dependency` as the latter is
+      # considered soft-deprecated.
+      #
+      # @example
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.add_runtime_dependency('rubocop')
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_dependency('rubocop')
+      #   end
+      #
+      class AddRuntimeDependency < Base
+        extend AutoCorrector
+
+        MSG = 'Use `add_dependency` instead of `add_runtime_dependency`.'
+
+        RESTRICT_ON_SEND = %i[add_runtime_dependency].freeze
+
+        def on_send(node)
+          return if !node.receiver || node.arguments.empty?
+
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node.loc.selector, 'add_dependency')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/attribute_assignment.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Use consistent style for Gemspec attributes assignment.
+      #
+      # @example
+      #
+      #   # bad
+      #   # This example uses two styles for assignment of metadata attribute.
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = { 'key' => 'value' }
+      #     spec.metadata['another-key'] = 'another-value'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata['key'] = 'value'
+      #     spec.metadata['another-key'] = 'another-value'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = { 'key' => 'value', 'another-key' => 'another-value' }
+      #   end
+      #
+      #   # bad
+      #   # This example uses two styles for assignment of authors attribute.
+      #   Gem::Specification.new do |spec|
+      #     spec.authors = %w[author-0 author-1]
+      #     spec.authors[2] = 'author-2'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.authors = %w[author-0 author-1 author-2]
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.authors[0] = 'author-0'
+      #     spec.authors[1] = 'author-1'
+      #     spec.authors[2] = 'author-2'
+      #   end
+      #
+      #   # good
+      #   # This example uses consistent assignment per attribute,
+      #   # even though two different styles are used overall.
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = { 'key' => 'value' }
+      #     spec.authors[0] = 'author-0'
+      #     spec.authors[1] = 'author-1'
+      #     spec.authors[2] = 'author-2'
+      #   end
+      #
+      class AttributeAssignment < Base
+        include GemspecHelp
+
+        MSG = 'Use consistent style for Gemspec attributes assignment.'
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          assignments = source_assignments(processed_source.ast)
+          indexed_assignments = source_indexed_assignments(processed_source.ast)
+
+          assignments.keys.intersection(indexed_assignments.keys).each do |attribute|
+            indexed_assignments[attribute].each do |node|
+              add_offense(node)
+            end
+          end
+        end
+
+        private
+
+        def source_assignments(ast)
+          assignment_method_declarations(ast)
+            .select(&:assignment_method?)
+            .group_by(&:method_name)
+            .transform_keys { |method_name| method_name.to_s.delete_suffix('=').to_sym }
+        end
+
+        def source_indexed_assignments(ast)
+          indexed_assignment_method_declarations(ast)
+            .group_by { |node| node.children.first.method_name }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/dependency_version.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Enforce that gem dependency version specifications or a commit reference (branch,
+      # ref, or tag) are either required or forbidden.
+      #
+      # @example EnforcedStyle: required (default)
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.add_dependency 'parser'
+      #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.add_development_dependency 'parser'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_dependency 'parser', '>= 2.3.3.1', '< 3.0'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_development_dependency 'parser', '>= 2.3.3.1', '< 3.0'
+      #   end
+      #
+      # @example EnforcedStyle: forbidden
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.add_dependency 'parser', '>= 2.3.3.1', '< 3.0'
+      #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.add_development_dependency 'parser', '>= 2.3.3.1', '< 3.0'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_dependency 'parser'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_development_dependency 'parser'
+      #   end
+      #
+      class DependencyVersion < Base
+        include ConfigurableEnforcedStyle
+        include GemspecHelp
+
+        REQUIRED_MSG = 'Dependency version specification is required.'
+        FORBIDDEN_MSG = 'Dependency version specification is forbidden.'
+        VERSION_SPECIFICATION_REGEX = /^\s*[~<>=]*\s*[0-9.]+/.freeze
+
+        ADD_DEPENDENCY_METHODS = %i[
+          add_dependency add_runtime_dependency add_development_dependency
+        ].freeze
+        RESTRICT_ON_SEND = ADD_DEPENDENCY_METHODS
+
+        # @!method add_dependency_method_declaration?(node)
+        def_node_matcher :add_dependency_method_declaration?, <<~PATTERN
+          (send
+            (lvar #match_block_variable_name?) #add_dependency_method? ...)
+        PATTERN
+
+        # @!method includes_version_specification?(node)
+        def_node_matcher :includes_version_specification?, <<~PATTERN
+          (send _ #add_dependency_method? <(str #version_specification?) ...>)
+        PATTERN
+
+        # @!method includes_commit_reference?(node)
+        def_node_matcher :includes_commit_reference?, <<~PATTERN
+          (send _ #add_dependency_method? <(hash <(pair (sym {:branch :ref :tag}) (str _)) ...>) ...>)
+        PATTERN
+
+        def on_send(node)
+          return unless add_dependency_method_declaration?(node)
+          return if allowed_gem?(node)
+
+          if offense?(node)
+            add_offense(node)
+            opposite_style_detected
+          else
+            correct_style_detected
+          end
+        end
+
+        private
+
+        def allowed_gem?(node)
+          allowed_gems.include?(node.first_argument.str_content)
+        end
+
+        def allowed_gems
+          Array(cop_config['AllowedGems'])
+        end
+
+        def message(_range)
+          if required_style?
+            REQUIRED_MSG
+          elsif forbidden_style?
+            FORBIDDEN_MSG
+          end
+        end
+
+        def match_block_variable_name?(receiver_name)
+          gem_specification(processed_source.ast) do |block_variable_name|
+            return block_variable_name == receiver_name
+          end
+        end
+
+        def add_dependency_method?(method_name)
+          ADD_DEPENDENCY_METHODS.include?(method_name)
+        end
+
+        def offense?(node)
+          required_offense?(node) || forbidden_offense?(node)
+        end
+
+        def required_offense?(node)
+          return false unless required_style?
+
+          !includes_version_specification?(node) && !includes_commit_reference?(node)
+        end
+
+        def forbidden_offense?(node)
+          return false unless forbidden_style?
+
+          includes_version_specification?(node) || includes_commit_reference?(node)
+        end
+
+        def forbidden_style?
+          style == :forbidden
+        end
+
+        def required_style?
+          style == :required
+        end
+
+        def version_specification?(expression)
+          expression.match?(VERSION_SPECIFICATION_REGEX)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Checks that deprecated attributes are not set in a gemspec file.
+      # Removing deprecated attributes allows the user to receive smaller packed gems.
+      #
+      # @example
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'your_cool_gem_name'
+      #     spec.test_files = Dir.glob('test/**/*')
+      #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'your_cool_gem_name'
+      #     spec.test_files += Dir.glob('test/**/*')
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'your_cool_gem_name'
+      #   end
+      #
+      class DeprecatedAttributeAssignment < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Do not set `%<attribute>s` in gemspec.'
+
+        # @!method gem_specification(node)
+        def_node_matcher :gem_specification, <<~PATTERN
+          (block
+            (send
+              (const
+                (const {cbase nil?} :Gem) :Specification) :new)
+            ...)
+        PATTERN
+
+        def on_block(block_node)
+          return unless gem_specification(block_node)
+
+          block_parameter = block_node.first_argument.source
+
+          assignment = block_node.descendants.detect do |node|
+            use_deprecated_attributes?(node, block_parameter)
+          end
+          return unless assignment
+
+          message = format_message_from
+          add_offense(assignment, message: message) do |corrector|
+            range = range_by_whole_lines(assignment.source_range, include_final_newline: true)
+
+            corrector.remove(range)
+          end
+        end
+
+        private
+
+        def node_and_method_name(node, attribute)
+          if node.op_asgn_type?
+            [node.lhs, attribute]
+          else
+            [node, :"#{attribute}="]
+          end
+        end
+
+        def use_deprecated_attributes?(node, block_parameter)
+          %i[test_files date specification_version rubygems_version].each do |attribute|
+            node, method_name = node_and_method_name(node, attribute)
+            unless node.send_type? && node.receiver&.source == block_parameter &&
+                   node.method?(method_name)
+              next
+            end
+
+            @attribute = attribute.to_s
+            return true
+          end
+          false
+        end
+
+        def format_message_from
+          format(MSG, attribute: @attribute)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/development_dependencies.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Enforce that development dependencies for a gem are specified in
+      # `Gemfile`, rather than in the `gemspec` using
+      # `add_development_dependency`. Alternatively, using `EnforcedStyle:
+      # gemspec`, enforce that all dependencies are specified in `gemspec`,
+      # rather than in `Gemfile`.
+      #
+      # @example EnforcedStyle: Gemfile (default)
+      #   # Specify runtime dependencies in your gemspec,
+      #   # but all other dependencies in your Gemfile.
+      #
+      #   # bad
+      #   # example.gemspec
+      #   s.add_development_dependency "foo"
+      #
+      #   # good
+      #   # Gemfile
+      #   gem "foo"
+      #
+      #   # good
+      #   # gems.rb
+      #   gem "foo"
+      #
+      #   # good (with AllowedGems: ["bar"])
+      #   # example.gemspec
+      #   s.add_development_dependency "bar"
+      #
+      # @example EnforcedStyle: gems.rb
+      #   # Specify runtime dependencies in your gemspec,
+      #   # but all other dependencies in your Gemfile.
+      #   #
+      #   # Identical to `EnforcedStyle: Gemfile`, but with a different error message.
+      #   # Rely on Bundler/GemFilename to enforce the use of `Gemfile` vs `gems.rb`.
+      #
+      #   # bad
+      #   # example.gemspec
+      #   s.add_development_dependency "foo"
+      #
+      #   # good
+      #   # Gemfile
+      #   gem "foo"
+      #
+      #   # good
+      #   # gems.rb
+      #   gem "foo"
+      #
+      #   # good (with AllowedGems: ["bar"])
+      #   # example.gemspec
+      #   s.add_development_dependency "bar"
+      #
+      # @example EnforcedStyle: gemspec
+      #   # Specify all dependencies in your gemspec.
+      #
+      #   # bad
+      #   # Gemfile
+      #   gem "foo"
+      #
+      #   # good
+      #   # example.gemspec
+      #   s.add_development_dependency "foo"
+      #
+      #   # good (with AllowedGems: ["bar"])
+      #   # Gemfile
+      #   gem "bar"
+      #
+      class DevelopmentDependencies < Base
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Specify development dependencies in %<preferred>s.'
+        RESTRICT_ON_SEND = %i[add_development_dependency gem].freeze
+
+        # @!method add_development_dependency?(node)
+        def_node_matcher :add_development_dependency?, <<~PATTERN
+          (send _ :add_development_dependency (str #forbidden_gem? ...) _? _?)
+        PATTERN
+
+        # @!method gem?(node)
+        def_node_matcher :gem?, <<~PATTERN
+          (send _ :gem (str #forbidden_gem? ...))
+        PATTERN
+
+        def on_send(node)
+          case style
+          when :Gemfile, :'gems.rb'
+            add_offense(node) if add_development_dependency?(node)
+          when :gemspec
+            add_offense(node) if gem?(node)
+          end
+        end
+
+        private
+
+        def forbidden_gem?(gem_name)
+          !cop_config['AllowedGems'].include?(gem_name)
+        end
+
+        def message(_range)
+          format(MSG, preferred: style)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/duplicated_assignment.rb

@@ -6,10 +6,11 @@ module RuboCop
       # An attribute assignment method calls should be listed only once
       # in a gemspec.
       #
-      # Assigning to an attribute with the same name using `spec.foo =` will be
-      # an unintended usage. On the other hand, duplication of methods such
-      # as `spec.requirements`, `spec.add_runtime_dependency`, and others are
-      # permitted because it is the intended use of appending values.
+      # Assigning to an attribute with the same name using `spec.foo =` or
+      # `spec.attribute#[]=` will be an unintended usage. On the other hand,
+      # duplication of methods such # as `spec.requirements`,
+      # `spec.add_runtime_dependency`, and others are permitted because it is
+      # the intended use of appending values.
       #
       # @example
       #   # bad
@@ -31,72 +32,78 @@ module RuboCop
       #
       #   # good
       #   Gem::Specification.new do |spec|
-      #     spec.add_runtime_dependency('parallel', '~> 1.10')
-      #     spec.add_runtime_dependency('parser', '>= 2.3.3.1', '< 3.0')
+      #     spec.add_dependency('parallel', '~> 1.10')
+      #     spec.add_dependency('parser', '>= 2.3.3.1', '< 3.0')
       #   end
-      class DuplicatedAssignment < Cop
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata["key"] = "value"
+      #     spec.metadata["key"] = "value"
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata["key"] = "value"
+      #   end
+      #
+      class DuplicatedAssignment < Base
         include RangeHelp
+        include GemspecHelp
 
-        MSG = '`%<assignment>s` method calls already given on line '\
+        MSG = '`%<assignment>s` method calls already given on line ' \
               '%<line_of_first_occurrence>d of the gemspec.'
 
-        def_node_search :gem_specification, <<~PATTERN
-          (block
-            (send
-              (const
-                (const {cbase nil?} :Gem) :Specification) :new)
-            (args
-              (arg $_)) ...)
-        PATTERN
-
-        def_node_search :assignment_method_declarations, <<~PATTERN
-          (send
-            (lvar #match_block_variable_name?) #assignment_method? ...)
-        PATTERN
-
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
-          duplicated_assignment_method_nodes.each do |nodes|
-            nodes[1..-1].each do |node|
-              register_offense(
-                node,
-                node.method_name,
-                nodes.first.first_line
-              )
-            end
-          end
+          process_assignment_method_nodes
+          process_indexed_assignment_method_nodes
         end
 
         private
 
-        def match_block_variable_name?(receiver_name)
-          gem_specification(processed_source.ast) do |block_variable_name|
-            return block_variable_name == receiver_name
+        def process_assignment_method_nodes
+          duplicated_assignment_method_nodes.each do |nodes|
+            nodes[1..].each do |node|
+              register_offense(node, node.method_name, nodes.first.first_line)
+            end
           end
         end
 
-        def assignment_method?(method_name)
-          method_name.to_s.end_with?('=')
+        def process_indexed_assignment_method_nodes
+          duplicated_indexed_assignment_method_nodes.each do |nodes|
+            nodes[1..].each do |node|
+              assignment = "#{node.children.first.method_name}[#{node.first_argument.source}]="
+              register_offense(node, assignment, nodes.first.first_line)
+            end
+          end
         end
 
         def duplicated_assignment_method_nodes
           assignment_method_declarations(processed_source.ast)
+            .select(&:assignment_method?)
             .group_by(&:method_name)
             .values
             .select { |nodes| nodes.size > 1 }
         end
 
+        def duplicated_indexed_assignment_method_nodes
+          indexed_assignment_method_declarations(processed_source.ast)
+            .group_by { |node| [node.children.first.method_name, node.first_argument] }
+            .values
+            .select { |nodes| nodes.size > 1 }
+        end
+
         def register_offense(node, assignment, line_of_first_occurrence)
           line_range = node.loc.column...node.loc.last_column
-          offense_location =
-            source_range(processed_source.buffer, node.first_line, line_range)
+          offense_location = source_range(processed_source.buffer, node.first_line, line_range)
           message = format(
             MSG,
             assignment: assignment,
             line_of_first_occurrence: line_of_first_occurrence
           )
-          add_offense(node, location: offense_location, message: message)
+          add_offense(offense_location, message: message)
         end
       end
     end