rubocop 0.76.0 → 0.83.0

data/lib/rubocop/cop/{metrics → layout}/line_length.rb

@@ -2,14 +2,13 @@
 
 require 'uri'
 
-# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
-    module Metrics
+    module Layout
       # 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.
@@ -20,19 +19,25 @@ module RuboCop
       #
       # If autocorrection is enabled, the following Layout cops
       # are recommended to further format the broken lines.
+      # (Many of these are enabled by default.)
       #
-      #   - AlignArray
-      #   - AlignHash
-      #   - AlignParameters
+      #   - ArgumentAlignment
+      #   - BlockAlignment
+      #   - BlockDelimiters
+      #   - BlockEndNewline
       #   - ClosingParenthesisIndentation
-      #   - IndentFirstArgument
-      #   - IndentFirstArrayElement
-      #   - IndentFirstHashElement
-      #   - IndentFirstParameter
+      #   - FirstArgumentIndentation
+      #   - FirstArrayElementIndentation
+      #   - FirstHashElementIndentation
+      #   - FirstParameterIndentation
+      #   - HashAlignment
+      #   - IndentationWidth
       #   - MultilineArrayLineBreaks
+      #   - MultilineBlockLayout
       #   - MultilineHashBraceLayout
       #   - MultilineHashKeyLineBreaks
       #   - MultilineMethodArgumentLineBreaks
+      #   - ParameterAlignment
       #
       # Together, these cops will pretty print hashes, arrays,
       # method calls, etc. For example, let's say the max columns
@@ -58,9 +63,14 @@ module RuboCop
         include ConfigurableMax
         include IgnoredPattern
         include RangeHelp
+        include LineLengthHelp
 
         MSG = 'Line is too long. [%<length>d/%<max>d]'
 
+        def on_block(node)
+          check_for_breakable_block(node)
+        end
+
         def on_potential_breakable_node(node)
           check_for_breakable_node(node)
         end
@@ -68,6 +78,10 @@ module RuboCop
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
 
+        def investigate(processed_source)
+          check_for_breakable_semicolons(processed_source)
+        end
+
         def investigate_post_walk(processed_source)
           processed_source.lines.each_with_index do |line, line_index|
             check_line(line, line_index)
@@ -89,33 +103,67 @@ module RuboCop
           return if breakable_node.nil?
 
           line_index = breakable_node.first_line - 1
-          breakable_nodes_by_line_index[line_index] = breakable_node
+          range = breakable_node.source_range
+
+          existing = breakable_range_by_line_index[line_index]
+          return if existing
+
+          breakable_range_by_line_index[line_index] = range
         end
 
-        def breakable_nodes_by_line_index
-          @breakable_nodes_by_line_index ||= {}
+        def check_for_breakable_semicolons(processed_source)
+          tokens = processed_source.tokens.select { |t| t.type == :tSEMI }
+          tokens.reverse_each do |token|
+            range = breakable_range_after_semicolon(token)
+            breakable_range_by_line_index[range.line - 1] = range if range
+          end
         end
 
-        def heredocs
-          @heredocs ||= extract_heredocs(processed_source.ast)
+        def check_for_breakable_block(block_node)
+          return unless block_node.single_line?
+
+          line_index = block_node.loc.line - 1
+          range = breakable_block_range(block_node)
+          pos = range.begin_pos + 1
+
+          breakable_range_by_line_index[line_index] =
+            range_between(pos, pos + 1)
         end
 
-        def tab_indentation_width
-          config.for_cop('Layout/Tab')['IndentationWidth']
+        def breakable_block_range(block_node)
+          if block_node.arguments? && !block_node.lambda?
+            block_node.arguments.loc.end
+          else
+            block_node.loc.begin
+          end
         end
 
-        def indentation_difference(line)
-          return 0 unless tab_indentation_width
+        def breakable_range_after_semicolon(semicolon_token)
+          range = semicolon_token.pos
+          end_pos = range.end_pos
+          next_range = range_between(end_pos, end_pos + 1)
+          return nil unless next_range.line == range.line
 
