rubocop 0.52.0 → 0.52.1

data/lib/rubocop/cop/lint/unused_method_argument.rb

@@ -23,6 +23,12 @@ module RuboCop
       class UnusedMethodArgument < Cop
         include UnusedArgument
 
+        def autocorrect(node)
+          UnusedArgCorrector.correct(processed_source, node)
+        end
+
+        private
+
         def check_argument(variable)
           return unless variable.method_argument?
           return if variable.keyword_argument? &&

data/lib/rubocop/cop/lint/uri_escape_unescape.rb

@@ -17,7 +17,8 @@ module RuboCop
       #
       #   # good
       #   CGI.escape('http://example.com')
-      #   URI.encode_www_form('http://example.com')
+      #   URI.encode_www_form([['example', 'param'], ['lang', 'en']])
+      #   URI.encode_www_form(page: 10, locale: 'en')
       #   URI.encode_www_form_component('http://example.com')
       #
       #   # bad

data/lib/rubocop/cop/mixin/alignment.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module checks for nodes that should be aligned to the left or right.
+    # This amount is determined by the instance variable @column_delta.
+    module Alignment
+      private
+
+      SPACE = ' '.freeze
+
+      attr_reader :column_delta
+
+      def configured_indentation_width
+        cop_config['IndentationWidth'] ||
+          config.for_cop('IndentationWidth')['Width']
+      end
+
+      def indentation(node)
+        offset(node) + (SPACE * configured_indentation_width)
+      end
+
+      def offset(node)
+        SPACE * node.loc.column
+      end
+
+      def check_alignment(items, base_column = nil)
+        unless items.empty?
+          base_column ||= display_column(items.first.source_range)
+        end
+
+        each_bad_alignment(items, base_column) do |current|
+          expr = current.source_range
+          if offenses.any? { |o| within?(expr, o.location) }
+            # If this offense is within a line range that is already being
+            # realigned by autocorrect, we report the offense without
+            # autocorrecting it. Two rewrites in the same area by the same
+            # cop can not be handled. The next iteration will find the
+            # offense again and correct it.
+            add_offense(nil, location: expr)
+          else
+            add_offense(current)
+          end
+        end
+      end
+
+      def each_bad_alignment(items, base_column)
+        prev_line = -1
+        items.each do |current|
+          if current.loc.line > prev_line &&
+             begins_its_line?(current.source_range)
+            @column_delta = base_column - display_column(current.source_range)
+
+            yield current if @column_delta.nonzero?
+          end
+          prev_line = current.loc.line
+        end
+      end
+
+      def display_column(range)
+        line = processed_source.lines[range.line - 1]
+        Unicode::DisplayWidth.of(line[0, range.column])
+      end
+
+      def within?(inner, outer)
+        inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/array_hash_indentation.rb

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Common code for indenting literal arrays and hashes.
     module ArrayHashIndentation
+      private
+
       def each_argument_node(node, type)
         left_parenthesis = node.loc.begin
 

data/lib/rubocop/cop/mixin/array_syntax.rb

@@ -5,6 +5,8 @@ module RuboCop
     # Common code for ordinary arrays with [] that can be written with %
     # syntax.
     module ArraySyntax
+      private
+
       def bracketed_array_of?(element_type, node)
         return false unless node.square_brackets? && node.values.size > 1
 

data/lib/rubocop/cop/mixin/code_length.rb

@@ -6,6 +6,8 @@ module RuboCop
     module CodeLength
       include ConfigurableMax
 
+      private
+
       def max_length
         cop_config['Max']
       end

data/lib/rubocop/cop/mixin/configurable_max.rb

@@ -5,6 +5,8 @@ module RuboCop
     # Handles `Max` configuration parameters, especially setting them to an
     # appropriate value with --auto-gen-config.
     module ConfigurableMax
+      private
+
       def max=(value)
         cfg = config_to_allow_offenses
         value = [cfg[max_parameter_name], value].max if cfg[max_parameter_name]

data/lib/rubocop/cop/mixin/def_node.rb

@@ -8,13 +8,15 @@ module RuboCop
 
       NON_PUBLIC_MODIFIERS = %w[private protected].freeze
 
