rubocop 0.87.1 → 0.91.0

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

@@ -34,6 +34,8 @@ module RuboCop
               "Please change your source to 'https://rubygems.org' " \
               "if possible, or 'http://rubygems.org' if not."
 
+        RESTRICT_ON_SEND = %i[source].freeze
+
         def_node_matcher :insecure_protocol_source?, <<~PATTERN
           (send nil? :source
             $(sym ${:gemcutter :rubygems :rubyforge}))

data/lib/rubocop/cop/commissioner.rb

@@ -7,6 +7,9 @@ module RuboCop
     class Commissioner
       include RuboCop::AST::Traversal
 
+      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.
@@ -42,7 +45,8 @@ module RuboCop
         @cops = cops
         @forces = forces
         @options = options
-        @callbacks = {}
+        @callbacks = Hash.new { |h, k| h[k] = cops_callbacks_for(k) }
+        @restricted_map = {}
 
         reset
       end
@@ -57,10 +61,17 @@ 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)
+        if RESTRICTED_CALLBACKS.include?(method_name)
+          trigger_restricted = "trigger_restricted_cops(:on_#{node_type}, node)"
         end
+
+        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]
@@ -83,9 +94,6 @@ module RuboCop
       private
 
       def trigger_responding_cops(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)
@@ -95,7 +103,38 @@ module RuboCop
 
       def reset
         @errors = []
-        @callbacks = {}
+      end
+
+      def cops_callbacks_for(callback)
+        callbacks = @cops.select do |cop|
+          cop.respond_to?(callback)
+        end
+        if RESTRICTED_CALLBACKS.include?(callback)
+          @restricted_map[callback] = restricted_map(callbacks)
+        end
+        callbacks
+      end
+
+      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
+
+      # 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
 
       def invoke(callback, cops, *args)

data/lib/rubocop/cop/cop.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'uri'
-require_relative 'legacy/corrections_proxy.rb'
+require_relative 'legacy/corrections_proxy'
 
 module RuboCop
   module Cop

data/lib/rubocop/cop/correctors/alignment_corrector.rb

@@ -29,13 +29,13 @@ module RuboCop
           end
         end
 
-        def align_end(processed_source, node, align_to)
+        def align_end(corrector, processed_source, node, align_to)
           @processed_source = processed_source
           whitespace = whitespace_range(node)
           return false unless whitespace.source.strip.empty?
 
           column = alignment_column(align_to)
-          ->(corrector) { corrector.replace(whitespace, ' ' * column) }
+          corrector.replace(whitespace, ' ' * column)
         end
 
         private
@@ -47,8 +47,8 @@ module RuboCop
           # string literals
           return if taboo_ranges.any? { |t| within?(range, t) }
 
-          if column_delta.positive?
-            corrector.insert_before(range, ' ' * column_delta) unless range.resize(1).source == "\n"
+          if column_delta.positive? && range.resize(1).source != "\n"
+            corrector.insert_before(range, ' ' * column_delta)
           elsif /\A[ \t]+\z/.match?(range.source)
             remove(range, corrector)
           end

data/lib/rubocop/cop/correctors/condition_corrector.rb

@@ -5,13 +5,11 @@ module RuboCop
     # This class does condition auto-correction
     class ConditionCorrector
       class << self
-        def correct_negative_condition(node)
+        def correct_negative_condition(corrector, node)
           condition = negated_condition(node)
 
-          lambda do |corrector|
-            corrector.replace(node.loc.keyword, node.inverse_keyword)
-            corrector.replace(condition, condition.children.first.source)
-          end
+          corrector.replace(node.loc.keyword, node.inverse_keyword)
+          corrector.replace(condition, condition.children.first.source)
         end
 
         private

data/lib/rubocop/cop/correctors/empty_line_corrector.rb

@@ -5,20 +5,19 @@ module RuboCop
     # This class does empty line auto-correction
     class EmptyLineCorrector
       class << self
-        def correct(node)
+        def correct(corrector, node)
           offense_style, range = node
-          lambda do |corrector|
-            case offense_style
-            when :no_empty_lines
-              corrector.remove(range)
-            when :empty_lines
-              corrector.insert_before(range, "\n")
-            end
+
+          case offense_style
+          when :no_empty_lines
+            corrector.remove(range)
+          when :empty_lines
+            corrector.insert_before(range, "\n")
           end
         end
 
