rubocop 0.70.0 → 1.6.1

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

@@ -19,47 +19,68 @@ module RuboCop
           expr = node.respond_to?(:loc) ? node.loc.expression : node
           return if block_comment_within?(expr)
 
+          taboo_ranges = inside_string_ranges(node)
+
           lambda do |corrector|
             each_line(expr) do |line_begin_pos|
               autocorrect_line(corrector, line_begin_pos, expr, column_delta,
-                               heredoc_ranges(node))
+                               taboo_ranges)
             end
           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
 
         def autocorrect_line(corrector, line_begin_pos, expr, column_delta,
-                             heredoc_ranges)
+                             taboo_ranges)
           range = calculate_range(expr, line_begin_pos, column_delta)
-          # We must not change indentation of heredoc strings.
-          return if heredoc_ranges.any? { |h| within?(range, h) }
+          # We must not change indentation of heredoc strings or inside other
+          # string literals
+          return if taboo_ranges.any? { |t| within?(range, t) }
 
-          if column_delta.positive?
-            unless range.source == "\n"
-              # TODO: Fix ranges instead of using `begin`
-              corrector.insert_before(range.begin, ' ' * column_delta)
-            end
-          elsif range.source =~ /\A[ \t]+\z/
+          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
         end
 
-        def heredoc_ranges(node)
+        def inside_string_ranges(node)
           return [] unless node.is_a?(Parser::AST::Node)
 
-          node.each_node(:dstr)
-              .select(&:heredoc?)
-              .map { |n| n.loc.heredoc_body.join(n.loc.heredoc_end) }
+          node.each_node(:str, :dstr, :xstr).map { |n| inside_string_range(n) }
+              .compact
+        end
+
+        def inside_string_range(node)
+          loc = node.location
+
+          if node.heredoc?
+            loc.heredoc_body.join(loc.heredoc_end)
+          elsif delimited_string_literal?(node)
+            loc.begin.end.join(loc.end.begin)
+          end
+        end
+
+        # Some special kinds of string literals are not composed of literal
+        # characters between two delimiters:
+        # - The source map of `?a` responds to :begin and :end but its end is
+        #   nil.
+        # - The source map of `__FILE__` responds to neither :begin nor :end.
+        def delimited_string_literal?(node)
+          loc = node.location
+
+          loc.respond_to?(:begin) && loc.begin &&
+            loc.respond_to?(:end) && loc.end
         end
 
         def block_comment_within?(expr)
@@ -69,15 +90,16 @@ module RuboCop
         end
 
         def calculate_range(expr, line_begin_pos, column_delta)
+          return range_between(line_begin_pos, line_begin_pos) if column_delta.positive?
+
           starts_with_space =
             expr.source_buffer.source[line_begin_pos].start_with?(' ')
-          pos_to_remove = if column_delta.positive? || starts_with_space
-                            line_begin_pos
-                          else
-                            line_begin_pos - column_delta.abs
-                          end
 
-          range_between(pos_to_remove, pos_to_remove + column_delta.abs)
+          if starts_with_space
+            range_between(line_begin_pos, line_begin_pos + column_delta.abs)
+          else
+            range_between(line_begin_pos - column_delta.abs, line_begin_pos)
+          end
         end
 
         def remove(range, corrector)
@@ -86,7 +108,7 @@ module RuboCop
           corrector.remove(range)
         rescue RuntimeError
           range = range_between(range.begin_pos + 1, range.end_pos + 1)
-          retry if range.source =~ /^ +$/
+          retry if /^ +$/.match?(range.source)
         ensure
           $stderr = original_stderr
         end

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

@@ -5,14 +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.source_range,
-                              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 then
-              corrector.remove(range)
-            when :empty_lines then
-              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.source_range, "\n") }
+        def insert_before(corrector, node)
+          corrector.insert_before(node, "\n")
         end
       end
     end

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

@@ -44,13 +44,13 @@ module RuboCop
       end
 
       def replace_selector(corrector)
-        corrector.replace(method.source_range, 'lambda')
+        corrector.replace(method, 'lambda')
       end
 
       def remove_arguments(corrector)
         return if arguments.empty_and_without_delimiters?
 
-        corrector.remove(arguments.source_range)
+        corrector.remove(arguments)
       end
 
       def insert_arguments(corrector)
@@ -62,7 +62,7 @@ module RuboCop
 
       def remove_leading_whitespace(corrector)
         corrector.remove_preceding(
-          arguments.source_range,
+          arguments,
           arguments.source_range.begin_pos -
             block_node.send_node.source_range.end_pos
         )
@@ -129,7 +129,7 @@ module RuboCop
       end
 
       def separating_space?
-        block_begin.source_buffer.source[block_begin.begin_pos + 2].match(/\s/)
+        block_begin.source_buffer.source[block_begin.begin_pos + 2].match?(/\s/)
       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
 
@@ -38,9 +38,9 @@ module RuboCop
           return unless eol_comment
 
           text = eol_comment.loc.expression.source
-          corrector.insert_before(node.source_range,
-                                  text + "\n" + (' ' * node.loc.keyword.column))
-          corrector.remove(eol_comment.loc.expression)
+          corrector.insert_before(node,
+                                  "#{text}\n#{' ' * node.loc.keyword.column}")
+          corrector.remove(eol_comment)
         end
 
         private
