rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class handles autocorrection for code that needs to be moved
+    # to new lines.
+    class LineBreakCorrector
+      extend Alignment
+      extend TrailingBody
+      extend Util
+
+      class << self
+        attr_reader :processed_source
+
+        def correct_trailing_body(configured_width:, corrector:, node:,
+                                  processed_source:)
+          @processed_source = processed_source
+          range = first_part_of(node.to_a.last)
+          eol_comment = end_of_line_comment(node.source_range.line)
+
+          break_line_before(range: range, node: node, corrector: corrector,
+                            configured_width: configured_width)
+          move_comment(eol_comment: eol_comment, node: node,
+                       corrector: corrector)
+          remove_semicolon(node, corrector)
+        end
+
+        def break_line_before(range:, node:, corrector:, indent_steps: 1,
+                              configured_width:)
+          corrector.insert_before(
+            range,
+            "\n" + ' ' * (node.loc.keyword.column +
+                          indent_steps * configured_width)
+          )
+        end
+
+        def move_comment(eol_comment:, node:, corrector:)
+          return unless eol_comment
+
+          text = eol_comment.loc.expression.source
+          corrector.insert_before(node,
+                                  text + "\n" + (' ' * node.loc.keyword.column))
+          corrector.remove(eol_comment)
+        end
+
+        private
+
+        def remove_semicolon(node, corrector)
+          return unless semicolon(node)
+
+          corrector.remove(semicolon(node).pos)
+        end
+
+        def semicolon(node)
+          @semicolon ||= {}
+          @semicolon[node.object_id] ||= tokens(node).find(&:semicolon?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Autocorrection logic for the closing brace of a literal either
+    # on the same line as the last contained elements, or a new line.
+    class MultilineLiteralBraceCorrector
+      include MultilineLiteralBraceLayout
+      include RangeHelp
+
+      def initialize(node, processed_source)
+        @node = node
+        @processed_source = processed_source
+      end
+
+      def call(corrector)
+        if closing_brace_on_same_line?(node)
+          correct_same_line_brace(corrector)
+        else
+          # When a comment immediately before the closing brace gets in the
+          # way of an easy correction, the offense is reported but not auto-
+          # corrected. The user must handle the delicate decision of where to
+          # put the comment.
+          return if new_line_needed_before_closing_brace?(node)
+
+          correct_next_line_brace(corrector)
+        end
+      end
+
+      private
+
+      attr_reader :node, :processed_source
+
+      def correct_same_line_brace(corrector)
+        corrector.insert_before(node.loc.end, "\n")
+      end
+
+      def correct_next_line_brace(corrector)
+        corrector.remove(
+          range_with_surrounding_space(range: node.loc.end, side: :left)
+        )
+
+        corrector.insert_before(
+          last_element_range_with_trailing_comma(node).end,
+          node.loc.end.source
+        )
+      end
+
+      def last_element_range_with_trailing_comma(node)
+        trailing_comma_range = last_element_trailing_comma_range(node)
+        if trailing_comma_range
+          children(node).last.source_range.join(trailing_comma_range)
+        else
+          children(node).last.source_range
+        end
+      end
+
+      def last_element_trailing_comma_range(node)
+        range = range_with_surrounding_space(
+          range: children(node).last.source_range,
+          side: :right
+        ).end.resize(1)
+
+        range.source == ',' ? range : nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects gem dependency order
+    class OrderedGemCorrector
+      extend OrderedGemNode
+
+      class << self
+        attr_reader :processed_source, :comments_as_separators
+
+        def correct(processed_source, node,
+                    previous_declaration, comments_as_separators)
+          @processed_source = processed_source
+          @comments_as_separators = comments_as_separators
+
+          current_range = declaration_with_comment(node)
+          previous_range = declaration_with_comment(previous_declaration)
+
+          lambda do |corrector|
+            swap_range(corrector, current_range, previous_range)
+          end
+        end
+
+        private
+
+        def declaration_with_comment(node)
+          buffer = processed_source.buffer
+          begin_pos = get_source_range(node, comments_as_separators).begin_pos
+          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          end_pos = buffer.line_range(end_line).end_pos
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+
+        def swap_range(corrector, range1, range2)
+          src1 = range1.source
+          src2 = range2.source
+          corrector.replace(range1, src2)
+          corrector.replace(range2, src1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects parentheses
+    class ParenthesesCorrector
+      class << self
+        def correct(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+
+            if ternary_condition?(node) && next_char_is_question_mark?(node)
+              corrector.insert_after(node.loc.end, ' ')
+            end
+          end
+        end
+
+        private
+
+        def ternary_condition?(node)
+          node.parent&.if_type? && node.parent&.ternary?
+        end
+
+        def next_char_is_question_mark?(node)
+          node.loc.last_column == node.parent.loc.question.column
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects percent literals
+    class PercentLiteralCorrector
+      include Util
+
+      attr_reader :config, :preferred_delimiters
+
+      def initialize(config, preferred_delimiters)
+        @config = config
+        @preferred_delimiters = preferred_delimiters
+      end
+
+      def correct(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)
+      end
+
+      private
+
+      def wrap_contents(node, contents, char, delimiters)
+        lambda do |corrector|
+          corrector.replace(
+            node,
+            "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}"
+          )
+        end
+      end
+
+      def escape_words?(node)
+        node.children.any? { |w| needs_escaping?(w.children[0]) }
+      end
+
+      def delimiters_for(type)
+        PreferredDelimiters
+          .new(type, config, preferred_delimiters)
+          .delimiters
+      end
+
+      def new_contents(node, escape, delimiters)
+        if node.multiline?
+          autocorrect_multiline_words(node, escape, delimiters)
+        else
+          autocorrect_words(node, escape, delimiters)
+        end
+      end
+
+      def autocorrect_multiline_words(node, escape, delimiters)
+        contents = process_multiline_words(node, escape, delimiters)
+        contents << end_content(node.source)
+        contents.join('')
+      end
+
+      def autocorrect_words(node, escape, delimiters)
+        node.children.map do |word_node|
+          fix_escaped_content(word_node, escape, delimiters)
+        end.join(' ')
+      end
+
+      def process_multiline_words(node, escape, delimiters)
+        base_line_num = node.first_line
+        prev_line_num = base_line_num
+        node.children.map.with_index do |word_node, index|
+          line_breaks = line_breaks(word_node,
+                                    node.source,
+                                    prev_line_num,
+                                    base_line_num,
+                                    index)
+          prev_line_num = word_node.first_line
+          content = fix_escaped_content(word_node, escape, delimiters)
+          line_breaks + content
+        end
+      end
+
+      def line_breaks(node, source, previous_line_num, base_line_num, node_indx)
+        source_in_lines = source.split("\n")
+        if first_line?(node, previous_line_num)
+          node_indx.zero? && node.first_line == base_line_num ? '' : ' '
+        else
+          process_lines(node, previous_line_num, base_line_num, source_in_lines)
+        end
+      end
+
+      def first_line?(node, previous_line_num)
+        node.first_line == previous_line_num
+      end
+
+      def process_lines(node, previous_line_num, base_line_num, source_in_lines)
+        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 || '')}"
+      end
+
+      def fix_escaped_content(word_node, escape, delimiters)
+        content = +word_node.children.first.to_s
+        content = escape_string(content) if escape
+        substitute_escaped_delimiters(content, delimiters)
+        content
+      end
+
+      def substitute_escaped_delimiters(content, delimiters)
+        delimiters.each { |delim| content.gsub!(delim, "\\#{delim}") }
+      end
+
+      def end_content(source)
+        result = /\A(\s*)\]/.match(source.split("\n").last)
+        ("\n" + result[1]) if result
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects whitespace
+    class SpaceCorrector
+      extend SurroundingSpace
+
+      class << self
+        attr_reader :processed_source
+
+        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)
+            corrector.remove(range)
+            corrector.insert_after(left_token.pos, ' ')
+          elsif offending_empty_no_space?(empty_config, left_token, right_token)
+            corrector.remove(range)
+          end
+        end
+
+        def remove_space(processed_source, corrector, left_token, right_token)
+          @processed_source = processed_source
+          if left_token.space_after?
+            range = side_space_range(range: left_token.pos, side: :right)
+            corrector.remove(range)
+          end
+          return unless right_token.space_before?
+
+          range = side_space_range(range: right_token.pos, side: :left)
+          corrector.remove(range)
+        end
+
+        def add_space(processed_source, corrector, left_token, right_token)
+          @processed_source = processed_source
+          corrector.insert_after(left_token.pos, ' ') unless left_token.space_after?
+          return if right_token.space_before?
+
+          corrector.insert_before(right_token.pos, ' ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects string literals
+    class StringLiteralCorrector
+      extend Util
+
+      class << self
+        def correct(node, style)
+          return if node.dstr_type?
+
+          lambda do |corrector|
+            str = node.str_content
+            if style == :single_quotes
+              corrector.replace(node, to_string_literal(str))
+            else
+              corrector.replace(node, str.inspect)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects unused arguments.
+    class UnusedArgCorrector
+      extend RangeHelp
+
+      class << self
+        attr_reader :processed_source
+
+        def correct(processed_source, node)
+          return if %i[kwarg kwoptarg].include?(node.type)
+
+          @processed_source = processed_source
+
+          if node.blockarg_type?
+            correct_for_blockarg_type(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
+          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
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/force.rb

@@ -29,6 +29,7 @@ module RuboCop
       def run_hook(method_name, *args)
         cops.each do |cop|
           next unless cop.respond_to?(method_name)
+
           cop.send(method_name, *args)
         end
       end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # 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.
+      #
+      # @example
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'rubocop'
+      #     spec.name = 'rubocop2'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'rubocop'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.requirements << 'libmagick, v6.0'
+      #     spec.requirements << 'A good graphics card'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_runtime_dependency('parallel', '~> 1.10')
+      #     spec.add_runtime_dependency('parser', '>= 2.3.3.1', '< 3.0')
+      #   end
+      class DuplicatedAssignment < Cop
+        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
+          (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)
+          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
+        end
+
+        private
+
+        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 assignment_method?(method_name)
+          method_name.to_s.end_with?('=')
+        end
+
+        def duplicated_assignment_method_nodes
+          assignment_method_declarations(processed_source.ast)
+            .group_by(&:method_name)
+            .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)
+          message = format(
+            MSG,
+            assignment: assignment,
+            line_of_first_occurrence: line_of_first_occurrence
+          )
+          add_offense(node, location: offense_location, message: message)
+        end
+      end
+    end
+  end
+end

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

@@ -54,12 +54,13 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include OrderedGemNode
 
-        MSG = 'Dependencies should be sorted in an alphabetical order within '\
+        MSG = 'Dependencies should be sorted in an alphabetical order within ' \
               'their section of the gemspec. '\
-              'Dependency `%s` should appear before `%s`.'.freeze
+              'Dependency `%<previous>s` should appear before `%<current>s`.'
 
         def investigate(processed_source)
-          return if processed_source.ast.nil?
+          return if processed_source.blank?
+
           dependency_declarations(processed_source.ast)
             .each_cons(2) do |previous, current|
             next unless consecutive_lines(previous, current)
@@ -67,14 +68,21 @@ 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
         end
 
+        def autocorrect(node)
+          OrderedGemCorrector.correct(
+            processed_source,
+            node,
+            previous_declaration(node),
+            treat_comments_as_separators
+          )
+        end
+
         private
 
         def previous_declaration(node)
@@ -87,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