rubocop 0.52.1 → 0.93.1

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

@@ -26,11 +26,13 @@ module RuboCop
       #   # good
       #   gem 'rubocop', groups: [:development, :test]
       class DuplicatedGem < Cop
+        include RangeHelp
+
         MSG = 'Gem `%<gem_name>s` requirements already given on line '\
-          '%<line_of_first_occurrence>d of the Gemfile.'.freeze
+          '%<line_of_first_occurrence>d of the Gemfile.'
 
         def investigate(processed_source)
-          return unless processed_source.ast
+          return if processed_source.blank?
 
           duplicated_gem_nodes.each do |nodes|
             nodes[1..-1].each do |node|
@@ -51,7 +53,11 @@ module RuboCop
           gem_declarations(processed_source.ast)
             .group_by(&:first_argument)
             .values
-            .select { |nodes| nodes.size > 1 }
+            .select { |nodes| nodes.size > 1 && !condition?(nodes) }
+        end
+
+        def condition?(nodes)
+          nodes[0].parent&.if_type? && nodes[0].parent == nodes[1].parent
         end
 
         def register_offense(node, gem_name, line_of_first_occurrence)

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Bundler
+      # Add a comment describing each gem in your Gemfile.
+      #
+      # Optionally, the "OnlyFor" configuration
+      # can be used to only register offenses when the gems
+      # use certain options or have version specifiers.
+      # Add "version_specifiers" and/or the gem option names
+      # you want to check.
+      #
+      # 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,
+      # you can check the https://bundler.io/man/gemfile.5.html[official documentation].
+      #
+      # @example OnlyFor: [] (default)
+      #   # bad
+      #
+      #   gem 'foo'
+      #
+      #   # good
+      #
+      #   # Helpers for the foo things.
+      #   gem 'foo'
+      #
+      # @example OnlyFor: ['version_specifiers']
+      #   # bad
+      #
+      #   gem 'foo', '< 2.1'
+      #
+      #   # good
+      #
+      #   # 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 < Cop
+        include DefNode
+
+        MSG = 'Missing gem description comment.'
+        CHECKED_OPTIONS_CONFIG = 'OnlyFor'
+        VERSION_SPECIFIERS_OPTION = 'version_specifiers'
+        RESTRICT_ON_SEND = %i[gem].freeze
+
+        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_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)
+        end
+
+        # 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
+        end
+
+        def preceding_lines(node)
+          processed_source.ast_with_comments[node].select do |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)
+        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)) ||
+            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
+
+        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
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Bundler
-      # The symbol argument `:gemcutter`, `:rubygems` and `:rubyforge`
+      # The symbol argument `:gemcutter`, `:rubygems`, and `:rubyforge`
       # are deprecated. So please change your source to URL string that
       # 'https://rubygems.org' if possible, or 'http://rubygems.org' if not.
       #
@@ -13,8 +13,8 @@ module RuboCop
       #
       # However, it don't replace all `sources` of `http://` with `https://`.
       # For example, when specifying an internal gem server using HTTP on the
-      # intranet, a use case where HTTPS can not be specified was considered.
-      # Consider using HTTP only if you can not use HTTPS.
+      # intranet, a use case where HTTPS cannot be specified was considered.
+      # Consider using HTTP only if you cannot use HTTPS.
       #
       # @example
       #   # bad
@@ -25,42 +25,36 @@ 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.".freeze
+              "if possible, or 'http://rubygems.org' if not."
+
+        RESTRICT_ON_SEND = %i[source].freeze
 
-        def_node_matcher :insecure_protocol_source?, <<-PATTERN
+        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: source_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 source_range(node)
-          range_between(node.begin_pos, node.end_pos)
-        end
       end
     end
   end

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

@@ -30,10 +30,11 @@ module RuboCop
 
         MSG = 'Gems should be sorted in an alphabetical order within their '\
               'section of the Gemfile. '\
-              'Gem `%<previous>s` should appear before `%<current>s`.'.freeze
+              'Gem `%<previous>s` should appear before `%<current>s`.'
 
         def investigate(processed_source)
-          return if processed_source.ast.nil?
+          return if processed_source.blank?
+
           gem_declarations(processed_source.ast)
             .each_cons(2) do |previous, current|
             next unless consecutive_lines(previous, current)
@@ -41,6 +42,7 @@ module RuboCop
               gem_name(current),
               gem_name(previous)
             )
+
             register_offense(previous, current)
           end
         end
@@ -58,11 +60,11 @@ module RuboCop
 
         def previous_declaration(node)
           declarations = gem_declarations(processed_source.ast)
-          node_index = declarations.find_index(node)
+          node_index = declarations.map(&:location).find_index(node.location)
           declarations.to_a[node_index - 1]
         end
 
-        def_node_search :gem_declarations, <<-PATTERN
+        def_node_search :gem_declarations, <<~PATTERN
           (:send nil? :gem str ...)
         PATTERN
       end

data/lib/rubocop/cop/commissioner.rb

@@ -7,97 +7,140 @@ module RuboCop
     class Commissioner
       include RuboCop::AST::Traversal
 