+      private
+
       def non_public?(node)
         non_public_modifier?(node.parent) ||
           preceding_non_public_modifier?(node)
       end
 
       def preceding_non_public_modifier?(node)
-        stripped_source_upto(node.loc.line).any? do |line|
+        stripped_source_upto(node.first_line).any? do |line|
           NON_PUBLIC_MODIFIERS.include?(line)
         end
       end

data/lib/rubocop/cop/mixin/documentation_comment.rb

@@ -7,10 +7,10 @@ module RuboCop
       extend NodePattern::Macros
       include Style::AnnotationComment
 
-      def_node_matcher :constant_definition?, '{class module casgn}'
-
       private
 
+      def_node_matcher :constant_definition?, '{class module casgn}'
+
       def documentation_comment?(node)
         preceding_lines = preceding_lines(node)
 

data/lib/rubocop/cop/mixin/empty_lines_around_body.rb

@@ -15,23 +15,11 @@ module RuboCop
         MSG_DEFERRED = 'Empty line missing before first %<type>s ' \
                        'definition'.freeze
 
+        private
+
         def_node_matcher :constant_definition?, '{class module}'
         def_node_matcher :empty_line_required?, '{def defs class module}'
 
-        def autocorrect(args)
-          offense_style, range = args
-          lambda do |corrector|
-            case offense_style
-            when :no_empty_lines then
-              corrector.remove(range)
-            when :empty_lines then
-              corrector.insert_before(range, "\n")
-            end
-          end
-        end
-
-        private
-
         def check(node, body)
           # When style is `empty_lines`, if the body is empty, we don't enforce
           # the presence OR absence of an empty line
@@ -111,7 +99,7 @@ module RuboCop
           node = first_empty_line_required_child(body)
           return unless node
 
-          line = previous_line_ignoring_comments(node.loc.first_line)
+          line = previous_line_ignoring_comments(node.first_line)
           return if processed_source[line].empty?
 
           range = source_range(processed_source.buffer, line + 2, 0)

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -58,31 +58,7 @@ module RuboCop
       end
 
       def line_break_before_keyword?(whole_expression, rhs)
-        rhs.loc.line > whole_expression.line
-      end
-
-      def align(node, align_to)
-        whitespace = whitespace_range(node)
-        return false unless whitespace.source.strip.empty?
-
-        column = alignment_column(align_to)
-        ->(corrector) { corrector.replace(whitespace, ' ' * column) }
-      end
-
-      def whitespace_range(node)
-        begin_pos = node.loc.end.begin_pos
-
-        range_between(begin_pos - node.loc.end.column, begin_pos)
-      end
-
-      def alignment_column(align_to)
-        if !align_to
-          0
-        elsif align_to.respond_to?(:loc)
-          align_to.source_range.column
-        else
-          align_to.column
-        end
+        rhs.first_line > whole_expression.line
       end
     end
   end

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -25,12 +25,6 @@ module RuboCop
           add_offense(node.children.last)
         end
       end
-
-      def autocorrect(node)
-        lambda do |corrector|
-          corrector.replace(node.source_range, self.class::SUPERCLASS)
-        end
-      end
     end
   end
 end

data/lib/rubocop/cop/mixin/first_element_line_break.rb

@@ -5,10 +5,6 @@ module RuboCop
     # Common functionality for checking for a line break before the first
     # element in a multi-line collection.
     module FirstElementLineBreak
-      def autocorrect(node)
-        ->(corrector) { corrector.insert_before(node.source_range, "\n") }
-      end
-
       private
 
       def check_method_line_break(node, children)
@@ -27,23 +23,23 @@ module RuboCop
       def check_children_line_break(node, children, start = node)
         return if children.size < 2
 
-        line = start.loc.line
+        line = start.first_line
 
         min = first_by_line(children)
-        return if line != min.loc.first_line
+        return if line != min.first_line
 
         max = last_by_line(children)
-        return if line == max.loc.last_line
+        return if line == max.last_line
 
         add_offense(min)
       end
 
       def first_by_line(nodes)
-        nodes.min_by { |n| n.loc.first_line }
+        nodes.min_by(&:first_line)
       end
 
       def last_by_line(nodes)
-        nodes.max_by { |n| n.loc.last_line }
+        nodes.max_by(&:last_line)
       end
     end
   end

