rubocop 0.78.0 → 1.13.0

data/lib/rubocop/cop/bundler/duplicated_gem.rb

@@ -25,13 +25,23 @@ module RuboCop
       #
       #   # good
       #   gem 'rubocop', groups: [:development, :test]
-      class DuplicatedGem < Cop
+      #
+      #   # good - conditional declaration
+      #   if Dir.exist?(local)
+      #     gem 'rubocop', path: local
+      #   elsif ENV['RUBOCOP_VERSION'] == 'master'
+      #     gem 'rubocop', git: 'https://github.com/rubocop/rubocop.git'
+      #   else
+      #     gem 'rubocop', '~> 0.90.0'
+      #   end
+      #
+      class DuplicatedGem < Base
         include RangeHelp
 
         MSG = 'Gem `%<gem_name>s` requirements already given on line '\
           '%<line_of_first_occurrence>d of the Gemfile.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
           duplicated_gem_nodes.each do |nodes|
@@ -47,25 +57,39 @@ module RuboCop
 
         private
 
+        # @!method gem_declarations(node)
         def_node_search :gem_declarations, '(send nil? :gem str ...)'
 
         def duplicated_gem_nodes
           gem_declarations(processed_source.ast)
             .group_by(&:first_argument)
             .values
-            .select { |nodes| nodes.size > 1 }
+            .select { |nodes| nodes.size > 1 && !conditional_declaration?(nodes) }
+        end
+
+        def conditional_declaration?(nodes)
+          parent = nodes[0].parent
+          return false unless parent&.if_type? || parent&.when_type?
+
+          root_conditional_node = parent.if_type? ? parent : parent.parent
+          nodes.all? { |node| within_conditional?(node, root_conditional_node) }
+        end
+
+        def within_conditional?(node, conditional_node)
+          conditional_node.branches.any? do |branch|
+            branch == node || branch.child_nodes.include?(node)
+          end
         end
 
         def register_offense(node, gem_name, 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,
             gem_name: gem_name,
             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

data/lib/rubocop/cop/bundler/gem_comment.rb

@@ -3,9 +3,37 @@
 module RuboCop
   module Cop
     module Bundler
-      # Add a comment describing each gem in your Gemfile.
+      # Each gem in the Gemfile should have a comment explaining
+      # its purpose in the project, or the reason for its version
+      # or source.
       #
-      # @example
+      # The optional "OnlyFor" configuration array
+      # can be used to only register offenses when the gems
+      # use certain options or have version specifiers.
+      #
+      # When "version_specifiers" is included, a comment
+      # will be enforced if the gem has any version specifier.
+      #
+      # When "restrictive_version_specifiers" is included, a comment
+      # will be enforced if the gem has a version specifier that
+      # holds back the version of the gem.
+      #
+      # For any other value in the array, a comment will be enforced for
+      # a gem if an option by the same name is present.
+      # A useful use case is to enforce a comment when using
+      # options that change the source of a gem:
+      #
+      # - `bitbucket`
+      # - `gist`
+      # - `git`
+      # - `github`
+      # - `source`
+      #
+      # For a full list of options supported by bundler,
+      # see https://bundler.io/man/gemfile.5.html
+      # .
+      #
+      # @example OnlyFor: [] (default)
       #   # bad
       #
       #   gem 'foo'
@@ -15,23 +43,71 @@ module RuboCop
       #   # Helpers for the foo things.
       #   gem 'foo'
       #
-      class GemComment < Cop
+      # @example OnlyFor: ['version_specifiers']
+      #   # bad
+      #
+      #   gem 'foo', '< 2.1'
+      #
+      #   # good
+      #
+      #   # Version 2.1 introduces breaking change baz
+      #   gem 'foo', '< 2.1'
+      #
+      # @example OnlyFor: ['restrictive_version_specifiers']
+      #   # bad
+      #
+      #   gem 'foo', '< 2.1'
+      #
+      #   # good
+      #
+      #   gem 'foo', '>= 1.0'
+      #
+      #   # Version 2.1 introduces breaking change baz
+      #   gem 'foo', '< 2.1'
+      #
+      # @example OnlyFor: ['version_specifiers', 'github']
+      #   # bad
+      #
+      #   gem 'foo', github: 'some_account/some_fork_of_foo'
+      #
+      #   gem 'bar', '< 2.1'
+      #
+      #   # good
+      #
+      #   # Using this fork because baz
+      #   gem 'foo', github: 'some_account/some_fork_of_foo'
+      #
+      #   # Version 2.1 introduces breaking change baz
+      #   gem 'bar', '< 2.1'
+      #
+      class GemComment < Base
         include DefNode
 
         MSG = 'Missing gem description comment.'
+        CHECKED_OPTIONS_CONFIG = 'OnlyFor'
+        VERSION_SPECIFIERS_OPTION = 'version_specifiers'
+        RESTRICTIVE_VERSION_SPECIFIERS_OPTION = 'restrictive_version_specifiers'
+        RESTRICTIVE_VERSION_PATTERN = /<|~>/.freeze
+        RESTRICT_ON_SEND = %i[gem].freeze
 
+        # @!method gem_declaration?(node)
         def_node_matcher :gem_declaration?, '(send nil? :gem str ...)'
 
         def on_send(node)
           return unless gem_declaration?(node)
           return if ignored_gem?(node)
-          return if commented?(node)
+          return if commented_any_descendant?(node)
+          return if cop_config[CHECKED_OPTIONS_CONFIG].any? && !checked_options_present?(node)
 
           add_offense(node)
         end
 
         private
 
+        def commented_any_descendant?(node)
+          commented?(node) || node.each_descendant.any? { |n| commented?(n) }
+        end
+
         def commented?(node)
           preceding_lines = preceding_lines(node)
           preceding_comment?(node, preceding_lines.last)
@@ -40,24 +116,57 @@ module RuboCop
         # The args node1 & node2 may represent a RuboCop::AST::Node
         # or a Parser::Source::Comment. Both respond to #loc.
         def precede?(node1, node2)
-          node2.loc.line - node1.loc.line == 1
+          node2.loc.line - node1.loc.line <= 1
         end
 
         def preceding_lines(node)
           processed_source.ast_with_comments[node].select do |line|
-            line.loc.line < node.loc.line
+            line.loc.line <= node.loc.line
           end
         end
 
         def preceding_comment?(node1, node2)
-          node1 && node2 && precede?(node2, node1) &&
-            comment_line?(node2.loc.expression.source)
+          node1 && node2 && precede?(node2, node1) && comment_line?(node2.loc.expression.source)
         end
 
         def ignored_gem?(node)
           ignored_gems = Array(cop_config['IgnoredGems'])
           ignored_gems.include?(node.first_argument.value)
         end
+
+        def checked_options_present?(node)
+          (cop_config[CHECKED_OPTIONS_CONFIG].include?(VERSION_SPECIFIERS_OPTION) &&
+            version_specified_gem?(node)) ||
+            (cop_config[CHECKED_OPTIONS_CONFIG].include?(RESTRICTIVE_VERSION_SPECIFIERS_OPTION) &&
+              restrictive_version_specified_gem?(node)) ||
+            contains_checked_options?(node)
+        end
+
+        # Besides the gem name, all other *positional* arguments to `gem` are version specifiers,
+        # as long as it has one we know there's at least one version specifier.
+        def version_specified_gem?(node)
+          # arguments[0] is the gem name
+          node.arguments[1]&.str_type?
+        end
+
+        # Version specifications that restrict all updates going forward. This excludes versions
+        # like ">= 1.0" or "!= 2.0.3".
+        def restrictive_version_specified_gem?(node)
+          return unless version_specified_gem?(node)
+
+          node.arguments
+              .any? { |arg| arg&.str_type? && RESTRICTIVE_VERSION_PATTERN.match?(arg.to_s) }
+        end
+
+        def contains_checked_options?(node)
+          (Array(cop_config[CHECKED_OPTIONS_CONFIG]) & gem_options(node).map(&:to_s)).any?
+        end
+
+        def gem_options(node)
+          return [] unless node.arguments.last&.type == :hash
+
+          node.arguments.last.keys.map(&:value)
+        end
       end
     end
   end

data/lib/rubocop/cop/bundler/insecure_protocol_source.rb

@@ -25,44 +25,37 @@ module RuboCop
       #   # good
       #   source 'https://rubygems.org' # strongly recommended
       #   source 'http://rubygems.org'
-      class InsecureProtocolSource < Cop
+      class InsecureProtocolSource < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'The source `:%<source>s` is deprecated because HTTP requests ' \
               'are insecure. ' \
               "Please change your source to 'https://rubygems.org' " \
               "if possible, or 'http://rubygems.org' if not."
 
+        RESTRICT_ON_SEND = %i[source].freeze
+
+        # @!method insecure_protocol_source?(node)
         def_node_matcher :insecure_protocol_source?, <<~PATTERN
           (send nil? :source
-            (sym ${:gemcutter :rubygems :rubyforge}))
+            $(sym ${:gemcutter :rubygems :rubyforge}))
         PATTERN
 
         def on_send(node)