-        def insert_before(node)
-          ->(corrector) { corrector.insert_before(node, "\n") }
+        def insert_before(corrector, node)
+          corrector.insert_before(node, "\n")
         end
       end
     end

data/lib/rubocop/cop/correctors/line_break_corrector.rb

@@ -16,7 +16,7 @@ module RuboCop
                                   processed_source:)
           @processed_source = processed_source
           range = first_part_of(node.to_a.last)
-          eol_comment = end_of_line_comment(node.source_range.line)
+          eol_comment = processed_source.comment_at_line(node.source_range.line)
 
           break_line_before(range: range, node: node, corrector: corrector,
                             configured_width: configured_width)
@@ -25,12 +25,12 @@ module RuboCop
           remove_semicolon(node, corrector)
         end
 
-        def break_line_before(range:, node:, corrector:, indent_steps: 1,
-                              configured_width:)
+        def break_line_before(range:, node:, corrector:, configured_width:,
+                              indent_steps: 1)
           corrector.insert_before(
             range,
-            "\n" + ' ' * (node.loc.keyword.column +
-                          indent_steps * configured_width)
+            "\n#{' ' * (node.loc.keyword.column +
+                          indent_steps * configured_width)}"
           )
         end
 
@@ -39,7 +39,7 @@ module RuboCop
 
           text = eol_comment.loc.expression.source
           corrector.insert_before(node,
-                                  text + "\n" + (' ' * node.loc.keyword.column))
+                                  "#{text}\n#{' ' * node.loc.keyword.column}")
           corrector.remove(eol_comment)
         end
 

data/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb

@@ -8,12 +8,17 @@ module RuboCop
       include MultilineLiteralBraceLayout
       include RangeHelp
 
-      def initialize(node, processed_source)
+      def self.correct(corrector, node, processed_source)
+        new(corrector, node, processed_source).call
+      end
+
+      def initialize(corrector, node, processed_source)
+        @corrector = corrector
         @node = node
         @processed_source = processed_source
       end
 
-      def call(corrector)
+      def call
         if closing_brace_on_same_line?(node)
           correct_same_line_brace(corrector)
         else
@@ -29,7 +34,7 @@ module RuboCop
 
       private
 
-      attr_reader :node, :processed_source
+      attr_reader :corrector, :node, :processed_source
 
       def correct_same_line_brace(corrector)
         corrector.insert_before(node.loc.end, "\n")
@@ -42,8 +47,34 @@ module RuboCop
 
         corrector.insert_before(
           last_element_range_with_trailing_comma(node).end,
+          content_if_comment_present(corrector, node)
+        )
+      end
+
+      def content_if_comment_present(corrector, node)
+        range = range_with_surrounding_space(
+          range: children(node).last.source_range,
+          side: :right
+        ).end.resize(1)
+        if range.source == '#'
+          select_content_to_be_inserted_after_last_element(corrector, node)
+        else
           node.loc.end.source
+        end
+      end
+
+      def select_content_to_be_inserted_after_last_element(corrector, node)
+        range = range_between(
+          node.loc.end.begin_pos,
+          range_by_whole_lines(node.loc.expression).end.end_pos
         )
+
+        remove_trailing_content_of_comment(corrector, range)
+        range.source
+      end
+
+      def remove_trailing_content_of_comment(corrector, range)
+        corrector.remove(range)
       end
 
       def last_element_range_with_trailing_comma(node)

data/lib/rubocop/cop/correctors/parentheses_corrector.rb

@@ -5,15 +5,12 @@ module RuboCop
     # This auto-corrects parentheses
     class ParenthesesCorrector
       class << self
-        def correct(node)
-          lambda do |corrector|
-            corrector.remove(node.loc.begin)
-            corrector.remove(node.loc.end)
+        def correct(corrector, node)
+          corrector.remove(node.loc.begin)
+          corrector.remove(node.loc.end)
+          return unless ternary_condition?(node) && next_char_is_question_mark?(node)
 
-            if ternary_condition?(node) && next_char_is_question_mark?(node)
-              corrector.insert_after(node.loc.end, ' ')
-            end
-          end
+          corrector.insert_after(node.loc.end, ' ')
         end
 
         private

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -13,23 +13,18 @@ module RuboCop
         @preferred_delimiters = preferred_delimiters
       end
 