data/lib/rubocop/cop/mixin/frozen_string_literal.rb

@@ -16,6 +16,8 @@ module RuboCop
         end
       end
 
+      private
+
       def frozen_string_literals_enabled?
         ruby_version = processed_source.ruby_version
         return false unless ruby_version
@@ -27,8 +29,6 @@ module RuboCop
         end
       end
 
-      private
-
       def leading_comment_lines
         processed_source[0..2].compact
       end

data/lib/rubocop/cop/mixin/ignored_pattern.rb

@@ -5,6 +5,8 @@ module RuboCop
     # This module encapsulates the ability to ignore certain lines when
     # parsing.
     module IgnoredPattern
+      private
+
       def ignored_line?(line)
         line = if line.respond_to?(:source_line)
                  line.source_line

data/lib/rubocop/cop/mixin/integer_node.rb

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Common functionality for checking integer nodes.
     module IntegerNode
+      private
+
       def integer_part(node)
         node.source.sub(/^[+-]/, '').split('.').first
       end

data/lib/rubocop/cop/mixin/match_range.rb

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Common functionality for obtaining source ranges from regexp matches
     module MatchRange
+      private
+
       # Return a new `Range` covering the first matching group number for each
       # match of `regex` inside `range`
       def each_match_range(range, regex)

data/lib/rubocop/cop/mixin/min_body_length.rb

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Common functionality for checking minimum body length.
     module MinBodyLength
+      private
+
       def min_body_length?(node)
         (node.loc.end.line - node.loc.keyword.line) > min_body_length
       end

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -24,6 +24,8 @@ module RuboCop
         check(range, node, lhs, rhs)
       end
 
+      private
+
       # In a chain of method calls, we regard the top send node as the base
       # for indentation of all lines following the first. For example:
       # a.

data/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb

@@ -7,6 +7,8 @@ module RuboCop
     module MultilineLiteralBraceLayout
       include ConfigurableEnforcedStyle
 
+      private
+
       def check_brace_layout(node)
         return if ignored_literal?(node)
 
@@ -17,30 +19,6 @@ module RuboCop
         check(node)
       end
 
-      def autocorrect(node)
-        if closing_brace_on_same_line?(node)
-          lambda do |corrector|
-            corrector.insert_before(node.loc.end, "\n".freeze)
-          end
-        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)
-
-          lambda do |corrector|
-            corrector.remove(range_with_surrounding_space(range: node.loc.end,
-                                                          side: :left))
-
-            corrector.insert_after(last_element_range_with_trailing_comma(node),
-                                   node.loc.end.source)
-          end
-        end
-      end
-
-      private
-
       # Returns true for the case
       #   [a,
       #    b # comment
@@ -91,33 +69,16 @@ module RuboCop
         end
       end
 
-      def ignored_literal?(node)
-        implicit_literal?(node) || empty_literal?(node) || node.single_line?
-      end
-
-      def implicit_literal?(node)
-        !node.loc.begin
-      end
-
       def empty_literal?(node)
         children(node).empty?
       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
+      def implicit_literal?(node)
+        !node.loc.begin
       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
+      def ignored_literal?(node)
+        implicit_literal?(node) || empty_literal?(node) || node.single_line?
       end
 
       def children(node)
@@ -127,13 +88,13 @@ module RuboCop
       # This method depends on the fact that we have guarded
       # against implicit and empty literals.
       def opening_brace_on_same_line?(node)
-        node.loc.begin.line == children(node).first.loc.first_line
+        node.loc.begin.line == children(node).first.first_line
       end
 
       # This method depends on the fact that we have guarded
       # against implicit and empty literals.
       def closing_brace_on_same_line?(node)
-        node.loc.end.line == children(node).last.loc.last_line
+        node.loc.end.line == children(node).last.last_line
       end
 
       # Starting with the parent node and recursively for the parent node's
@@ -165,7 +126,7 @@ module RuboCop
 
         if node.respond_to?(:loc) &&
            node.loc.respond_to?(:heredoc_end) &&
-           node.loc.heredoc_end.last_line >= parent.loc.last_line
+           node.loc.heredoc_end.last_line >= parent.last_line
           return true
         end