-          insecure_protocol_source?(node) do |source|
+          insecure_protocol_source?(node) do |source_node, source|
             message = format(MSG, source: source)
 
             add_offense(
-              node,
-              location: range(node.first_argument.loc.expression),
+              source_node,
               message: message
-            )
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(
-              node.first_argument.loc.expression, "'https://rubygems.org'"
-            )
+            ) do |corrector|
+              corrector.replace(
+                source_node, "'https://rubygems.org'"
+              )
+            end
           end
         end
-
-        private
-
-        def range(node)
-          range_between(node.begin_pos, node.end_pos)
-        end
       end
     end
   end

data/lib/rubocop/cop/bundler/ordered_gems.rb

@@ -38,10 +38,7 @@ module RuboCop
           gem_declarations(processed_source.ast)
             .each_cons(2) do |previous, current|
             next unless consecutive_lines(previous, current)
-            next unless case_insensitive_out_of_order?(
-              gem_name(current),
-              gem_name(previous)
-            )
+            next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
 
             register_offense(previous, current)
           end
@@ -64,6 +61,7 @@ module RuboCop
           declarations.to_a[node_index - 1]
         end
 
+        # @!method gem_declarations(node)
         def_node_search :gem_declarations, <<~PATTERN
           (:send nil? :gem str ...)
         PATTERN

