rubocop 0.70.0 → 1.6.1

data/lib/rubocop/cop/layout/{indent_first_hash_element.rb → first_hash_element_indentation.rb}

@@ -5,7 +5,7 @@ module RuboCop
     module Layout
       # This cop checks the indentation of the first key in a hash literal
       # where the opening brace and the first key are on separate lines. The
-      # other keys' indentations are handled by the AlignHash cop.
+      # other keys' indentations are handled by the HashAlignment cop.
       #
       # By default, Hash literals that are arguments in a method call with
       # parentheses, and where the opening curly brace of the hash is on the
@@ -77,7 +77,7 @@ module RuboCop
       #   and_now_for_something = {
       #                             completely: :different
       #                           }
-      class IndentFirstHashElement < Cop
+      class FirstHashElementIndentation < Cop
         include Alignment
         include ConfigurableEnforcedStyle
         include MultilineElementIndentation
@@ -113,7 +113,7 @@ module RuboCop
           first_pair = hash_node.pairs.first
 
           if first_pair
-            return if first_pair.source_range.line == left_brace.line
+            return if first_pair.first_line == left_brace.line
 
             if separator_style?(first_pair)
               check_based_on_longest_key(hash_node, left_brace,
@@ -128,7 +128,7 @@ module RuboCop
 
         def check_right_brace(right_brace, left_brace, left_parenthesis)
           # if the right brace is on the same line as the last value, accept
-          return if right_brace.source_line[0...right_brace.column] =~ /\S/
+          return if /\S/.match?(right_brace.source_line[0...right_brace.column])
 
           expected_column = base_column(left_brace, left_parenthesis)
           @column_delta = expected_column - right_brace.column
@@ -149,7 +149,7 @@ module RuboCop
         def separator_style?(first_pair)
           separator = first_pair.loc.operator
           key = "Enforced#{separator.is?(':') ? 'Colon' : 'HashRocket'}Style"
-          config.for_cop('Layout/AlignHash')[key] == 'separator'
+          config.for_cop('Layout/HashAlignment')[key] == 'separator'
         end
 
         def check_based_on_longest_key(hash_node, left_brace, left_parenthesis)

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

@@ -16,8 +16,9 @@ module RuboCop
       #     {
       #       a: 1,
       #       b: 2 }
-      class FirstHashElementLineBreak < Cop
+      class FirstHashElementLineBreak < Base
         include FirstElementLineBreak
+        extend AutoCorrector
 
         MSG = 'Add a line break before the first element of a ' \
               'multi-line hash.'
@@ -27,10 +28,6 @@ module RuboCop
           # If it doesn't, Style/FirstMethodArgumentLineBreak will handle it
           check_children_line_break(node, node.children) if node.loc.begin
         end
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
       end
     end
   end

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

@@ -20,14 +20,15 @@ module RuboCop
       #     # ignored
       #     method foo, bar,
       #       baz
-      class FirstMethodArgumentLineBreak < Cop
+      class FirstMethodArgumentLineBreak < Base
         include FirstElementLineBreak
+        extend AutoCorrector
 
         MSG = 'Add a line break before the first argument of a ' \
               'multi-line method argument list.'
 
         def on_send(node)
-          args = node.arguments
+          args = node.arguments.dup
 
           # If there is a trailing hash arg without explicit braces, like this:
           #
@@ -35,20 +36,13 @@ 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
-          end
+          last_arg = args.last
+          args.concat(args.pop.children) if last_arg&.hash_type? && !last_arg&.braces?
 
           check_method_line_break(node, args)
         end
         alias on_csend on_send
         alias on_super on_send
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
       end
     end
   end

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

@@ -26,8 +26,9 @@ module RuboCop
       #         bar
       #       do_something
       #     end
-      class FirstMethodParameterLineBreak < Cop
+      class FirstMethodParameterLineBreak < Base
         include FirstElementLineBreak
+        extend AutoCorrector
 
         MSG = 'Add a line break before the first parameter of a ' \
               'multi-line method parameter list.'
@@ -36,10 +37,6 @@ module RuboCop
           check_method_line_break(node, node.arguments)
         end
         alias on_defs on_def
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
       end
     end
   end

data/lib/rubocop/cop/layout/{indent_first_parameter.rb → first_parameter_indentation.rb}

@@ -3,9 +3,13 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of the first parameter in a method call.
-      # Parameters after the first one are checked by Layout/AlignParameters,
-      # not by this cop.
+      # This cop checks the indentation of the first parameter in a method
+      # definition. Parameters after the first one are checked by
+      # Layout/ParameterAlignment, not by this cop.
+      #
+      # For indenting the first argument of method _calls_, check out
+      # Layout/FirstArgumentIndentation, which supports options related to
+      # nesting that are irrelevant for method _definitions_.
       #
       # @example
       #
@@ -37,7 +41,7 @@ module RuboCop
       #   second_param)
       #     123
       #   end
-      class IndentFirstParameter < Cop
+      class FirstParameterIndentation < Cop
         include Alignment
         include ConfigurableEnforcedStyle
         include MultilineElementIndentation

data/lib/rubocop/cop/layout/{align_hash.rb → hash_alignment.rb}

@@ -7,16 +7,16 @@ module RuboCop
       # literal are aligned according to configuration. The configuration
       # options are:
       #
-      #   - key (left align keys, one space before hash rockets and values)
-      #   - separator (align hash rockets and colons, right align keys)
-      #   - table (left align keys, hash rockets, and values)
+      # * key (left align keys, one space before hash rockets and values)
+      # * separator (align hash rockets and colons, right align keys)
+      # * table (left align keys, hash rockets, and values)
       #
       # The treatment of hashes passed as the last argument to a method call
       # can also be configured. The options are:
       #
-      #   - always_inspect
-      #   - always_ignore
-      #   - ignore_implicit (without curly braces)
+      # * always_inspect
+      # * always_ignore
+      # * ignore_implicit (without curly braces)
       #
       # Alternatively you can specify multiple allowed styles. That's done by
       # passing a list of styles to EnforcedStyles.
@@ -175,12 +175,17 @@ module RuboCop
       #   do_something({foo: 1,
       #     bar: 2})
       #
-      class AlignHash < Cop
-        include HashAlignment
+      class HashAlignment < Base
+        include HashAlignmentStyles
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Align the elements of a hash literal if they span more than ' \
-              'one line.'
+        MESSAGES = { KeyAlignment => 'Align the keys of a hash literal if ' \
+                      'they span more than one line.',
+                     SeparatorAlignment => 'Align the separators of a hash ' \
+                       'literal if they span more than one line.',
+                     TableAlignment => 'Align the keys and values of a hash ' \
+                       'literal if they span more than one line.' }.freeze
 
         def on_send(node)
           return if double_splat?(node)
@@ -196,7 +201,7 @@ module RuboCop
         alias on_super on_send
         alias on_yield on_send
 
-        def on_hash(node)
+        def on_hash(node) # rubocop:todo Metrics/CyclomaticComplexity
           return if ignored_node?(node)
           return if node.pairs.empty? || node.single_line?
 
@@ -208,26 +213,22 @@ module RuboCop
           check_pairs(node)
         end
 
-        def autocorrect(node)
-          delta = column_deltas[alignment_for(node).first.class][node]
-          return if delta.nil?
-
-          correct_node(node, delta)
-        end
-
-        attr_accessor :offences_by
-        attr_accessor :column_deltas
+        attr_accessor :offences_by, :column_deltas
 
         private
 
+        def reset!
+          self.offences_by = {}
+          self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
+        end
+
         def double_splat?(node)
           node.children.last.is_a?(Symbol)
         end
 
         def check_pairs(node)
           first_pair = node.pairs.first
-          self.offences_by = {}
-          self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
+          reset!
 
           alignment_for(first_pair).each do |alignment|
             delta = alignment.deltas_for_first_pair(first_pair, node)
@@ -245,9 +246,13 @@ module RuboCop
         end
 
         def add_offences
-          _format, offences = offences_by.min_by { |_, v| v.length }
+          format, offences = offences_by.min_by { |_, v| v.length }
           (offences || []).each do |offence|
-            add_offense offence
+            add_offense(offence, message: MESSAGES[format]) do |corrector|
+              delta = column_deltas[alignment_for(offence).first.class][offence]
+
+              correct_node(corrector, offence, delta) unless delta.nil?
+            end
           end
         end
 
@@ -286,25 +291,26 @@ module RuboCop
             new_alignment('EnforcedColonStyle')
         end
 
-        def correct_node(node, delta)
+        def correct_node(corrector, node, delta)
           # We can't use the instance variable inside the lambda. That would
           # just give each lambda the same reference and they would all get the
           # last value of each. A local variable fixes the problem.
 
-          if !node.value
-            correct_no_value(delta[:key] || 0, node.source_range)
-          else
-            correct_key_value(delta, node.key.source_range,
+          if node.value
+            correct_key_value(corrector, delta, node.key.source_range,
                               node.value.source_range,
                               node.loc.operator)
+          else
+            delta_value = delta[:key] || 0
+            correct_no_value(corrector, delta_value, node.source_range)
           end
         end
 
-        def correct_no_value(key_delta, key)
-          ->(corrector) { adjust(corrector, key_delta, key) }
+        def correct_no_value(corrector, key_delta, key)
+          adjust(corrector, key_delta, key)
         end
 
-        def correct_key_value(delta, key, value, separator)
+        def correct_key_value(corrector, delta, key, value, separator)
           # We can't use the instance variable inside the lambda. That would
           # just give each lambda the same reference and they would all get the
           # last value of each. Some local variables fix the problem.
@@ -315,11 +321,9 @@ module RuboCop
           key_column = key.column
           key_delta = -key_column if key_delta < -key_column
 
-          lambda do |corrector|
-            adjust(corrector, key_delta, key)
-            adjust(corrector, separator_delta, separator)
-            adjust(corrector, value_delta, value)
-          end
+          adjust(corrector, key_delta, key)
+          adjust(corrector, separator_delta, separator)
+          adjust(corrector, value_delta, value)
         end
 
         def new_alignment(key)

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

@@ -50,12 +50,17 @@ module RuboCop
       #        123,
       #      )
       #
-      class HeredocArgumentClosingParenthesis < Cop
+      class HeredocArgumentClosingParenthesis < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Put the closing parenthesis for a method call with a ' \
         'HEREDOC parameter on the same line as the HEREDOC opening.'
 
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInArguments]
+        end
+
         def on_send(node)
           heredoc_arg = extract_heredoc_argument(node)
           return unless heredoc_arg
@@ -64,10 +69,15 @@ module RuboCop
           return unless outermost_send
           return unless outermost_send.loc.end
           return unless heredoc_arg.first_line != outermost_send.loc.end.line
+          return if subsequent_closing_parentheses_in_same_line?(outermost_send)
 
-          add_offense(outermost_send, location: :end)
+          add_offense(outermost_send.loc.end) do |corrector|
+            autocorrect(corrector, outermost_send)
+          end
         end
 
+        private
+
         # Autocorrection note:
         #
         # Commas are a bit tricky to handle when the method call is
@@ -94,22 +104,14 @@ module RuboCop
         #   SQL
         #   third_array_value,
         # ]
-        def autocorrect(node)
-          lambda do |corrector|
-            fix_closing_parenthesis(node, corrector)
+        def autocorrect(corrector, node)
+          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
-          end
+          fix_external_trailing_comma(node, corrector) if external_trailing_comma?(node)
         end
 
-        private
-
         def outermost_send_on_same_line(heredoc)
           previous = heredoc
           current = previous.parent
@@ -159,13 +161,24 @@ module RuboCop
 
         # Closing parenthesis helpers.
 
+        def subsequent_closing_parentheses_in_same_line?(outermost_send)
+          last_arg_of_outer_send = outermost_send.last_argument
+          return false unless last_arg_of_outer_send&.loc.respond_to?(:end) &&
+                              (end_of_last_arg_of_outer_send = last_arg_of_outer_send.loc.end)
+
+          end_of_outer_send = outermost_send.loc.end
+
+          end_of_outer_send.line == end_of_last_arg_of_outer_send.line &&
+            end_of_outer_send.column == end_of_last_arg_of_outer_send.column + 1
+        end
+
         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.source_range, ')')
