rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for the placement of the closing parenthesis
+      # in a method call that passes a HEREDOC string as an argument.
+      # It should be placed at the end of the line containing the
+      # opening HEREDOC tag.
+      #
+      # @example
+      #   # bad
+      #
+      #      foo(<<-SQL
+      #        bar
+      #      SQL
+      #      )
+      #
+      #      foo(<<-SQL, 123, <<-NOSQL,
+      #        bar
+      #      SQL
+      #        baz
+      #      NOSQL
+      #      )
+      #
+      #      foo(
+      #        bar(<<-SQL
+      #          baz
+      #        SQL
+      #        ),
+      #        123,
+      #      )
+      #
+      #   # good
+      #
+      #      foo(<<-SQL)
+      #        bar
+      #      SQL
+      #
+      #      foo(<<-SQL, 123, <<-NOSQL)
+      #        bar
+      #      SQL
+      #        baz
+      #      NOSQL
+      #
+      #      foo(
+      #        bar(<<-SQL),
+      #          baz
+      #        SQL
+      #        123,
+      #      )
+      #
+      class HeredocArgumentClosingParenthesis < Cop
+        include RangeHelp
+
+        MSG = 'Put the closing parenthesis for a method call with a ' \
+        'HEREDOC parameter on the same line as the HEREDOC opening.'
+
+        def on_send(node)
+          heredoc_arg = extract_heredoc_argument(node)
+          return unless heredoc_arg
+
+          outermost_send = outermost_send_on_same_line(heredoc_arg)
+          return unless outermost_send
+          return unless outermost_send.loc.end
+          return unless heredoc_arg.first_line != outermost_send.loc.end.line
+
+          add_offense(outermost_send, location: :end)
+        end
+
+        # Autocorrection note:
+        #
+        # Commas are a bit tricky to handle when the method call is
+        # embedded in another expression. Here's an example:
+        #
+        # [
+        #   first_array_value,
+        #   foo(<<-SQL, 123, 456,
+        #     SELECT * FROM db
+        #   SQL
+        #   ),
+        #   third_array_value,
+        # ]
+        #
+        # The "internal" trailing comma is after `456`.
+        # The "external" trailing comma is after `)`.
+        #
+        # To autocorrect, we remove the latter, and move the former up:
+        #
+        # [
+        #   first_array_value,
+        #   foo(<<-SQL, 123, 456),
+        #     SELECT * FROM db
+        #   SQL
+        #   third_array_value,
+        # ]
+        def autocorrect(node)
+          lambda do |corrector|
+            fix_closing_parenthesis(node, corrector)
+
+            remove_internal_trailing_comma(node, corrector) if internal_trailing_comma?(node)
+
+            fix_external_trailing_comma(node, corrector) if external_trailing_comma?(node)
+          end
+        end
+
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInArguments]
+        end
+
+        private
+
+        def outermost_send_on_same_line(heredoc)
+          previous = heredoc
+          current = previous.parent
+          until send_missing_closing_parens?(current, previous, heredoc)
+            previous = current
+            current = current.parent
+            return unless previous && current
+          end
+          current
+        end
+
+        def send_missing_closing_parens?(parent, child, heredoc)
+          parent&.call_type? &&
+            parent.arguments.include?(child) &&
+            parent.loc.begin &&
+            parent.loc.end.line != heredoc.last_line
+        end
+
+        def extract_heredoc_argument(node)
+          node.arguments.find do |arg_node|
+            extract_heredoc(arg_node)
+          end
+        end
+
+        def extract_heredoc(node)
+          return node if heredoc_node?(node)
+          return node.receiver if single_line_send_with_heredoc_receiver?(node)
+
+          return unless node.hash_type?
+
+          node.values.find do |v|
+            heredoc = extract_heredoc(v)
+            return heredoc if heredoc
+          end
+        end
+
+        def heredoc_node?(node)
+          node.respond_to?(:heredoc?) && node.heredoc?
+        end
+
+        def single_line_send_with_heredoc_receiver?(node)
+          return false unless node.send_type?
+          return false unless heredoc_node?(node.receiver)
+
+          node.receiver.location.heredoc_end.end_pos > node.source_range.end_pos
+        end
+
+        # Closing parenthesis helpers.
+
+        def fix_closing_parenthesis(node, corrector)
+          remove_incorrect_closing_paren(node, corrector)
+          add_correct_closing_paren(node, corrector)
+        end
+
+        def add_correct_closing_paren(node, corrector)
+          corrector.insert_after(node.arguments.last, ')')
+        end
+
+        def remove_incorrect_closing_paren(node, corrector)
+          corrector.remove(
+            range_between(
+              incorrect_parenthesis_removal_begin(node),
+              incorrect_parenthesis_removal_end(node)
+            )
+          )
+        end
+
+        def incorrect_parenthesis_removal_begin(node)
+          end_pos = node.source_range.end_pos
+          if safe_to_remove_line_containing_closing_paren?(node)
+            last_line_length = node.source.scan(/\n(.*)$/).last[0].size
+            end_pos - last_line_length - 1 # Add one for the line break itself.
+          else
+            end_pos - 1 # Just the `)` at the end of the string
+          end
+        end
+
+        def safe_to_remove_line_containing_closing_paren?(node)
+          last_line = processed_source[node.loc.end.line - 1]
+          # Safe to remove if last line only contains `)`, `,`, and whitespace.
+          last_line.match?(/^ *\) {0,20},{0,1} *$/)
+        end
+
+        def incorrect_parenthesis_removal_end(node)
+          end_pos = node.source_range.end_pos
+          if processed_source.buffer.source[end_pos] == ','
+            end_pos + 1
+          else
+            end_pos
+          end
+        end
+
+        # Internal trailing comma helpers.
+
+        def remove_internal_trailing_comma(node, corrector)
+          offset = internal_trailing_comma_offset_from_last_arg(node)
+          last_arg_end_pos = node.children.last.source_range.end_pos
+          corrector.remove(
+            range_between(
+              last_arg_end_pos,
+              last_arg_end_pos + offset
+            )
+          )
+        end
+
+        def internal_trailing_comma?(node)
+          !internal_trailing_comma_offset_from_last_arg(node).nil?
+        end
+
+        # Returns nil if no trailing internal comma.
+        def internal_trailing_comma_offset_from_last_arg(node)
+          source_after_last_arg = range_between(
+            node.children.last.source_range.end_pos,
+            node.loc.end.begin_pos
+          ).source
+
+          first_comma_offset = source_after_last_arg.index(',')
+          first_new_line_offset = source_after_last_arg.index("\n")
+          return if first_comma_offset.nil?
+          return if first_new_line_offset.nil?
+          return if first_comma_offset > first_new_line_offset
+
+          first_comma_offset + 1
+        end
+
+        # External trailing comma helpers.
+
+        def fix_external_trailing_comma(node, corrector)
+          remove_incorrect_external_trailing_comma(node, corrector)
+          add_correct_external_trailing_comma(node, corrector)
+        end
+
+        def add_correct_external_trailing_comma(node, corrector)
+          return unless external_trailing_comma?(node)
+
+          corrector.insert_after(node.arguments.last, ',')
+        end
+
+        def remove_incorrect_external_trailing_comma(node, corrector)
+          end_pos = node.source_range.end_pos
+          return unless external_trailing_comma?(node)
+
+          corrector.remove(
+            range_between(
+              end_pos,
+              end_pos + external_trailing_comma_offset_from_loc_end(node)
+            )
+          )
+        end
+
+        def external_trailing_comma?(node)
+          !external_trailing_comma_offset_from_loc_end(node).nil?
+        end
+
+        # Returns nil if no trailing external comma.
+        def external_trailing_comma_offset_from_loc_end(node)
+          end_pos = node.source_range.end_pos
+          offset = 0
+          limit = 20
+          offset += 1 while offset < limit && space?(end_pos + offset)
+          char = processed_source.buffer.source[end_pos + offset]
+          return unless char == ','
+
+          offset + 1 # Add one to include the comma.
+        end
+
+        def space?(pos)
+          processed_source.buffer.source[pos] == ' '
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of the here document bodies. The bodies
+      # are indented one step.
+      #
+      # Note: When ``Layout/LineLength``'s `AllowHeredoc` is false (not default),
+      #       this cop does not add any offenses for long here documents to
+      #       avoid `Layout/LineLength`'s offenses.
+      #
+      # @example
+      #   # bad
+      #   <<-RUBY
+      #   something
+      #   RUBY
+      #
+      #   # good
+      #   <<~RUBY
+      #     something
+      #   RUBY
+      #
+      #
+      class HeredocIndentation < Cop
+        include Heredoc
+
+        TYPE_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
+                   'heredoc by using `<<~` instead of `%<current_indent_type>s`.'
+        WIDTH_MSG = 'Use %<indentation_width>d spaces for indentation in a heredoc.'
+
+        def on_heredoc(node)
+          body = heredoc_body(node)
+          return if body.strip.empty?
+
+          body_indent_level = indent_level(body)
+
+          if heredoc_indent_type(node) == '~'
+            expected_indent_level = base_indent_level(node) + indentation_width
+            return if expected_indent_level == body_indent_level
+          else
+            return unless body_indent_level.zero?
+          end
+
+          return if line_too_long?(node)
+
+          add_offense(node, location: :heredoc_body)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if heredoc_indent_type(node) == '~'
+              adjust_squiggly(corrector, node)
+            else
+              adjust_minus(corrector, node)
+            end
+          end
+        end
+
+        private
+
+        def message(node)
+          current_indent_type = "<<#{heredoc_indent_type(node)}"
+
+          if current_indent_type == '<<~'
+            width_message(indentation_width)
+          else
+            type_message(indentation_width, current_indent_type)
+          end
+        end
+
+        def type_message(indentation_width, current_indent_type)
+          format(
+            TYPE_MSG,
+            indentation_width: indentation_width,
+            current_indent_type: current_indent_type
+          )
+        end
+
+        def width_message(indentation_width)
+          format(
+            WIDTH_MSG,
+            indentation_width: indentation_width
+          )
+        end
+
+        def line_too_long?(node)
+          return false if unlimited_heredoc_length?
+
+          body = heredoc_body(node)
+
+          expected_indent = base_indent_level(node) + indentation_width
+          actual_indent = indent_level(body)
+          increase_indent_level = expected_indent - actual_indent
+
+          longest_line(body).size + increase_indent_level >= max_line_length
+        end
+
+        def longest_line(lines)
+          lines.each_line.max_by { |line| line.chomp.size }.chomp
+        end
+
+        def unlimited_heredoc_length?
+          config.for_cop('Layout/LineLength')['AllowHeredoc']
+        end
+
+        def max_line_length
+          config.for_cop('Layout/LineLength')['Max']
+        end
+
+        def adjust_squiggly(corrector, node)
+          corrector.replace(node.loc.heredoc_body, indented_body(node))
+          corrector.replace(node.loc.heredoc_end, indented_end(node))
+        end
+
+        def adjust_minus(corrector, node)
+          heredoc_beginning = node.loc.expression.source
+          corrected = heredoc_beginning.sub(/<<-?/, '<<~')
+          corrector.replace(node, corrected)
+        end
+
+        def indented_body(node)
+          body = heredoc_body(node)
+          body_indent_level = indent_level(body)
+          correct_indent_level = base_indent_level(node) + indentation_width
+          body.gsub(/^[^\S\r\n]{#{body_indent_level}}/,
+                    ' ' * correct_indent_level)
+        end
+
+        def indented_end(node)
+          end_ = heredoc_end(node)
+          end_indent_level = indent_level(end_)
+          correct_indent_level = base_indent_level(node)
+          if end_indent_level < correct_indent_level
+            end_.gsub(/^\s{#{end_indent_level}}/, ' ' * correct_indent_level)
+          else
+            end_
+          end
+        end
+
+        def base_indent_level(node)
+          base_line_num = node.loc.expression.line
+          base_line = processed_source.lines[base_line_num - 1]
+          indent_level(base_line)
+        end
+
+        def indent_level(str)
+          indentations = str.lines
+                            .map { |line| line[/^\s*/] }
+                            .reject { |line| line.end_with?("\n") }
+          indentations.empty? ? 0 : indentations.min_by(&:size).size
+        end
+
+        # Returns '~', '-' or nil
+        def heredoc_indent_type(node)
+          node.source[/^<<([~-])/, 1]
+        end
+
+        def indentation_width
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
+        end
+
+        def heredoc_body(node)
+          node.loc.heredoc_body.source.scrub
+        end
+
+        def heredoc_end(node)
+          node.loc.heredoc_end.source.scrub
+        end
+      end
+    end
+  end
+end

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

@@ -3,21 +3,126 @@
 module RuboCop
   module Cop
     module Layout
-      # This cops checks for inconsistent indentation.
+      # This cop checks for inconsistent indentation.
       #
-      # @example
+      # The difference between `indented_internal_methods` and `normal` is
+      # that the `indented_internal_methods` style prescribes that in
+      # classes and modules the `protected` and `private` modifier keywords
+      # shall be indented the same as public methods and that protected and
+      # private members shall be indented one step more than the modifiers.
+      # Other than that, both styles mean that entities on the same logical
+      # depth shall have the same indentation.
       #
+      # @example EnforcedStyle: normal (default)
+      #   # bad
       #   class A
       #     def test
       #       puts 'hello'
       #        puts 'world'
       #     end
       #   end
+      #
+      #   # bad
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #       puts 'world'
+      #     end
+      #
+      #     protected
+      #
+      #       def foo
+      #       end
+      #
+      #     private
+      #
+      #       def bar
+      #       end
+      #   end
+      #
+      #   # good
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #       puts 'world'
+      #     end
+      #   end
+      #
+      #   # good
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #       puts 'world'
+      #     end
+      #
+      #     protected
+      #
+      #     def foo
+      #     end
+      #
+      #     private
+      #
+      #     def bar
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: indented_internal_methods
+      #   # bad
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #        puts 'world'
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #       puts 'world'
+      #     end
+      #
+      #     protected
+      #
+      #     def foo
+      #     end
+      #
+      #     private
+      #
+      #     def bar
+      #     end
+      #   end
+      #
+      #   # good
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #       puts 'world'
+      #     end
+      #   end
+      #
+      #   # good
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #       puts 'world'
+      #     end
+      #
+      #     protected
+      #
+      #       def foo
+      #       end
+      #
+      #     private
+      #
+      #       def bar
+      #       end
+      #   end
       class IndentationConsistency < Cop
-        include AutocorrectAlignment
+        include Alignment
         include ConfigurableEnforcedStyle
 
-        MSG = 'Inconsistent indentation detected.'.freeze
+        MSG = 'Inconsistent indentation detected.'
 
         def on_begin(node)
           check(node)
@@ -27,17 +132,64 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+
         private
 
+        # Not all nodes define `bare_access_modifier?` (for example,
+        # `RuboCop::AST::DefNode` does not), so we must check `send_type?` first
+        # to avoid a NoMethodError.
+        def bare_access_modifier?(node)
+          node.send_type? && node.bare_access_modifier?
+        end
+
+        # Returns an integer representing the correct indentation, or nil to
+        # indicate that the correct indentation is that of the first child that
+        # is not an access modifier.
+        def base_column_for_normal_style(node)
+          first_child = node.children.first
+          return unless first_child && bare_access_modifier?(first_child)
+
+          # If, as is most common, the access modifier is indented deeper than
+          # the module (`access_modifier_indent > module_indent`) then the
+          # indentation of the access modifier determines the correct
+          # indentation.
+          #
+          # Otherwise, in the rare event that the access modifier is outdented
+          # to the level of the module (see `AccessModifierIndentation` cop) we
+          # return nil so that `check_alignment` will derive the correct
+          # indentation from the first child that is not an access modifier.
+          module_indent = display_column(node.parent.source_range)
+          access_modifier_indent = display_column(first_child.source_range)
+          access_modifier_indent if access_modifier_indent > module_indent
+        end
+
         def check(node)
+          if style == :indented_internal_methods
+            check_indented_internal_methods_style(node)
+          else
+            check_normal_style(node)
+          end
+        end
+
+        def check_normal_style(node)
+          check_alignment(
+            node.children.reject { |child| bare_access_modifier?(child) },
+            base_column_for_normal_style(node)
+          )
+        end
+
+        def check_indented_internal_methods_style(node)
           children_to_check = [[]]
           node.children.each do |child|
             # Modifier nodes have special indentation and will be checked by
             # the AccessModifierIndentation cop. This cop uses them as dividers
-            # in rails mode. Then consistency is checked only within each
-            # section delimited by a modifier node.
-            if child.send_type? && child.access_modifier?
-              children_to_check << [] if style == :rails
+            # in indented_internal_methods mode. Then consistency is checked
+            # only within each section delimited by a modifier node.
+            if bare_access_modifier?(child)
+              children_to_check << []
             else
               children_to_check.last << child
             end