-          line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+          next_char = next_range.source
+          return nil if /[\r\n]/.match?(next_char)
+          return nil if next_char == ';'
+
+          next_range
+        end
+
+        def breakable_range_by_line_index
+          @breakable_range_by_line_index ||= {}
         end
 
-        def line_length(line)
-          line.length + indentation_difference(line)
+        def heredocs
+          @heredocs ||= extract_heredocs(processed_source.ast)
         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)
@@ -147,33 +195,12 @@ module RuboCop
         def register_offense(loc, line, line_index)
           message = format(MSG, length: line_length(line), max: max)
 
-          breakable_range = breakable_range(line, line_index)
+          breakable_range = breakable_range_by_line_index[line_index]
           add_offense(breakable_range, location: loc, message: message) do
             self.max = line_length(line)
           end
         end
 
-        def breakable_range(line, line_index)
-          return if line_in_heredoc?(line_index + 1)
-
-          semicolon_range = breakable_semicolon_range(line, line_index)
-          return semicolon_range if semicolon_range
-
-          breakable_node = breakable_nodes_by_line_index[line_index]
-          return breakable_node.source_range if breakable_node
-        end
-
-        def breakable_semicolon_range(line, line_index)
-          semicolon_separated_parts = line.split(';')
-          return if semicolon_separated_parts.length <= 1
-
-          column = semicolon_separated_parts.first.length + 1
-          range = source_range(processed_source.buffer, line_index, column, 1)
-          return if processed_source.commented?(range)
-
-          range
-        end
-
         def excess_range(uri_range, line, line_index)
           excessive_position = if uri_range && uri_range.begin < max
                                  uri_range.end
@@ -222,53 +249,6 @@ module RuboCop
           end
         end
 
-        def allow_uri?
-          cop_config['AllowURI']
-        end
-
-        def ignore_cop_directives?
-          cop_config['IgnoreCopDirectives']
-        end
-
-        def allowed_uri_position?(line, uri_range)
-          uri_range.begin < max &&
-            (uri_range.end == line_length(line) ||
-             uri_range.end == line_length(line) - 1)
-        end
-
-        def find_excessive_uri_range(line)
-          last_uri_match = match_uris(line).last
-          return nil unless last_uri_match
-
-          begin_position, end_position =
-            last_uri_match.offset(0).map do |pos|
-              pos + indentation_difference(line)
-            end
-          return nil if begin_position < max && end_position < max
-
-          begin_position...end_position
-        end
-
-        def match_uris(string)
-          matches = []
-          string.scan(uri_regexp) do
-            matches << $LAST_MATCH_INFO if valid_uri?($LAST_MATCH_INFO[0])
-          end
-          matches
-        end
-
-        def valid_uri?(uri_ish_string)
-          URI.parse(uri_ish_string)
-          true
-        rescue URI::InvalidURIError, NoMethodError
-          false
-        end
-
-        def uri_regexp
-          @uri_regexp ||=
-            URI::DEFAULT_PARSER.make_regexp(cop_config['URISchemes'])
-        end
-
         def check_directive_line(line, line_index)
           return if line_length_without_directive(line) <= max
 
@@ -284,23 +264,6 @@ module RuboCop
           )
         end
 
-        def directive_on_source_line?(line_index)
-          source_line_number = line_index + processed_source.buffer.first_line
-          comment =
-            processed_source
-            .comments
-            .detect { |e| e.location.line == source_line_number }
-
-          return false unless comment
-
-          comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-        end
-
-        def line_length_without_directive(line)
-          before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-          before_comment.rstrip.length
-        end
-
         def check_uri_line(line, line_index)
           uri_range = find_excessive_uri_range(line)
           return if uri_range && allowed_uri_position?(line, uri_range)
@@ -315,4 +278,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Metrics/ClassLength

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

@@ -97,7 +97,8 @@ module RuboCop
         def line_break_necessary_in_args?(node)
           needed_length = node.source_range.column +
                           node.source.lines.first.length +
