rubocop 0.70.0 → 1.6.1

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Here we check if the elements of a multi-line array literal are
+      # aligned.
+      #
+      # @example EnforcedStyle: with_first_element (default)
+      #   # good
+      #
+      #   array = [1, 2, 3,
+      #            4, 5, 6]
+      #   array = ['run',
+      #            'forrest',
+      #            'run']
+      #
+      #   # bad
+      #
+      #   array = [1, 2, 3,
+      #     4, 5, 6]
+      #   array = ['run',
+      #        'forrest',
+      #        'run']
+      #
+      # @example EnforcedStyle: with_fixed_indentation
+      #   # good
+      #
+      #   array = [1, 2, 3,
+      #     4, 5, 6]
+      #
+      #   # bad
+      #
+      #   array = [1, 2, 3,
+      #            4, 5, 6]
+      class ArrayAlignment < Cop
+        include Alignment
+
+        ALIGN_ELEMENTS_MSG = 'Align the elements of an array literal ' \
+          'if they span more than one line.'
+
+        FIXED_INDENT_MSG = 'Use one level of indentation for elements ' \
+          'following the first line of a multi-line array.'
+
+        def on_array(node)
+          return if node.children.size < 2
+          return if node.parent&.masgn_type?
+
+          check_alignment(node.children, base_column(node, node.children))
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+
+        private
+
+        def message(_node)
+          fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_ELEMENTS_MSG
+        end
+
+        def fixed_indentation?
+          cop_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def base_column(node, args)
+          if fixed_indentation?
+            lineno = target_method_lineno(node)
+            line = node.source_range.source_buffer.source_line(lineno)
+            indentation_of_line = /\S.*/.match(line).begin(0)
+            indentation_of_line + configured_indentation_width
+          else
+            display_column(args.first.source_range)
+          end
+        end
+
+        def target_method_lineno(node)
+          node.loc.line
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/{indent_assignment.rb → assignment_indentation.rb}

@@ -21,7 +21,7 @@ module RuboCop
       #
       # The indentation of the remaining lines can be corrected with
       # other cops such as `IndentationConsistency` and `EndAlignment`.
-      class IndentAssignment < Cop
+      class AssignmentIndentation < Cop
         include CheckAssignment
         include Alignment
 
@@ -33,13 +33,22 @@ module RuboCop
           return unless node.loc.operator
           return if node.loc.operator.line == rhs.first_line
 
-          base = display_column(node.source_range)
+          base = display_column(leftmost_multiple_assignment(node).source_range)
           check_alignment([rhs], base + configured_indentation_width)
         end
 
         def autocorrect(node)
           AlignmentCorrector.correct(processed_source, node, column_delta)
         end
+
+        def leftmost_multiple_assignment(node)
+          return node unless same_line?(node, node.parent) &&
+                             node.parent.assignment?
+
+          leftmost_multiple_assignment(node.parent)
+
+          node.parent
+        end
       end
     end
   end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether the end keyword of `begin` is aligned properly.