@@ -52,8 +52,8 @@ module RuboCop
         end
 
         def semicolon(node)
-          @semicolon ||= {}
-          @semicolon[node.object_id] ||= tokens(node).find(&:semicolon?)
+          @semicolon ||= {}.compare_by_identity
+          @semicolon[node] ||= processed_source.tokens_within(node).find(&:semicolon?)
         end
       end
     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")
@@ -40,10 +45,36 @@ module RuboCop
           range_with_surrounding_space(range: node.loc.end, side: :left)
         )
 
-        corrector.insert_after(
-          last_element_range_with_trailing_comma(node),
+        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.source_range,
-            "%#{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)
@@ -53,7 +48,7 @@ module RuboCop
       def autocorrect_multiline_words(node, escape, delimiters)
         contents = process_multiline_words(node, escape, delimiters)
         contents << end_content(node.source)
-        contents.join('')
+        contents.join
       end
 
       def autocorrect_words(node, escape, delimiters)
@@ -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
@@ -94,11 +89,11 @@ module RuboCop
         begin_line_num = previous_line_num - base_line_num + 1
         end_line_num = node.first_line - base_line_num + 1
         lines = source_in_lines[begin_line_num...end_line_num]
-        "\n#{(lines.join("\n").split(node.source).first || '')}"
+        "\n#{lines.join("\n").split(node.source).first || ''}"
       end
 
       def fix_escaped_content(word_node, escape, delimiters)
-        content = word_node.children.first.to_s
+        content = +word_node.children.first.to_s
         content = escape_string(content) if escape
         substitute_escaped_delimiters(content, delimiters)
         content
@@ -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/space_corrector.rb

@@ -12,12 +12,11 @@ module RuboCop
         def empty_corrections(processed_source, corrector, empty_config,
                               left_token, right_token)
           @processed_source = processed_source
+          range = range_between(left_token.end_pos, right_token.begin_pos)
           if offending_empty_space?(empty_config, left_token, right_token)
-            range = side_space_range(range: left_token.pos, side: :right)
             corrector.remove(range)
             corrector.insert_after(left_token.pos, ' ')
           elsif offending_empty_no_space?(empty_config, left_token, right_token)
-            range = side_space_range(range: left_token.pos, side: :right)
             corrector.remove(range)
           end
         end
@@ -36,9 +35,7 @@ module RuboCop
 
         def add_space(processed_source, corrector, left_token, right_token)
           @processed_source = processed_source
-          unless left_token.space_after?
-            corrector.insert_after(left_token.pos, ' ')
-          end
+          corrector.insert_after(left_token.pos, ' ') unless left_token.space_after?
           return if right_token.space_before?
 
           corrector.insert_before(right_token.pos, ' ')

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

@@ -7,16 +7,14 @@ module RuboCop
       extend Util
 
       class << self
-        def correct(node, style)
+        def correct(corrector, node, style)
           return if node.dstr_type?
 
-          lambda do |corrector|
-            str = node.str_content
-            if style == :single_quotes
-              corrector.replace(node.source_range, to_string_literal(str))
-            else
-              corrector.replace(node.source_range, str.inspect)
-            end
+          str = node.str_content
+          if style == :single_quotes
+            corrector.replace(node, to_string_literal(str))
+          else
+            corrector.replace(node, str.inspect)
           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

data/lib/rubocop/cop/force.rb

@@ -11,6 +11,7 @@ module RuboCop
       end
 
       def self.inherited(subclass)
+        super
         all << subclass
       end
 
@@ -30,7 +31,7 @@ module RuboCop
         cops.each do |cop|
           next unless cop.respond_to?(method_name)
 
-          cop.send(method_name, *args)
+          cop.public_send(method_name, *args)
         end
       end
 

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

@@ -34,13 +34,13 @@ module RuboCop
       #     spec.add_runtime_dependency('parallel', '~> 1.10')
       #     spec.add_runtime_dependency('parser', '>= 2.3.3.1', '< 3.0')
       #   end
-      class DuplicatedAssignment < Cop
+      class DuplicatedAssignment < Base
         include RangeHelp
 
         MSG = '`%<assignment>s` method calls already given on line '\
               '%<line_of_first_occurrence>d of the gemspec.'
 
-        def_node_search :gem_specification, <<-PATTERN
+        def_node_search :gem_specification, <<~PATTERN
           (block
             (send
               (const
@@ -49,12 +49,12 @@ module RuboCop
               (arg $_)) ...)
         PATTERN
 
-        def_node_search :assignment_method_declarations, <<-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|
@@ -96,7 +96,7 @@ module RuboCop
             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

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

@@ -68,9 +68,7 @@ module RuboCop
               gem_name(current),
               gem_name(previous)
             )
-            unless get_dependency_name(previous) == get_dependency_name(current)
-              next
-            end
+            next unless get_dependency_name(previous) == get_dependency_name(current)
 
             register_offense(previous, current)
           end
@@ -97,8 +95,8 @@ module RuboCop
           node.method_name
         end
 
-        def_node_search :dependency_declarations, <<-PATTERN
-          (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} ...)
+        def_node_search :dependency_declarations, <<~PATTERN
+          (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} (str _) ...)
         PATTERN
       end
     end