-      CopError = Struct.new(:error, :line, :column)
+      RESTRICTED_CALLBACKS = %i[on_send on_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
 
-      attr_reader :errors
+        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 self.callback_methods
-        Parser::Meta::NODE_TYPES.map { |type| :"on_#{type}" }
+        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 = {}
+        @callbacks = Hash.new { |h, k| h[k] = cops_callbacks_for(k) }
+        @restricted_map = {}
 
-        reset_errors
+        reset
       end
 
-      # In the dynamically generated methods below, a call to `super` is used
+      # Create methods like :on_send, :on_super, etc. They will be called
+      # during AST traversal and try to call corresponding methods on cops.
+      # A call to `super` is used
       # to continue iterating over the children of a node.
       # However, if we know that a certain node type (like `int`) never has
       # child nodes, there is no reason to pay the cost of calling `super`.
-      no_child_callbacks = NO_CHILD_NODES.map do |type|
-        :"on_#{type}"
-      end
+      Parser::Meta::NODE_TYPES.each do |node_type|
+        method_name = :"on_#{node_type}"
+        next unless method_defined?(method_name)
+
+        if RESTRICTED_CALLBACKS.include?(method_name)
+          trigger_restricted = "trigger_restricted_cops(:on_#{node_type}, node)"
+        end
 
-      callback_methods.each do |callback|
-        next unless method_defined?(callback)
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{callback}(node)
-            @callbacks[:"#{callback}"] ||= @cops.select do |cop|
-              cop.respond_to?(:"#{callback}")
-            end
-            @callbacks[:#{callback}].each do |cop|
-              with_cop_error_handling(cop, node) do
-                cop.send(:#{callback}, node)
-              end
-            end
-
-            #{!no_child_callbacks.include?(callback) && 'super'}
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def on_#{node_type}(node)
+            trigger_responding_cops(:on_#{node_type}, node)
+            #{trigger_restricted}
+            #{'super(node)' unless NO_CHILD_NODES.include?(node_type)}
           end
         RUBY
       end
 
+      # @return [InvestigationReport]
       def investigate(processed_source)
-        reset_errors
-        remove_irrelevant_cops(processed_source.buffer.name)
-        reset_callbacks
-        prepare(processed_source)
-        invoke_custom_processing(@cops, processed_source)
-        invoke_custom_processing(@forces, processed_source)
-        walk(processed_source.ast) if processed_source.ast
-        @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 reset_errors
-        @errors = Hash.new { |hash, k| hash[k] = [] }
+      def trigger_responding_cops(callback, node)
+        @callbacks[callback].each do |cop|
+          with_cop_error_handling(cop, node) do
+            cop.send(callback, node)
+          end
+        end
+      end
+
+      def reset
+        @errors = []
       end
 
-      def remove_irrelevant_cops(filename)
-        @cops.reject! { |cop| cop.excluded_file?(filename) }
-        @cops.reject! do |cop|
-          cop.class.respond_to?(:support_target_ruby_version?) &&
-            !cop.class.support_target_ruby_version?(cop.target_ruby_version)
+      def cops_callbacks_for(callback)
+        callbacks = @cops.select do |cop|
+          cop.respond_to?(callback)
         end
-        @cops.reject! do |cop|
-          cop.class.respond_to?(:support_target_rails_version?) &&
-            !cop.class.support_target_rails_version?(cop.target_rails_version)
+        if RESTRICTED_CALLBACKS.include?(callback)
+          @restricted_map[callback] = restricted_map(callbacks)
         end
+        callbacks
       end
 
-      def reset_callbacks
-        @callbacks.clear
+      def trigger_restricted_cops(event, node)
+        name = node.method_name
+        @restricted_map.fetch(event)[name]&.each do |cop|
+          with_cop_error_handling(cop, node) do
+            cop.send(event, node)
+          end
+        end
       end
 
-      # TODO: Bad design.
-      def prepare(processed_source)
-        @cops.each { |cop| cop.processed_source = processed_source }
+      # Note: mutates `callbacks` in place
+      def restricted_map(callbacks)
+        map = {}
+        callbacks.select! do |cop|
+          restrictions = cop.class.send :restrict_on_send
+          restrictions.each do |name|
+            (map[name] ||= []) << cop
+          end
+          restrictions.empty?
+        end
+        map
       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.
-      def invoke_custom_processing(cops_or_forces, processed_source)
-        cops_or_forces.each do |cop|
-          next unless cop.respond_to?(:investigate)
-
+      def invoke(callback, cops, *args)
+        cops.each do |cop|
           with_cop_error_handling(cop) do
-            cop.investigate(processed_source)
+            cop.send(callback, *args)
           end
         end
       end
@@ -109,12 +152,9 @@ module RuboCop
         yield
       rescue StandardError => e
         raise e if @options[:raise_error]
-        if node
-          line = node.first_line
-          column = node.loc.column
-        end
-        error = CopError.new(e, line, column)
-        @errors[cop] << error
+
+        err = ErrorWithAnalyzedFileLocation.new(cause: e, node: node, cop: cop)
+        @errors << err
       end
     end
   end