+      #
+      # Two modes are supported through the `EnforcedStyleAlignWith` configuration
+      # parameter. If it's set to `start_of_line` (which is the default), the
+      # `end` shall be aligned with the start of the line where the `begin`
+      # keyword is. If it's set to `begin`, the `end` shall be aligned with the
+      # `begin` keyword.
+      #
+      # `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
+      # by default. On the other hand, `||= begin` that this cop targets tends to
+      # align with the start of the line, it defaults to `EnforcedStyleAlignWith: start_of_line`.
+      # These style can be configured by each cop.
+      #
+      # @example EnforcedStyleAlignWith: start_of_line (default)
+      #   # bad
+      #   foo ||= begin
+      #             do_something
+      #           end
+      #
+      #   # good
+      #   foo ||= begin
+      #     do_something
+      #   end
+      #
+      # @example EnforcedStyleAlignWith: begin
+      #   # bad
+      #   foo ||= begin
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   foo ||= begin
+      #             do_something
+      #           end
+      #
+      class BeginEndAlignment < Base
+        include EndKeywordAlignment
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'
+
+        def on_kwbegin(node)
+          check_begin_alignment(node)
+        end
+
+        private
+
+        def check_begin_alignment(node)
+          align_with = {
+            begin: node.loc.begin,
+            start_of_line: start_line_range(node)
+          }
+          check_end_kw_alignment(node, align_with)
+        end
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.align_end(corrector, processed_source, node, alignment_node(node))
+        end
+
+        def alignment_node(node)
+          case style
+          when :begin
+            node
+          else
+            start_line_range(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -44,8 +44,8 @@ module RuboCop
       #
       #   foo.bar
       #     .each do
-      #        baz
-      #      end
+      #       baz
+      #     end
       #
       # @example EnforcedStyleAlignWith: start_of_line
       #   # bad
@@ -61,13 +61,14 @@ module RuboCop
       #     .each do
       #        baz
       #   end
-      class BlockAlignment < Cop
+      class BlockAlignment < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '%<current>s is not aligned with %<prefer>s%<alt_prefer>s.'
 
-        def_node_matcher :block_end_align_target?, <<-PATTERN
+        def_node_matcher :block_end_align_target?, <<~PATTERN
           {assignment?
            splat
            and
@@ -84,19 +85,6 @@ module RuboCop
           'EnforcedStyleAlignWith'
         end
 
-        def autocorrect(node)
-          ancestor_node = start_for_block_node(node)
-          start_col = compute_start_col(ancestor_node, node)
-          loc_end = node.loc.end
-          delta = start_col - loc_end.column
-
-          if delta.positive?
-            add_space_before(loc_end, delta)
-          elsif delta.negative?
-            remove_space_before(loc_end.begin_pos, -delta)
-          end
-        end
-
         private
 
         def start_for_block_node(block_node)
@@ -163,7 +151,22 @@ module RuboCop
           message = format_message(start_loc, end_loc, do_source_line_column,
                                    error_source_line_column)
 
-          add_offense(block_node, location: end_loc, message: message)
+          add_offense(end_loc, message: message) do |corrector|
+            autocorrect(corrector, block_node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          ancestor_node = start_for_block_node(node)
+          start_col = compute_start_col(ancestor_node, node)
+          loc_end = node.loc.end
+          delta = start_col - loc_end.column
+
+          if delta.positive?
+            add_space_before(corrector, loc_end, delta)
+          elsif delta.negative?
+            remove_space_before(corrector, loc_end.begin_pos, -delta)
+          end
         end
 
         def format_message(start_loc, end_loc, do_source_line_column,
@@ -207,13 +210,12 @@ module RuboCop
         end
 
         def alt_start_msg(start_loc, source_line_column)
-          if style != :either
-            ''
-          elsif start_loc.line == source_line_column[:line] &&
-                start_loc.column == source_line_column[:column]
+          if style != :either ||
+             (start_loc.line == source_line_column[:line] &&
+                 start_loc.column == source_line_column[:column])
             ''
           else
-            ' or ' + format_source_line_column(source_line_column)
+            " or #{format_source_line_column(source_line_column)}"
           end
         end
 
@@ -230,13 +232,14 @@ module RuboCop
           (ancestor_node || node).source_range.column
         end
 
-        def add_space_before(loc, delta)
-          ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
+        def add_space_before(corrector, loc, delta)
+          corrector.insert_before(loc, ' ' * delta)
         end
 
-        def remove_space_before(end_pos, delta)
+        def remove_space_before(corrector, end_pos, delta)
           range = range_between(end_pos - delta, end_pos)
-          ->(corrector) { corrector.remove(range) }
+
+          corrector.remove(range)
         end
       end
     end

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

@@ -52,9 +52,11 @@ module RuboCop
         end
 
         def delimiter_range(node)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.children.last.loc.expression.end_pos,
-                                    node.loc.expression.end_pos)
+          Parser::Source::Range.new(
+            node.loc.expression.source_buffer,
+            node.children.compact.last.loc.expression.end_pos,
+            node.loc.expression.end_pos
+          )
         end
       end
     end

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

@@ -3,10 +3,10 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks how the *when*s of a *case* expression
-      # are indented in relation to its *case* or *end* keyword.
+      # This cop checks how the ``when``s of a `case` expression
+      # are indented in relation to its `case` or `end` keyword.
       #
-      # It will register a separate offense for each misaligned *when*.
+      # It will register a separate offense for each misaligned `when`.
       #
       # @example
       #   # If Layout/EndAlignment is set to keyword style (default)
@@ -67,10 +67,11 @@ module RuboCop
       #   else
       #     y / 3
       #   end
-      class CaseIndentation < Cop
+      class CaseIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Indent `when` %<depth>s `%<base>s`.'
 
@@ -82,16 +83,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          whitespace = whitespace_range(node)
-
-          return false unless whitespace.source.strip.empty?
-
-          lambda do |corrector|
-            corrector.replace(whitespace, replacement(node))
-          end
-        end
-
         private
 
         def check_when(when_node)
@@ -114,22 +105,27 @@ module RuboCop
         end
 
         def incorrect_style(when_node)
-          when_column = when_node.loc.keyword.column
-          base_column = base_column(when_node.parent, alternative_style)
+          depth = indent_one_step? ? 'one step more than' : 'as deep as'
+          message = format(MSG, depth: depth, base: style)
 
-          add_offense(when_node, location: :keyword, message: message(style)) do
-            if when_column == base_column
-              opposite_style_detected
-            else
-              unrecognized_style_detected
-            end
+          add_offense(when_node.loc.keyword, message: message) do |corrector|
+            detect_incorrect_style(when_node)
+
+            whitespace = whitespace_range(when_node)
+
+            corrector.replace(whitespace, replacement(when_node)) if whitespace.source.strip.empty?
           end
         end
 
-        def message(base)
-          depth = indent_one_step? ? 'one step more than' : 'as deep as'
+        def detect_incorrect_style(when_node)
+          when_column = when_node.loc.keyword.column
+          base_column = base_column(when_node.parent, alternative_style)
 
-          format(MSG, depth: depth, base: base)
+          if when_column == base_column
+            opposite_style_detected
+          else
+            unrecognized_style_detected
+          end
         end
 
         def base_column(case_node, base)

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

@@ -8,22 +8,24 @@ module RuboCop
       # `Categories` allows us to map macro names into a category.
       #
       # Consider an example of code style that covers the following order:
-      # - Module inclusion (include, prepend, extend)
-      # - Constants
-      # - Associations (has_one, has_many)
-      # - Public attribute macros (attr_accessor, attr_writer, attr_reader)
-      # - Other macros (validates, validate)
-      # - Public class methods
-      # - Initializer
-      # - Public instance methods
-      # - Protected attribute macros (attr_accessor, attr_writer, attr_reader)
-      # - Protected instance methods
-      # - Private attribute macros (attr_accessor, attr_writer, attr_reader)
-      # - Private instance methods
+      #
+      # * Module inclusion (include, prepend, extend)
+      # * Constants
+      # * Associations (has_one, has_many)
+      # * Public attribute macros (attr_accessor, attr_writer, attr_reader)
+      # * Other macros (validates, validate)
+      # * Public class methods
+      # * Initializer
+      # * Public instance methods
+      # * Protected attribute macros (attr_accessor, attr_writer, attr_reader)
+      # * Protected instance methods
+      # * Private attribute macros (attr_accessor, attr_writer, attr_reader)
+      # * Private instance methods
       #
       # You can configure the following order:
       #
-      # ```yaml
+      # [source,yaml]
+      # ----
       #  Layout/ClassStructure:
       #    ExpectedOrder:
       #      - module_inclusion
@@ -40,13 +42,14 @@ module RuboCop
       #      - private_attribute_macros
       #      - private_delegate
       #      - private_methods
-      # ```
+      # ----
       #
       # Instead of putting all literals in the expected order, is also
       # possible to group categories of macros. Visibility levels are handled
       # automatically.
       #
-      # ```yaml
+      # [source,yaml]
+      # ----
       #  Layout/ClassStructure:
       #    Categories:
       #      association:
@@ -63,7 +66,7 @@ module RuboCop
       #        - include
       #        - prepend
       #        - extend
-      # ```
+      # ----
       #
       # @example
       #   # bad
@@ -129,8 +132,11 @@ module RuboCop
       #     end
       #   end
       #
-      # @see https://github.com/rubocop-hq/ruby-style-guide#consistent-classes
-      class ClassStructure < Cop
+      # @see https://rubystyle.guide#consistent-classes
+      class ClassStructure < Base
+        include VisibilityHelp
+        extend AutoCorrector
+
         HUMANIZED_NODE_TYPE = {
           casgn: :constants,
           defs: :class_methods,
@@ -138,12 +144,11 @@ module RuboCop
           sclass: :class_singleton
         }.freeze
 
-        VISIBILITY_SCOPES = %i[private protected public].freeze
         MSG = '`%<category>s` is supposed to appear before ' \
               '`%<previous>s`.'
 
-        def_node_matcher :visibility_block?, <<-PATTERN
-          (send nil? { :private :protected :public })
+        def_node_matcher :dynamic_constant?, <<~PATTERN
+          (casgn nil? _ (send ...))
         PATTERN
 
         # Validates code style on class declaration.
@@ -155,31 +160,30 @@ module RuboCop
             if index < previous
               message = format(MSG, category: category,
                                     previous: expected_order[previous])
-              add_offense(node, message: message)
+              add_offense(node, message: message) do |corrector|
+                autocorrect(corrector, node)
+              end
             end
             previous = index
           end
         end
 
+        private
+
         # Autocorrect by swapping between two nodes autocorrecting them
-        def autocorrect(node)
-          node_classification = classify(node)
-          previous = left_siblings_of(node).find do |sibling|
-            classification = classify(sibling)
-            !ignore?(classification) && node_classification != classification
+        def autocorrect(corrector, node)
+          previous = node.left_siblings.find do |sibling|
+            !ignore_for_autocorrect?(node, sibling)
           end
+          return unless previous
 
           current_range = source_range_with_comment(node)
           previous_range = source_range_with_comment(previous)
 
-          lambda do |corrector|
-            corrector.insert_before(previous_range, current_range.source)
-            corrector.remove(current_range)
-          end
+          corrector.insert_before(previous_range, current_range.source)
+          corrector.remove(current_range)
         end
 
-        private
-
         # Classifies a node to match with something in the {expected_order}
         # @param node to be analysed
         # @return String when the node type is a `:block` then
@@ -240,36 +244,13 @@ module RuboCop
             expected_order.index(classification).nil?
         end
 
-        def node_visibility(node)
-          scope = find_visibility_start(node)
-          scope&.method_name || :public
-        end
-
-        def find_visibility_start(node)
-          left_siblings_of(node)
-            .reverse
-            .find(&method(:visibility_block?))
-        end
-
-        # Navigate to find the last protected method
-        def find_visibility_end(node)
-          possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
-          right = right_siblings_of(node)
-          right.find do |child_node|
-            possible_visibilities.include?(node_visibility(child_node))
-          end || right.last
-        end
-
-        def siblings_of(node)
-          node.parent.children
-        end
-
-        def right_siblings_of(node)
-          siblings_of(node)[node.sibling_index..-1]
-        end
+        def ignore_for_autocorrect?(node, sibling)
+          classification = classify(node)
+          sibling_class = classify(sibling)
 
-        def left_siblings_of(node)
-          siblings_of(node)[0, node.sibling_index]
+          ignore?(sibling_class) ||
+            classification == sibling_class ||
+            dynamic_constant?(node)
         end
 
         def humanize_node(node)
@@ -296,20 +277,19 @@ module RuboCop
         end
 
         def end_position_for(node)
+          heredoc = find_heredoc(node)
+          return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+
           end_line = buffer.line_for_position(node.loc.expression.end_pos)
           buffer.line_range(end_line).end_pos
         end
 
         def begin_pos_with_comment(node)
-          annotation_line = node.first_line - 1
           first_comment = nil
+          (node.first_line - 1).downto(1) do |annotation_line|
+            break unless (comment = processed_source.comment_at_line(annotation_line))
 
-          processed_source.comments_before_line(annotation_line)
-                          .reverse_each do |comment|
-            if comment.location.line == annotation_line
-              first_comment = comment
-              annotation_line -= 1
-            end
+            first_comment = comment
           end
 
           start_line_position(first_comment || node)
@@ -319,6 +299,10 @@ module RuboCop
           buffer.line_range(node.loc.line).begin_pos - 1
         end
 
+        def find_heredoc(node)
+          node.each_node(:str, :dstr, :xstr).find(&:heredoc?)
+        end
+
         def buffer
           processed_source.buffer
         end

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

@@ -46,8 +46,9 @@ module RuboCop
       #         Hi
       #       EOS
       #
-      class ClosingHeredocIndentation < Cop
+      class ClosingHeredocIndentation < Base
         include Heredoc
+        extend AutoCorrector
 
         SIMPLE_HEREDOC = '<<'
         MSG = '`%<closing>s` is not aligned with `%<opening>s`.'
@@ -59,11 +60,8 @@ module RuboCop
                     opening_indentation(node) == closing_indentation(node) ||
                     argument_indentation_correct?(node)
 
-          add_offense(node, location: :heredoc_end)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          message = message(node)
+          add_offense(node.loc.heredoc_end, message: message) do |corrector|
             corrector.replace(node.loc.heredoc_end, indented_end(node))
           end
         end

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

@@ -191,7 +191,7 @@ module RuboCop
         end
 
         def indentation_width
-          @config.for_cop('IndentationWidth')['Width'] || 2
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
         end
 
         def line_break_after_left_paren?(left_paren, elements)