-                          block_arg_string(node.arguments).length + PIPE_SIZE
+                          block_arg_string(node, node.arguments).length +
+                          PIPE_SIZE
           needed_length > max_line_length
         end
 
@@ -115,7 +116,8 @@ module RuboCop
             newlines: false
           ).end_pos
           range = range_between(node.loc.begin.end.begin_pos, end_pos)
-          corrector.replace(range, " |#{block_arg_string(node.arguments)}|")
+          corrector.replace(range,
+                            " |#{block_arg_string(node, node.arguments)}|")
         end
 
         def autocorrect_body(corrector, node, block_body)
@@ -127,18 +129,25 @@ 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
 
-        def block_arg_string(args)
-          args.children.map do |arg|
+        def block_arg_string(node, args)
+          arg_string = args.children.map do |arg|
             if arg.mlhs_type?
-              "(#{block_arg_string(arg)})"
+              "(#{block_arg_string(node, arg)})"
             else
               arg.source
             end
           end.join(', ')
+          arg_string += ',' if include_trailing_comma?(node.arguments)
+          arg_string
+        end
+
+        def include_trailing_comma?(args)
+          arg_count = args.each_descendant(:arg).to_a.size
+          arg_count == 1 && args.source.include?(',')
         end
       end
     end

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

@@ -105,10 +105,6 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing hash brace must be on the same ' \
           'line as the last hash element.'
 
-        def self.autocorrect_incompatible_with
-          [Style::BracesAroundHashParameters]
-        end
-
         def on_hash(node)
           check_brace_layout(node)
         end

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

@@ -26,7 +26,7 @@ module RuboCop
           'on a separate line.'
 
         def on_send(node)
-          return if node.method_name == :[]=
+          return if node.method?(:[]=)
 
           args = node.arguments
 

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/{align_parameters.rb → parameter_alignment.rb}

@@ -68,7 +68,7 @@ module RuboCop
       #        baz)
       #     123
       #   end
-      class AlignParameters < Cop
+      class ParameterAlignment < Cop
         include Alignment
 
         ALIGN_PARAMS_MSG = 'Align the parameters of a method definition if ' \

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_keyword.rb

@@ -30,10 +30,12 @@ module RuboCop
 
         DO = 'do'
         SAFE_NAVIGATION = '&.'
+        NAMESPACE_OPERATOR = '::'
         ACCEPT_LEFT_PAREN =
           %w[break defined? next not rescue return super yield].freeze
         ACCEPT_LEFT_SQUARE_BRACKET =
           %w[super yield].freeze
+        ACCEPT_NAMESPACE_OPERATOR = 'super'
 
         def on_and(node)
           check(node, [:operator].freeze) if node.keyword?
@@ -193,6 +195,8 @@ module RuboCop
 
           return false if accepted_opening_delimiter?(range, char)
           return false if safe_navigation_call?(range, pos)
+          return false if accept_namespace_operator?(range) &&
+                          namespace_operator?(range, pos)
 
           char !~ /[\s;,#\\\)\}\]\.]/
         end
@@ -212,10 +216,18 @@ module RuboCop
           ACCEPT_LEFT_SQUARE_BRACKET.include?(range.source)
         end
 
+        def accept_namespace_operator?(range)
+          ACCEPT_NAMESPACE_OPERATOR == range.source
+        end
+
         def safe_navigation_call?(range, pos)
           range.source_buffer.source[pos, 2].start_with?(SAFE_NAVIGATION)
         end
 
+        def namespace_operator?(range, pos)
+          range.source_buffer.source[pos, 2].start_with?(NAMESPACE_OPERATOR)
+        end
+
         def preceded_by_operator?(node, _range)
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them

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

@@ -0,0 +1,133 @@
+# 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)
+
+          if !right.comment? && valid_right_token?(right, operator)
+            no_space_offenses(node, operator, right, MSG)
+          end
+          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)
+          if !right_token.comment? && valid_right_token?(right_token, operator)
+            return right_token
+          end
+
+          operator
+        end
+      end
+    end
+  end
+end