data/lib/rubocop/cop/commissioner.rb

@@ -7,15 +7,47 @@ module RuboCop
     class Commissioner
       include RuboCop::AST::Traversal
 
+      RESTRICTED_CALLBACKS = %i[on_send on_csend after_send after_csend].freeze
+      private_constant :RESTRICTED_CALLBACKS
+
+      # How a Commissioner returns the results of the investigation
+      # as a list of Cop::InvestigationReport and any errors caught
+      # during the investigation.
+      # Immutable
+      # Consider creation API private
+      InvestigationReport = Struct.new(:processed_source, :cop_reports, :errors) do
+        def cops
+          @cops ||= cop_reports.map(&:cop)
+        end
+
+        def offenses_per_cop
+          @offenses_per_cop ||= cop_reports.map(&:offenses)
+        end
+
+        def correctors
+          @correctors ||= cop_reports.map(&:corrector)
+        end
+
+        def offenses
+          @offenses ||= offenses_per_cop.flatten(1)
+        end
+
+        def merge(investigation)
+          InvestigationReport.new(processed_source,
+                                  cop_reports + investigation.cop_reports,
+                                  errors + investigation.errors)
+        end
+      end
+
       attr_reader :errors
 
       def initialize(cops, forces = [], options = {})
         @cops = cops
         @forces = forces
         @options = options
-        @callbacks = {}
+        initialize_callbacks
 
-        reset_errors
+        reset
       end
 
       # Create methods like :on_send, :on_super, etc. They will be called
@@ -28,105 +60,97 @@ module RuboCop
         method_name = :"on_#{node_type}"
         next unless method_defined?(method_name)
 
