rubocop 0.80.0 → 0.84.0

data/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb

@@ -98,13 +98,9 @@ module RuboCop
           lambda do |corrector|
             fix_closing_parenthesis(node, corrector)
 
-            if internal_trailing_comma?(node)
-              remove_internal_trailing_comma(node, corrector)
-            end
+            remove_internal_trailing_comma(node, corrector) if internal_trailing_comma?(node)
 
-            if external_trailing_comma?(node)
-              fix_external_trailing_comma(node, corrector)
-            end
+            fix_external_trailing_comma(node, corrector) if external_trailing_comma?(node)
           end
         end
 
@@ -169,7 +165,7 @@ module RuboCop
         end
 
         def add_correct_closing_paren(node, corrector)
-          corrector.insert_after(node.arguments.last.source_range, ')')
+          corrector.insert_after(node.arguments.last, ')')
         end
 
         def remove_incorrect_closing_paren(node, corrector)
@@ -249,7 +245,7 @@ module RuboCop
         def add_correct_external_trailing_comma(node, corrector)
           return unless external_trailing_comma?(node)
 
-          corrector.insert_after(node.arguments.last.source_range, ',')
+          corrector.insert_after(node.arguments.last, ',')
         end
 
         def remove_incorrect_external_trailing_comma(node, corrector)

data/lib/rubocop/cop/layout/heredoc_indentation.rb

@@ -184,14 +184,14 @@ module RuboCop
         def adjust_minus(corrector, node)
           heredoc_beginning = node.loc.expression.source
           corrected = heredoc_beginning.sub(/<<-?/, '<<~')
-          corrector.replace(node.loc.expression, corrected)
+          corrector.replace(node, corrected)
         end
 
         def correct_by_library(node)
           lambda do |corrector|
             corrector.replace(node.loc.heredoc_body, indented_body(node))
             corrected = ".#{STRIP_METHODS[style]}"
-            corrector.insert_after(node.loc.expression, corrected)
+            corrector.insert_after(node, corrected)
           end
         end
 

data/lib/rubocop/cop/layout/{tab.rb → indentation_style.rb}

@@ -5,9 +5,10 @@ require 'set'
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for tabs inside the source code.
+      # This cop checks that the indentation method is consistent.
+      # Either tabs only or spaces only are used for indentation.
       #
-      # @example
+      # @example EnforcedStyle: spaces (default)
       #   # bad
       #   # This example uses a tab to indent bar.
       #   def foo
@@ -20,17 +21,30 @@ module RuboCop
       #     bar
       #   end
       #
-      class Tab < Cop
+      # @example EnforcedStyle: tabs
+      #   # bad
+      #   # This example uses spaces to indent bar.
+      #   def foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   # This example uses a tab to indent bar.
+      #   def foo
+      #     bar
+      #   end
+      class IndentationStyle < Cop
         include Alignment
+        include ConfigurableEnforcedStyle
         include RangeHelp
 
-        MSG = 'Tab detected.'
+        MSG = '%<type>s detected in indentation.'
 
         def investigate(processed_source)
           str_ranges = string_literal_ranges(processed_source.ast)
 
           processed_source.lines.each.with_index(1) do |line, lineno|