-      def correct(node, char)
+      def correct(corrector, node, char)
         escape = escape_words?(node)
         char = char.upcase if escape
         delimiters = delimiters_for("%#{char}")
         contents = new_contents(node, escape, delimiters)
-        wrap_contents(node, contents, char, delimiters)
+        wrap_contents(corrector, node, contents, char, delimiters)
       end
 
       private
 
-      def wrap_contents(node, contents, char, delimiters)
-        lambda do |corrector|
-          corrector.replace(
-            node,
-            "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}"
-          )
-        end
+      def wrap_contents(corrector, node, contents, char, delimiters)
+        corrector.replace(node, "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}")
       end
 
       def escape_words?(node)
@@ -71,7 +66,7 @@ module RuboCop
                                     prev_line_num,
                                     base_line_num,
                                     index)
-          prev_line_num = word_node.first_line
+          prev_line_num = word_node.last_line
           content = fix_escaped_content(word_node, escape, delimiters)
           line_breaks + content
         end
@@ -110,7 +105,7 @@ module RuboCop
 
       def end_content(source)
         result = /\A(\s*)\]/.match(source.split("\n").last)
-        ("\n" + result[1]) if result
+        "\n#{result[1]}" if result
       end
     end
   end

data/lib/rubocop/cop/correctors/punctuation_corrector.rb

@@ -5,22 +5,20 @@ module RuboCop
     # This auto-corrects punctuation
     class PunctuationCorrector
       class << self
-        def remove_space(space_before)
-          ->(corrector) { corrector.remove(space_before) }
+        def remove_space(corrector, space_before)
+          corrector.remove(space_before)
         end
 
-        def add_space(token)
-          ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
+        def add_space(corrector, token)
+          corrector.replace(token.pos, "#{token.pos.source} ")
         end
 
-        def swap_comma(range)
+        def swap_comma(corrector, range)
           return unless range
 
-          lambda do |corrector|
-            case range.source
-            when ',' then corrector.remove(range)
-            else          corrector.insert_after(range, ',')
-            end
+          case range.source
+          when ',' then corrector.remove(range)
+          else          corrector.insert_after(range, ',')
           end
         end
       end

data/lib/rubocop/cop/correctors/unused_arg_corrector.rb

@@ -9,33 +9,30 @@ module RuboCop
       class << self
         attr_reader :processed_source
 
-        def correct(processed_source, node)
+        def correct(corrector, processed_source, node)
           return if %i[kwarg kwoptarg].include?(node.type)
 
           @processed_source = processed_source
 
           if node.blockarg_type?
-            correct_for_blockarg_type(node)
+            correct_for_blockarg_type(corrector, node)
           else
-            lambda do |corrector|
-              variable_name = if node.optarg_type?
-                                node.node_parts[0]
-                              else
-                                # Extract only a var name without splat (`*`)
-                                node.source.gsub(/\A\*+/, '')
-                              end
-              corrector.replace(node.loc.name, "_#{variable_name}")
-            end
+            variable_name = if node.optarg_type?
+                              node.node_parts[0]
+                            else
+                              # Extract only a var name without splat (`*`)
+                              node.source.gsub(/\A\*+/, '')
+                            end
+
+            corrector.replace(node.loc.name, "_#{variable_name}")
           end
         end
 
-        def correct_for_blockarg_type(node)
-          lambda do |corrector|
-            range = range_with_surrounding_space(range: node.source_range,
-                                                 side: :left)
-            range = range_with_surrounding_comma(range, :left)
-            corrector.remove(range)
-          end
+        def correct_for_blockarg_type(corrector, node)
+          range = range_with_surrounding_space(range: node.source_range, side: :left)
+          range = range_with_surrounding_comma(range, :left)
+
+          corrector.remove(range)
         end
       end
     end

data/lib/rubocop/cop/documentation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Helpers for builtin documentation
+    module Documentation
+      module_function
+
+      # @api private
+      def department_to_basename(department)
+        "cops_#{department.downcase}"
+      end
+
+      # @api private
+      def url_for(cop_class)
+        base = department_to_basename(cop_class.department)
+        fragment = cop_class.cop_name.downcase.gsub(/[^a-z]/, '')
+        "https://docs.rubocop.org/rubocop/#{base}.html##{fragment}"
+      end
+    end
+  end
+end