+          corrector.insert_after(node.arguments.last, ')')
         end
 
         def remove_incorrect_closing_paren(node, corrector)
@@ -190,7 +203,7 @@ module RuboCop
         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}[ ]*$/)
+          last_line.match?(/^ *\) {0,20},{0,1} *$/)
         end
 
         def incorrect_parenthesis_removal_end(node)
@@ -245,7 +258,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

@@ -0,0 +1,176 @@
+# 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 < Base
+        include Heredoc
+        extend AutoCorrector
+
+        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)
+          heredoc_indent_type = heredoc_indent_type(node)
+
+          if heredoc_indent_type == '~'
+            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)
+
+          register_offense(node, heredoc_indent_type)
+        end
+
+        private
+
+        def register_offense(node, heredoc_indent_type)
+          message = message(heredoc_indent_type)
+
+          add_offense(node.loc.heredoc_body, message: message) do |corrector|
+            if heredoc_indent_type == '~'
+              adjust_squiggly(corrector, node)
+            else
+              adjust_minus(corrector, node)
+            end
+          end
+        end
+
+        def message(heredoc_indent_type)
+          current_indent_type = "<<#{heredoc_indent_type}"
+
+          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
+        end
+
+        def heredoc_end(node)
+          node.loc.heredoc_end.source
+        end
+      end
+    end
+  end
+end

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

@@ -5,12 +5,13 @@ module RuboCop
     module Layout
       # This cop checks for inconsistent indentation.
       #
-      # The difference between `rails` and `normal` is that the `rails` 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.
+      # 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
@@ -65,7 +66,7 @@ module RuboCop
       #     end
       #   end
       #
-      # @example EnforcedStyle: rails
+      # @example EnforcedStyle: indented_internal_methods
       #   # bad
       #   class A
       #     def test
@@ -166,8 +167,8 @@ module RuboCop
         end
 
         def check(node)
-          if style == :rails
-            check_rails_style(node)
+          if style == :indented_internal_methods
+            check_indented_internal_methods_style(node)
           else
             check_normal_style(node)
           end
@@ -180,13 +181,13 @@ module RuboCop
           )
         end
 
-        def check_rails_style(node)
+        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.
+            # 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