rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module RuboCop
+  module Cop
+    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/IndentationStyle` cop.
+      # It also ignores a shebang line by default.
+      #
+      # This cop has some autocorrection capabilities.
+      # It can programmatically shorten certain long lines by
+      # inserting line breaks into expressions that can be safely
+      # split across lines. These include arrays, hashes, and
+      # method calls with argument lists.
+      #
+      # If autocorrection is enabled, the following Layout cops
+      # are recommended to further format the broken lines.
+      # (Many of these are enabled by default.)
+      #
+      # * ArgumentAlignment
+      # * BlockAlignment
+      # * BlockDelimiters
+      # * BlockEndNewline
+      # * ClosingParenthesisIndentation
+      # * 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
+      # is 25:
+      #
+      # @example
+      #
+      #   # bad
+      #   {foo: "0000000000", bar: "0000000000", baz: "0000000000"}
+      #
+      #   # good
+      #   {foo: "0000000000",
+      #   bar: "0000000000", baz: "0000000000"}
+      #
+      #   # good (with recommended cops enabled)
+      #   {
+      #     foo: "0000000000",
+      #     bar: "0000000000",
+      #     baz: "0000000000",
+      #   }
+      class LineLength < Cop
+        include CheckLineBreakable
+        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
+        alias on_array on_potential_breakable_node
+        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)
+          end
+        end
+
+        def autocorrect(range)
+          return if range.nil?
+
+          lambda do |corrector|
+            corrector.insert_before(range, "\n")
+          end
+        end
+
+        private
+
+        def check_for_breakable_node(node)
+          breakable_node = extract_breakable_node(node, max)
+          return if breakable_node.nil?
+
+          line_index = breakable_node.first_line - 1
+          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 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 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 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 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
+
+          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 heredocs
+          @heredocs ||= extract_heredocs(processed_source.ast)
+        end
+
+        def highlight_start(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)
+          return if line_length(line) <= max
+          return if ignored_line?(line, line_index)
+
+          if ignore_cop_directives? && directive_on_source_line?(line_index)
+            return check_directive_line(line, line_index)
+          end
+          return check_uri_line(line, line_index) if allow_uri?
+
+          register_offense(
+            excess_range(nil, line, line_index),
+            line,
+            line_index
+          )
+        end
+
+        def ignored_line?(line, line_index)
+          matches_ignored_pattern?(line) ||
+            shebang?(line, line_index) ||
+            heredocs && line_in_permitted_heredoc?(line_index.succ)
+        end
+
+        def shebang?(line, line_index)
+          line_index.zero? && line.start_with?('#!')
+        end
+
+        def register_offense(loc, line, line_index)
+          message = format(MSG, length: line_length(line), max: max)
+
+          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 excess_range(uri_range, line, line_index)
+          excessive_position = if uri_range && uri_range.begin < max
+                                 uri_range.end
+                               else
+                                 highlight_start(line)
+                               end
+
+          source_range(processed_source.buffer, line_index + 1,
+                       excessive_position...(line_length(line)))
+        end
+
+        def max
+          cop_config['Max']
+        end
+
+        def allow_heredoc?
+          allowed_heredoc
+        end
+
+        def allowed_heredoc
+          cop_config['AllowHeredoc']
+        end
+
+        def extract_heredocs(ast)
+          return [] unless ast
+
+          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+            body = node.location.heredoc_body
+            delimiter = node.location.heredoc_end.source.strip
+            [body.first_line...body.last_line, delimiter]
+          end
+        end
+
+        def line_in_permitted_heredoc?(line_number)
+          return false unless allowed_heredoc
+
+          heredocs.any? do |range, delimiter|
+            range.cover?(line_number) &&
+              (allowed_heredoc == true || allowed_heredoc.include?(delimiter))
+          end
+        end
+
+        def line_in_heredoc?(line_number)
+          heredocs.any? do |range, _delimiter|
+            range.cover?(line_number)
+          end
+        end
+
+        def check_directive_line(line, line_index)
+          return if line_length_without_directive(line) <= max
+
+          range = max..(line_length_without_directive(line) - 1)
+          register_offense(
+            source_range(
+              processed_source.buffer,
+              line_index + 1,
+              range
+            ),
+            line,
+            line_index
+          )
+        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)
+
+          register_offense(
+            excess_range(uri_range, line, line_index),
+            line,
+            line_index
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Layout
       # This cop checks that the closing brace in an array literal is either
-      # on the same line as the last array element, or a new line.
+      # on the same line as the last array element or on a new line.
       #
       # When using the `symmetrical` (default) style:
       #
@@ -26,55 +26,92 @@ module RuboCop
       # The closing brace of a multi-line array literal must be on the same
       # line as the last element of the array.
       #
-      # @example
+      # @example EnforcedStyle: symmetrical (default)
+      #     # bad
+      #     [ :a,
+      #       :b
+      #     ]
       #
-      #     # symmetrical: bad
-      #     # new_line: good
-      #     # same_line: bad
+      #     # bad
+      #     [
+      #       :a,
+      #       :b ]
+      #
+      #     # good
       #     [ :a,
+      #       :b ]
+      #
+      #     # good
+      #     [
+      #       :a,
       #       :b
       #     ]
       #
-      #     # symmetrical: bad
-      #     # new_line: bad
-      #     # same_line: good
+      # @example EnforcedStyle: new_line
+      #     # bad
       #     [
       #       :a,
       #       :b ]
       #
-      #     # symmetrical: good
-      #     # new_line: bad
-      #     # same_line: good
+      #     # bad
       #     [ :a,
       #       :b ]
       #
-      #     # symmetrical: good
-      #     # new_line: good
-      #     # same_line: bad
+      #     # good
+      #     [ :a,
+      #       :b
+      #     ]
+      #
+      #     # good
       #     [
       #       :a,
       #       :b
       #     ]
+      #
+      # @example EnforcedStyle: same_line
+      #     # bad
+      #     [ :a,
+      #       :b
+      #     ]
+      #
+      #     # bad
+      #     [
+      #       :a,
+      #       :b
+      #     ]
+      #
+      #     # good
+      #     [
+      #       :a,
+      #       :b ]
+      #
+      #     # good
+      #     [ :a,
+      #       :b ]
       class MultilineArrayBraceLayout < Cop
         include MultilineLiteralBraceLayout
 
-        SAME_LINE_MESSAGE = 'Closing array brace must be on the same line as ' \
-          'the last array element when opening brace is on the same line as ' \
-          'the first array element.'.freeze
+        SAME_LINE_MESSAGE = 'The closing array brace must be on the same ' \
+          'line as the last array element when the opening brace is on the ' \
+          'same line as the first array element.'
 
-        NEW_LINE_MESSAGE = 'Closing array brace must be on the line after ' \
-          'the last array element when opening brace is on a separate line ' \
-          'from the first array element.'.freeze
+        NEW_LINE_MESSAGE = 'The closing array brace must be on the line ' \
+          'after the last array element when the opening brace is on a ' \
+          'separate line from the first array element.'
 
-        ALWAYS_NEW_LINE_MESSAGE = 'Closing array brace must be on the line ' \
-          'after the last array element.'.freeze
+        ALWAYS_NEW_LINE_MESSAGE = 'The closing array brace must be on the ' \
+          'line after the last array element.'
 
-        ALWAYS_SAME_LINE_MESSAGE = 'Closing array brace must be on the same ' \
-          'line as teh last array element.'.freeze
+        ALWAYS_SAME_LINE_MESSAGE = 'The closing array brace must be on the ' \
+          'same line as the last array element.'
 
         def on_array(node)
           check_brace_layout(node)
         end
+
+        def autocorrect(node)
+          MultilineLiteralBraceCorrector.new(node, processed_source)
+        end
       end
     end
   end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop ensures that each item in a multi-line array
+      # starts on a separate line.
+      #
+      # @example
+      #
+      #   # bad
+      #   [
+      #     a, b,
+      #     c
+      #   ]
+      #
+      #   # good
+      #   [
+      #     a,
+      #     b,
+      #     c
+      #   ]
+      class MultilineArrayLineBreaks < Cop
+        include MultilineElementLineBreaks
+
+        MSG = 'Each item in a multi-line array must start ' \
+          'on a separate line.'
+
+        def on_array(node)
+          check_line_breaks(node, node.children)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
+      end
+    end
+  end
+end

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

@@ -6,45 +6,52 @@ module RuboCop
       # This cop checks whether the multiline assignments have a newline
       # after the assignment operator.
       #
-      # @example
-      #   # bad (with EnforcedStyle set to new_line)
+      # @example EnforcedStyle: new_line (default)
+      #   # bad
       #   foo = if expression
       #     'bar'
       #   end
       #
-      #   # good (with EnforcedStyle set to same_line)
-      #   foo = if expression
-      #     'bar'
-      #   end
-      #
-      #   # good (with EnforcedStyle set to new_line)
+      #   # good
       #   foo =
       #     if expression
       #       'bar'
       #     end
       #
-      #   # good (with EnforcedStyle set to new_line)
+      #   # good
       #   foo =
       #     begin
       #       compute
       #     rescue => e
       #       nil
       #     end
+      #
+      # @example EnforcedStyle: same_line
+      #   # good
+      #   foo = if expression
+      #     'bar'
+      #   end
       class MultilineAssignmentLayout < Cop
         include CheckAssignment
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         NEW_LINE_OFFENSE = 'Right hand side of multi-line assignment is on ' \
-          'the same line as the assignment operator `=`.'.freeze
+          'the same line as the assignment operator `=`.'
 
         SAME_LINE_OFFENSE = 'Right hand side of multi-line assignment is not ' \
-          'on the same line as the assignment operator `=`.'.freeze
+          'on the same line as the assignment operator `=`.'
 
         def check_assignment(node, rhs)
+          return if node.send_type? && node.loc.operator&.source != '='
           return unless rhs
           return unless supported_types.include?(rhs.type)
-          return if rhs.loc.first_line == rhs.loc.last_line
+          return if rhs.first_line == rhs.last_line
+
+          check_by_enforced_style(node, rhs)
+        end
 
+        def check_by_enforced_style(node, rhs)
           case style
           when :new_line
             check_new_line_offense(node, rhs)
@@ -54,13 +61,13 @@ module RuboCop
         end
 
         def check_new_line_offense(node, rhs)
-          return unless node.loc.operator.line == rhs.loc.line
+          return unless node.loc.operator.line == rhs.first_line
 
           add_offense(node, message: NEW_LINE_OFFENSE)
         end
 
         def check_same_line_offense(node, rhs)
-          return unless node.loc.operator.line != rhs.loc.line
+          return unless node.loc.operator.line != rhs.first_line
 
           add_offense(node, message: SAME_LINE_OFFENSE)
         end

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

@@ -5,7 +5,9 @@ module RuboCop
     module Layout
       # This cop checks whether the multiline do end blocks have a newline
       # after the start of the block. Additionally, it checks whether the block
-      # arguments, if any, are on the same line as the start of the block.
+      # arguments, if any, are on the same line as the start of the
+      # block. Putting block arguments on separate lines, because the whole
+      # line would otherwise be too long, is accepted.
       #
       # @example
       #   # bad
@@ -35,38 +37,39 @@ module RuboCop
       #     foo(i)
       #     bar(i)
       #   }
+      #
+      #   # good
+      #   blah { |
+      #     long_list,
+      #     of_parameters,
+      #     that_would_not,
+      #     fit_on_one_line
+      #   |
+      #     foo(i)
+      #     bar(i)
+      #   }
       class MultilineBlockLayout < Cop
+        include RangeHelp
+
         MSG = 'Block body expression is on the same line as ' \
-              'the block start.'.freeze
+              'the block start.'
         ARG_MSG = 'Block argument expression is not on the same line as the ' \
-                  'block start.'.freeze
+                  'block start.'
+        PIPE_SIZE = '|'.length
 
         def on_block(node)
           return if node.single_line?
 
-          unless args_on_beginning_line?(node)
+          unless args_on_beginning_line?(node) ||
+                 line_break_necessary_in_args?(node)
             add_offense_for_expression(node, node.arguments, ARG_MSG)
           end
 
-          return unless node.body && node.loc.begin.line == node.body.loc.line
+          return unless node.body && node.loc.begin.line == node.body.first_line
 
           add_offense_for_expression(node, node.body, MSG)
         end
 
-        private
-
-        def args_on_beginning_line?(node)
-          !node.arguments? ||
-            node.loc.begin.line == node.arguments.loc.last_line
-        end
-
-        def add_offense_for_expression(node, expr, msg)
-          expression = expr.source_range
-          range = range_between(expression.begin_pos, expression.end_pos)
-
-          add_offense(node, location: range, message: msg)
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             unless args_on_beginning_line?(node)
@@ -78,21 +81,46 @@ module RuboCop
 
             expr_before_body ||= node.loc.begin
 
-            if expr_before_body.line == node.body.loc.line
+            if expr_before_body.line == node.body.first_line
               autocorrect_body(corrector, node, node.body)
             end
           end
         end
 
+        private
+
+        def args_on_beginning_line?(node)
+          !node.arguments? ||
+            node.loc.begin.line == node.arguments.loc.last_line
+        end
+
+        def line_break_necessary_in_args?(node)
+          needed_length = node.source_range.column +
+                          node.source.lines.first.length +
+                          block_arg_string(node, node.arguments).length +
+                          PIPE_SIZE
+          needed_length > max_line_length
+        end
+
+        def add_offense_for_expression(node, expr, msg)
+          expression = expr.source_range
+          range = range_between(expression.begin_pos, expression.end_pos)
+          add_offense(node, location: range, message: msg)
+        end
+
         def autocorrect_arguments(corrector, node)
-          end_pos = range_with_surrounding_space(node.arguments.source_range,
-                                                 :right, false).end_pos
+          end_pos = range_with_surrounding_space(
+            range: node.arguments.source_range,
+            side: :right,
+            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)
-          first_node = if block_body.begin_type?
+          first_node = if block_body.begin_type? && !block_body.source.start_with?('(')
                          block_body.children.first
                        else
                          block_body
@@ -100,18 +128,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