-        define_method(method_name) do |node|
-          trigger_responding_cops(method_name, node)
-          super(node) unless NO_CHILD_NODES.include?(node_type)
-        end
+        # Hacky: Comment-out code as needed
+        r = '#' unless RESTRICTED_CALLBACKS.include?(method_name) # has Restricted?
+        c = '#' if NO_CHILD_NODES.include?(node_type) # has Children?
+
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+                  def on_#{node_type}(node)                               # def on_send(node)
+                    trigger_responding_cops(:on_#{node_type}, node)       #   trigger_responding_cops(:on_send, node)
+              #{r}  trigger_restricted_cops(:on_#{node_type}, node)       #   trigger_restricted_cops(:on_send, node)
+          #{c}      super(node)                                           #   super(node)
+          #{c}      trigger_responding_cops(:after_#{node_type}, node)    #   trigger_responding_cops(:after_send, node)
+          #{c}#{r}  trigger_restricted_cops(:after_#{node_type}, node)    #   trigger_restricted_cops(:after_send, node)
+                  end                                                     # end
+        RUBY
       end
 
+      # @return [InvestigationReport]
       def investigate(processed_source)
-        reset_errors
-        remove_irrelevant_cops(processed_source.file_path)
-        reset_callbacks
-        prepare(processed_source)
-        invoke_custom_processing(@cops, processed_source)
-        invoke_custom_processing(@forces, processed_source)
-        walk(processed_source.ast) unless processed_source.blank?
-        invoke_custom_post_walk_processing(@cops, processed_source)
-        @cops.flat_map(&:offenses)
+        reset
+
+        @cops.each { |cop| cop.send :begin_investigation, processed_source }
+        if processed_source.valid_syntax?
+          invoke(:on_new_investigation, @cops)
+          invoke(:investigate, @forces, processed_source)
+          walk(processed_source.ast) unless @cops.empty?
+          invoke(:on_investigation_end, @cops)
+        else
+          invoke(:on_other_file, @cops)
+        end
+        reports = @cops.map { |cop| cop.send(:complete_investigation) }
+        InvestigationReport.new(processed_source, reports, @errors)
       end
 
       private
 
       def trigger_responding_cops(callback, node)
-        @callbacks[callback] ||= @cops.select do |cop|
-          cop.respond_to?(callback)
-        end
-        @callbacks[callback].each do |cop|
+        @callbacks[callback]&.each do |cop|
           with_cop_error_handling(cop, node) do
-            cop.send(callback, node)
+            cop.public_send(callback, node)
           end
         end
       end
 
-      def reset_errors
+      def reset
         @errors = []
       end
 
-      def remove_irrelevant_cops(filename)
-        @cops.reject! do |cop|
-          cop.excluded_file?(filename) ||
-            !support_target_ruby_version?(cop) ||
-            !support_target_rails_version?(cop)
-        end
+      def initialize_callbacks
+        @callbacks = build_callbacks(@cops)
+        @restricted_map = restrict_callbacks(@callbacks)
       end
 
-      def support_target_ruby_version?(cop)
-        return true unless cop.class.respond_to?(:support_target_ruby_version?)
-
-        cop.class.support_target_ruby_version?(cop.target_ruby_version)
-      end
-
-      def support_target_rails_version?(cop)
-        return true unless cop.class.respond_to?(:support_target_rails_version?)
-
-        cop.class.support_target_rails_version?(cop.target_rails_version)
-      end
-
-      def reset_callbacks
-        @callbacks.clear
+      def build_callbacks(cops)
+        callbacks = {}
+        cops.each do |cop|
+          cop.callbacks_needed.each do |callback|
+            (callbacks[callback] ||= []) << cop
+          end
+        end
+        callbacks
       end
 
-      # TODO: Bad design.
-      def prepare(processed_source)
-        @cops.each { |cop| cop.processed_source = processed_source }
+      def restrict_callbacks(callbacks)
+        restricted = {}
+        RESTRICTED_CALLBACKS.each do |callback|
+          restricted[callback] = restricted_map(callbacks[callback])
+        end
+        restricted
       end
 
-      # There are cops/forces that require their own custom processing.
-      # If they define the #investigate method, all input parameters passed
-      # to the commissioner will be passed to the cop too in order to do
-      # its own processing.
-      #
-      # These custom processors are invoked before the AST traversal,
-      # so they can build initial state that is later used by callbacks
-      # during the AST traversal.
-      def invoke_custom_processing(cops_or_forces, processed_source)
-        cops_or_forces.each do |cop|
-          next unless cop.respond_to?(:investigate)
-
-          with_cop_error_handling(cop) do
-            cop.investigate(processed_source)
+      def trigger_restricted_cops(event, node)
+        name = node.method_name
+        @restricted_map[event][name]&.each do |cop|
+          with_cop_error_handling(cop, node) do
+            cop.public_send(event, node)
           end
         end
       end
 
-      # There are cops that require their own custom processing **after**
-      # the AST traversal. By performing the walk before invoking these
-      # custom processors, we allow these cops to build their own
-      # state during the primary AST traversal instead of performing their
-      # own AST traversals. Minimizing the number of walks is more efficient.
-      #
-      # If they define the #investigate_post_walk method, all input parameters
-      # passed to the commissioner will be passed to the cop too in order to do
-      # its own processing.
-      def invoke_custom_post_walk_processing(cops, processed_source)
-        cops.each do |cop|
-          next unless cop.respond_to?(:investigate_post_walk)
-
-          with_cop_error_handling(cop) do
-            cop.investigate_post_walk(processed_source)
-          end
+      # NOTE: mutates `callbacks` in place
+      def restricted_map(callbacks)
+        map = {}
+        callbacks&.select! do |cop|
+          restrictions = cop.class.send :restrict_on_send
+          restrictions.each { |name| (map[name] ||= []) << cop }
+          restrictions.empty?
         end
+        map
+      end
+
+      def invoke(callback, cops, *args)
+        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback, *args) } }
       end
 
       # Allow blind rescues here, since we're absorbing and packaging or