-            match = line.match(/\t+/)
+            match = find_offence(line)
             next unless match
 
             range = source_range(processed_source.buffer,
@@ -43,13 +57,37 @@ module RuboCop
         end
 
         def autocorrect(range)
+          if range.source.include?("\t")
+            autocorrect_lambda_for_tabs(range)
+          else
+            autocorrect_lambda_for_spaces(range)
+          end
+        end
+
+        private
+
+        def find_offence(line)
+          if style == :spaces
+            line.match(/\A\s*\t+/)
+          else
+            line.match(/\A\s* +/)
+          end
+        end
+
+        def autocorrect_lambda_for_tabs(range)
           lambda do |corrector|
             spaces = ' ' * configured_indentation_width
             corrector.replace(range, range.source.gsub(/\t/, spaces))
           end
         end
 
-        private
+        def autocorrect_lambda_for_spaces(range)
+          lambda do |corrector|
+            corrector.replace(range, range.source.gsub(/\A\s+/) do |match|
+              "\t" * (match.size / configured_indentation_width)
+            end)
+          end
+        end
 
         def in_string_literal?(ranges, tabs_range)
           ranges.any? { |range| range.contains?(tabs_range) }
@@ -69,6 +107,10 @@ module RuboCop
             end
           end
         end
+
+        def message(_node)
+          format(MSG, type: style == :spaces ? 'Tab' : 'Space')
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/indentation_width.rb

@@ -263,9 +263,7 @@ module RuboCop
         def offense(body_node, indentation, style)
           # This cop only auto-corrects the first statement in a def body, for
           # example.
-          if body_node.begin_type? && !parentheses?(body_node)
-            body_node = body_node.children.first
-          end
+          body_node = body_node.children.first if body_node.begin_type? && !parentheses?(body_node)
 
           # Since autocorrect changes a number of lines, and not only the line
           # where the reported offending range is, we avoid auto-correction if

data/lib/rubocop/cop/layout/leading_comment_space.rb

@@ -56,7 +56,7 @@ module RuboCop
 
         def investigate(processed_source)
           processed_source.each_comment do |comment|
-            next unless comment.text =~ /\A#+[^#\s=:+-]/
+            next unless /\A#+[^#\s=:+-]/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
             next if doxygen_comment_style?(comment)
             next if gemfile_ruby_comment?(comment)

data/lib/rubocop/cop/layout/line_length.rb

@@ -8,7 +8,7 @@ module RuboCop
       # This cop checks the length of lines in the source code.
       # The maximum length is configurable.
       # The tab size is configured in the `IndentationWidth`
-      # of the `Layout/Tab` cop.
+      # of the `Layout/IndentationStyle` cop.
       # It also ignores a shebang line by default.
       #
       # This cop has some autocorrection capabilities.
@@ -131,7 +131,7 @@ module RuboCop
         end
 
         def breakable_block_range(block_node)
-          if block_node.arguments?
+          if block_node.arguments? && !block_node.lambda?
             block_node.arguments.loc.end
           else
             block_node.loc.begin
@@ -145,7 +145,7 @@ module RuboCop
           return nil unless next_range.line == range.line
 
           next_char = next_range.source
-          return nil if /[\r\n]/ =~ next_char
+          return nil if /[\r\n]/.match?(next_char)
           return nil if next_char == ';'
 
           next_range
@@ -160,7 +160,10 @@ module RuboCop
         end
 
         def highlight_start(line)
-          max - indentation_difference(line)
+          # TODO: The max with 0 is a quick fix to avoid crashes when a line
+          # begins with many tabs, but getting a correct highlighting range
+          # when tabs are used for indentation doesn't work currently.
+          [max - indentation_difference(line), 0].max
         end
 
         def check_line(line, line_index)

data/lib/rubocop/cop/layout/multiline_block_layout.rb

@@ -81,9 +81,7 @@ module RuboCop
 
             expr_before_body ||= node.loc.begin
 
-            if expr_before_body.line == node.body.first_line
-              autocorrect_body(corrector, node, node.body)
-            end
+            autocorrect_body(corrector, node, node.body) if expr_before_body.line == node.body.first_line
           end
         end
 
@@ -129,7 +127,7 @@ module RuboCop
 
           block_start_col = node.source_range.column
 
-          corrector.insert_before(first_node.source_range,
+          corrector.insert_before(first_node,
                                   "\n  #{' ' * block_start_col}")
         end
 

data/lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb

@@ -37,9 +37,7 @@ module RuboCop
           # ...then each key/value pair is treated as a method 'argument'
           # when determining where line breaks should appear.
           if (last_arg = args.last)
-            if last_arg.hash_type? && !last_arg.braces?
-              args = args.concat(args.pop.children)
-            end
+            args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
           end
 
           check_line_breaks(node, args)

data/lib/rubocop/cop/layout/multiline_method_call_indentation.rb

@@ -193,7 +193,7 @@ module RuboCop
           node = node.receiver while node.receiver
           # ascend to first call which has a dot
           node = node.parent
-          node = node.parent until node.loc.dot
+          node = node.parent until node.loc.respond_to?(:dot) && node.loc.dot
 
           return if node.loc.dot.line != node.first_line
 

data/lib/rubocop/cop/layout/multiline_operation_indentation.rb

@@ -6,30 +6,39 @@ module RuboCop
       # This cop checks the indentation of the right hand side operand in
       # binary operations that span more than one line.
       #
+      # The `aligned` style checks that operators are aligned if they are part
+      # of an `if` or `while` condition, a `return` statement, etc. In other
+      # contexts, the second operand should be indented regardless of enforced
+      # style.
+      #
       # @example EnforcedStyle: aligned (default)
       #   # bad
       #   if a +
       #       b
-      #     something
+      #     something &&
+      #     something_else
       #   end
       #
       #   # good
       #   if a +
       #      b
-      #     something
+      #     something &&
+      #       something_else
       #   end
       #
       # @example EnforcedStyle: indented
       #   # bad
       #   if a +
       #      b
-      #     something
+      #     something &&
+      #     something_else
       #   end
       #
       #   # good
       #   if a +
       #       b
-      #     something
+      #     something &&
+      #       something_else
       #   end
       #
       class MultilineOperationIndentation < Cop

data/lib/rubocop/cop/layout/space_around_block_parameters.rb

@@ -43,11 +43,11 @@ module RuboCop
           lambda do |corrector|
             if target.is_a?(RuboCop::AST::Node)
               if target.parent.children.first == target
-                corrector.insert_before(target.source_range, ' ')
+                corrector.insert_before(target, ' ')
               else
-                corrector.insert_after(target.source_range, ' ')
+                corrector.insert_after(target, ' ')
               end
-            elsif target.source =~ /^\s+$/
+            elsif /^\s+$/.match?(target.source)
               corrector.remove(target)
             else
               corrector.insert_after(target, ' ')

data/lib/rubocop/cop/layout/space_around_method_call_operator.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks method call operators to not have spaces around them.
+      #
+      # @example
+      #   # bad
+      #   foo. bar
+      #   foo .bar
+      #   foo . bar
+      #   foo. bar .buzz
+      #   foo
+      #     . bar
+      #     . buzz
+      #   foo&. bar
+      #   foo &.bar
+      #   foo &. bar
+      #   foo &. bar&. buzz
+      #   RuboCop:: Cop
+      #   RuboCop:: Cop:: Cop
+      #   :: RuboCop::Cop
+      #
+      #   # good
+      #   foo.bar
+      #   foo.bar.buzz
+      #   foo
+      #     .bar
+      #     .buzz
+      #   foo&.bar
+      #   foo&.bar&.buzz
+      #   RuboCop::Cop
+      #   RuboCop::Cop::Cop
+      #   ::RuboCop::Cop
+      #
+      class SpaceAroundMethodCallOperator < Cop
+        include SurroundingSpace
+
+        MSG = 'Avoid using spaces around a method call operator.'
+
+        def on_send(node)
+          return unless dot_or_safe_navigation_operator?(node)
+
+          check_and_add_offense(node)
+        end
+
+        def on_const(node)
+          return unless node.loc.double_colon
+
+          check_and_add_offense(node, false)
+        end
+
+        def autocorrect(node)
+          operator = operator_token(node)
+          left = left_token_for_auto_correction(node, operator)
+          right = right_token_for_auto_correction(operator)
+
+          lambda do |corrector|
+            SpaceCorrector.remove_space(
+              processed_source, corrector, left, right
+            )
+          end
+        end
+
+        alias on_csend on_send
+
+        private
+
+        def check_and_add_offense(node, add_left_offense = true)
+          operator = operator_token(node)
+          left = previous_token(operator)
+          right = next_token(operator)
+
+          no_space_offenses(node, operator, right, MSG) if !right.comment? && valid_right_token?(right, operator)
+          return unless valid_left_token?(left, operator)
+
+          no_space_offenses(node, left, operator, MSG) if add_left_offense
+        end
+
+        def operator_token(node)
+          operator_location =
+            node.const_type? ? node.loc.double_colon : node.loc.dot
+
+          processed_source.find_token do |token|
+            token.pos == operator_location
+          end
+        end
+
+        def previous_token(current_token)
+          index = processed_source.tokens.index(current_token)
+          index.zero? ? nil : processed_source.tokens[index - 1]
+        end
+
+        def next_token(current_token)
+          index = processed_source.tokens.index(current_token)
+          processed_source.tokens[index + 1]
+        end
+
+        def dot_or_safe_navigation_operator?(node)
+          node.dot? || node.safe_navigation?
+        end
+
+        def valid_left_token?(left, operator)
+          left && left.line == operator.line
+        end
+
+        def valid_right_token?(right, operator)
+          right && right.line == operator.line
+        end
+
+        def left_token_for_auto_correction(node, operator)
+          left_token = previous_token(operator)
+          return operator if node.const_type?
+          return left_token if valid_left_token?(left_token, operator)
+
+          operator
+        end
+
+        def right_token_for_auto_correction(operator)
+          right_token = next_token(operator)
+          return right_token if !right_token.comment? && valid_right_token?(right_token, operator)
+
+          operator
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -139,7 +139,7 @@ module RuboCop
             elsif range.source.end_with?("\n")
               corrector.replace(range, " #{range.source.strip}\n")
             else
-              corrector.replace(range, " #{range.source.strip} ")
+              enclose_operator_with_space(corrector, range)
             end
           end
         end
@@ -170,12 +170,25 @@ module RuboCop
           yield msg if msg
         end
 
+        def enclose_operator_with_space(corrector, range)
+          operator = range.source
+
+          # If `ForceEqualSignAlignment` is true, `Layout/ExtraSpacing` cop
+          # inserts spaces before operator. If `Layout/SpaceAroundOperators` cop
+          # inserts a space, it collides and raises the infinite loop error.
+          if force_equal_sign_alignment?
+            corrector.insert_after(range, ' ') unless operator.end_with?(' ')
+          else
+            corrector.replace(range, " #{operator.strip} ")
+          end
+        end
+
         def offense_message(type, operator, with_space, right_operand)
           if should_not_have_surrounding_space?(operator)
             return if with_space.is?(operator.source)
 
             "Space around operator `#{operator.source}` detected."
-          elsif with_space.source !~ /^\s.*\s$/
+          elsif !/^\s.*\s$/.match?(with_space.source)
             "Surrounding space missing for operator `#{operator.source}`."
           elsif excess_leading_space?(type, operator, with_space) ||
                 excess_trailing_space?(right_operand, with_space)
@@ -216,6 +229,10 @@ module RuboCop
           cop_config['EnforcedStyleForExponentOperator'] == 'space'
         end
 
+        def force_equal_sign_alignment?
+          config.for_cop('Layout/ExtraSpacing')['ForceEqualSignAlignment']
+        end
+
         def should_not_have_surrounding_space?(operator)
           operator.is?('**') ? !space_around_exponent_operator? : false
         end