rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Here we check if the parameters on a multi-line method call or
+      # definition are aligned.
+      #
+      # To set the alignment of the first argument, use the cop
+      # FirstParameterIndentation.
+      #
+      # @example EnforcedStyle: with_first_parameter (default)
+      #   # good
+      #
+      #   def foo(bar,
+      #           baz)
+      #     123
+      #   end
+      #
+      #   def foo(
+      #     bar,
+      #     baz
+      #   )
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(bar,
+      #        baz)
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(
+      #     bar,
+      #        baz)
+      #     123
+      #   end
+      #
+      # @example EnforcedStyle: with_fixed_indentation
+      #   # good
+      #
+      #   def foo(bar,
+      #     baz)
+      #     123
+      #   end
+      #
+      #   def foo(
+      #     bar,
+      #     baz
+      #   )
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(bar,
+      #           baz)
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(
+      #     bar,
+      #        baz)
+      #     123
+      #   end
+      class ParameterAlignment < Cop
+        include Alignment
+
+        ALIGN_PARAMS_MSG = 'Align the parameters of a method definition if ' \
+          'they span more than one line.'
+
+        FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
+          'following the first line of a multi-line method definition.'
+
+        def on_def(node)
+          return if node.arguments.size < 2
+
+          check_alignment(node.arguments, base_column(node, node.arguments))
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+
+        private
+
+        def message(_node)
+          fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_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.keyword.line
+        end
+      end
+    end
+  end
+end

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

@@ -22,7 +22,16 @@ module RuboCop
       #     puts 'error'
       #   end
       class RescueEnsureAlignment < Cop
-        MSG = '`%s` at %d, %d is not aligned with `end` at %d, %d.'.freeze
+        include RangeHelp
+
+        MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
+              'aligned with `%<beginning>s` at ' \
+              '%<begin_loc_line>d, %<begin_loc_column>d.'
+        ANCESTOR_TYPES = %i[kwbegin def defs class module].freeze
+        RUBY_2_5_ANCESTOR_TYPES = (ANCESTOR_TYPES + %i[block]).freeze
+        ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = %i[def defs].freeze
+        ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method
+                                          private_class_method].freeze
 
         def on_resbody(node)
           check(node) unless modifier?(node)
@@ -32,55 +41,149 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          whitespace = whitespace_range(node)
+          # Some inline node is sitting before current node.
+          return nil unless whitespace.source.strip.empty?
+
+          alignment_node = alignment_node(node)
+          return false if alignment_node.nil?
+
+          new_column = alignment_node.loc.column
+          ->(corrector) { corrector.replace(whitespace, ' ' * new_column) }
+        end
+
         def investigate(processed_source)
           @modifier_locations =
             processed_source.tokens.each_with_object([]) do |token, locations|
-              next unless token.type == :kRESCUE_MOD
+              next unless token.rescue_modifier?
+
               locations << token.pos
             end
         end
 
-        def autocorrect(node)
-          whitespace = whitespace_range(node)
-          return false unless whitespace.source.strip.empty?
+        private
 
-          new_column = ancestor_node(node).loc.end.column
-          ->(corrector) { corrector.replace(whitespace, ' ' * new_column) }
+        # Check alignment of node with rescue or ensure modifiers.
+
+        def check(node)
+          alignment_node = alignment_node(node)
+          return if alignment_node.nil?
+
+          alignment_loc = alignment_node.loc.expression
+          kw_loc        = node.loc.keyword
+
+          return if
+            alignment_loc.column == kw_loc.column ||
+            alignment_loc.line   == kw_loc.line
+
+          add_offense(
+            node,
+            location: kw_loc,
+            message: format_message(alignment_node, alignment_loc, kw_loc)
+          )
         end
 
-        private
+        def format_message(alignment_node, alignment_loc, kw_loc)
+          format(
+            MSG,
+            kw_loc: kw_loc.source,
+            kw_loc_line: kw_loc.line,
+            kw_loc_column: kw_loc.column,
+            beginning: alignment_source(alignment_node, alignment_loc),
+            begin_loc_line: alignment_loc.line,
+            begin_loc_column: alignment_loc.column
+          )
+        end
 
-        def check(node)
-          end_loc = ancestor_node(node).loc.end
-          kw_loc = node.loc.keyword
+        # rubocop:disable Metrics/AbcSize
+        def alignment_source(node, starting_loc)
+          ending_loc =
+            case node.type
+            when :block, :kwbegin
+              node.loc.begin
+            when :def, :defs, :class, :module,
+                 :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
+              node.loc.name
+            when :masgn
+              mlhs_node, = *node
+              mlhs_node.loc.expression
+            else
+              # It is a wrapper with access modifier.
+              node.child_nodes.first.loc.name
+            end
+
+          range_between(starting_loc.begin_pos, ending_loc.end_pos).source
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # We will use ancestor or wrapper with access modifier.
+
+        def alignment_node(node)
+          ancestor_node = ancestor_node(node)
+
+          return ancestor_node if ancestor_node.nil? ||
+                                  ancestor_node.kwbegin_type?
 
-          return if end_loc.column == kw_loc.column
-          return if end_loc.line == kw_loc.line
+          assignment_node = assignment_node(ancestor_node)
+          return assignment_node if same_line?(ancestor_node, assignment_node)
 
-          add_offense(node,
-                      location: kw_loc,
-                      message: format_message(kw_loc, end_loc))
+          access_modifier_node = access_modifier_node(ancestor_node)
+          return access_modifier_node unless access_modifier_node.nil?
+
+          ancestor_node
         end
 
-        def format_message(kw_loc, end_loc)
-          format(MSG, kw_loc.source, kw_loc.line, kw_loc.column, end_loc.line,
-                 end_loc.column)
+        def ancestor_node(node)
+          ancestor_types =
+            if target_ruby_version >= 2.5
+              RUBY_2_5_ANCESTOR_TYPES
+            else
+              ANCESTOR_TYPES
+            end
+
+          node.each_ancestor(*ancestor_types).first
+        end
+
+        def assignment_node(node)
+          assignment_node = node.ancestors.first
+          return nil unless
+            assignment_node&.assignment?
+
+          assignment_node
+        end
+
+        def access_modifier_node(node)
+          return nil unless
+            ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS.include?(node.type)
+
+          access_modifier_node = node.ancestors.first
+          return nil unless access_modifier?(access_modifier_node)
+
+          access_modifier_node
         end
 
         def modifier?(node)
           return false unless @modifier_locations.respond_to?(:include?)
+
           @modifier_locations.include?(node.loc.keyword)
         end
 
         def whitespace_range(node)
-          begin_pos = node.loc.keyword.begin_pos
+          begin_pos      = node.loc.keyword.begin_pos
           current_column = node.loc.keyword.column
 
           range_between(begin_pos - current_column, begin_pos)
         end
 
-        def ancestor_node(node)
-          node.each_ancestor(:kwbegin, :def, :defs, :class, :module).first
+        def access_modifier?(node)
+          return true if node.respond_to?(:access_modifier?) &&
+                         node.access_modifier?
+
+          return true if node.respond_to?(:method_name) &&
+                         ALTERNATIVE_ACCESS_MODIFIERS.include?(node.method_name)
+
+          false
         end
       end
     end

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

@@ -14,7 +14,7 @@ module RuboCop
       #   # good
       #   def f(a:, b: 2); {a: 3}; end
       class SpaceAfterColon < Cop
-        MSG = 'Space missing after colon.'.freeze
+        MSG = 'Space missing after colon.'
 
         def on_pair(node)
           return unless node.colon?
@@ -32,14 +32,14 @@ module RuboCop
           add_offense(colon, location: colon) unless followed_by_space?(colon)
         end
 
+        def autocorrect(range)
+          ->(corrector) { corrector.insert_after(range, ' ') }
+        end
+
         private
 
         def followed_by_space?(colon)
-          colon.source_buffer.source[colon.end_pos] =~ /\s/
-        end
-
-        def autocorrect(range)
-          ->(corrector) { corrector.insert_after(range, ' ') }
+          /\s/.match?(colon.source_buffer.source[colon.end_pos])
         end
       end
     end

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

@@ -8,22 +8,26 @@ module RuboCop
       # @example
       #
       #   # bad
-      #   1,2
+      #   [1,2]
       #   { foo:bar,}
       #
       #   # good
-      #   1, 2
+      #   [1, 2]
       #   { foo:bar, }
       class SpaceAfterComma < Cop
         include SpaceAfterPunctuation
 
+        def autocorrect(comma)
+          PunctuationCorrector.add_space(comma)
+        end
+
         def space_style_before_rcurly
           cfg = config.for_cop('Layout/SpaceInsideHashLiteralBraces')
           cfg['EnforcedStyle'] || 'space'
         end
 
         def kind(token)
-          'comma' if token.type == :tCOMMA
+          'comma' if token.comma?
         end
       end
     end

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

@@ -8,28 +8,31 @@ module RuboCop
       # @example
       #
       #   # bad
-      #   def func (x) ... end
+      #   def func (x) end
+      #   def method= (y) end
       #
       #   # good
-      #   def func(x) ... end
+      #   def func(x) end
+      #   def method=(y) end
       class SpaceAfterMethodName < Cop
+        include RangeHelp
+
         MSG = 'Do not put a space between a method name and the opening ' \
-              'parenthesis.'.freeze
+              'parenthesis.'
 
         def on_def(node)
           args = node.arguments
-          return unless args.loc.begin && args.loc.begin.is?('(')
+          return unless args.loc.begin&.is?('(')
+
           expr = args.source_range
           pos_before_left_paren = range_between(expr.begin_pos - 1,
                                                 expr.begin_pos)
-          return unless pos_before_left_paren.source =~ /\s/
+          return unless pos_before_left_paren.source.start_with?(' ')
 
           add_offense(pos_before_left_paren, location: pos_before_left_paren)
         end
         alias on_defs on_def
 
-        private
-
         def autocorrect(pos_before_left_paren)
           ->(corrector) { corrector.remove(pos_before_left_paren) }
         end

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

@@ -12,10 +12,12 @@ module RuboCop
       #   # good
       #   !something
       class SpaceAfterNot < Cop
-        MSG = 'Do not leave space between `!` and its argument.'.freeze
+        include RangeHelp
+
+        MSG = 'Do not leave space between `!` and its argument.'
 
         def on_send(node)
-          return unless node.keyword_bang? && whitespace_after_operator?(node)
+          return unless node.prefix_bang? && whitespace_after_operator?(node)
 
           add_offense(node)
         end

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

@@ -4,16 +4,27 @@ module RuboCop
   module Cop
     module Layout
       # Checks for semicolon (;) not followed by some kind of space.
+      #
+      # @example
+      #   # bad
+      #   x = 1;y = 2
+      #
+      #   # good
+      #   x = 1; y = 2
       class SpaceAfterSemicolon < Cop
         include SpaceAfterPunctuation
 
+        def autocorrect(semicolon)
+          PunctuationCorrector.add_space(semicolon)
+        end
+
         def space_style_before_rcurly
           cfg = config.for_cop('Layout/SpaceInsideBlockBraces')
           cfg['EnforcedStyle'] || 'space'
         end
 
         def kind(token)
-          'semicolon' if token.type == :tSEMI
+          'semicolon' if token.semicolon?
         end
       end
     end

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

@@ -3,12 +3,11 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks the spacing inside and after block parameters pipes.
-      #
-      # @example
-      #
-      #   # EnforcedStyleInsidePipes: no_space (default)
+      # Checks the spacing inside and after block parameters pipes. Line breaks
+      # inside parameter pipes are checked by `Layout/MultilineBlockLayout` and
+      # not by this cop.
       #
+      # @example EnforcedStyleInsidePipes: no_space (default)
       #   # bad
       #   {}.each { | x,  y |puts x }
       #   ->( x,  y ) { puts x }
@@ -17,10 +16,7 @@ module RuboCop
       #   {}.each { |x, y| puts x }
       #   ->(x, y) { puts x }
       #
-      # @example
-      #
-      #   # EnforcedStyleInsidePipes: space
-      #
+      # @example EnforcedStyleInsidePipes: space
       #   # bad
       #   {}.each { |x,  y| puts x }
       #   ->(x,  y) { puts x }
@@ -28,49 +24,64 @@ module RuboCop
       #   # good
       #   {}.each { | x, y | puts x }
       #   ->( x, y ) { puts x }
-      class SpaceAroundBlockParameters < Cop
+      class SpaceAroundBlockParameters < Base
         include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
 
         def on_block(node)
-          return unless node.arguments?
-
-          args = node.arguments
+          arguments = node.arguments
 
-          opening_pipe = args.loc.begin
-          closing_pipe = args.loc.end
-          return if opening_pipe.nil? || closing_pipe.nil?
+          return unless node.arguments? && pipes?(arguments)
 
-          check_inside_pipes(args.children, opening_pipe, closing_pipe)
+          check_inside_pipes(arguments)
+          check_after_closing_pipe(arguments) if node.body
+          check_each_arg(arguments)
+        end
 
-          if node.body
-            check_space(closing_pipe.end_pos, node.body.source_range.begin_pos,
-                        closing_pipe, 'after closing `|`')
-          end
+        private
 
-          check_each_arg(args)
+        def pipes(arguments)
+          [arguments.loc.begin, arguments.loc.end]
         end
 
-        private
+        def pipes?(arguments)
+          pipes(arguments).none?(&:nil?)
+        end
 
         def style_parameter_name
           'EnforcedStyleInsidePipes'
         end
 
-        def check_inside_pipes(args, opening_pipe, closing_pipe)
+        def check_inside_pipes(arguments)
+          opening_pipe, closing_pipe = pipes(arguments)
+
           if style == :no_space
-            check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+            check_no_space_style_inside_pipes(arguments.children,
+                                              opening_pipe,
+                                              closing_pipe)
           elsif style == :space
-            check_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+            check_space_style_inside_pipes(arguments.children,
+                                           opening_pipe,
+                                           closing_pipe)
           end
         end
 
+        def check_after_closing_pipe(arguments)
+          _opening_pipe, closing_pipe = pipes(arguments)
+          block = arguments.parent
+
+          check_space(closing_pipe.end_pos, block.body.source_range.begin_pos,
+                      closing_pipe, 'after closing `|`')
+        end
+
         def check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe)
           first = args.first.source_range
           last = args.last.source_range
 
           check_no_space(opening_pipe.end_pos, first.begin_pos,
                          'Space before first')
-          check_no_space(last_end_pos_inside_pipes(last.end_pos),
+          check_no_space(last_end_pos_inside_pipes(last),
                          closing_pipe.begin_pos, 'Space after last')
         end
 
@@ -80,17 +91,18 @@ module RuboCop
         end
 
         def check_opening_pipe_space(args, opening_pipe)
-          first = args.first.source_range
+          first_arg = args.first
+          range = first_arg.source_range
 
-          check_space(opening_pipe.end_pos, first.begin_pos, first,
-                      'before first block parameter')
-          check_no_space(opening_pipe.end_pos, first.begin_pos - 1,
+          check_space(opening_pipe.end_pos, range.begin_pos, range,
+                      'before first block parameter', first_arg)
+          check_no_space(opening_pipe.end_pos, range.begin_pos - 1,
                          'Extra space before first')
         end
 
         def check_closing_pipe_space(args, closing_pipe)
           last         = args.last.source_range
-          last_end_pos = last_end_pos_inside_pipes(last.end_pos)
+          last_end_pos = last_end_pos_inside_pipes(last)
 
           check_space(last_end_pos, closing_pipe.begin_pos, last,
                       'after last block parameter')
@@ -98,38 +110,51 @@ module RuboCop
                          'Extra space after last')
         end
 
-        def last_end_pos_inside_pipes(pos)
-          processed_source.buffer.source[pos] == ',' ? pos + 1 : pos
+        def last_end_pos_inside_pipes(range)
+          pos = range.end_pos
+          range.source_buffer.source[pos] == ',' ? pos + 1 : pos
         end
 
         def check_each_arg(args)
-          args.children.butfirst.each do |arg|
-            expr = arg.source_range
-            check_no_space(range_with_surrounding_space(expr, :left).begin_pos,
-                           expr.begin_pos - 1, 'Extra space before')
+          args.children.each do |arg|
+            check_arg(arg)
           end
         end
 
-        def check_space(space_begin_pos, space_end_pos, range, msg)
+        def check_arg(arg)
+          arg.children.each { |a| check_arg(a) } if arg.mlhs_type?
+
+          expr = arg.source_range
+          check_no_space(
+            range_with_surrounding_space(range: expr, side: :left).begin_pos,
+            expr.begin_pos - 1,
+            'Extra space before'
+          )
+        end
+
+        def check_space(space_begin_pos, space_end_pos, range, msg, node = nil)
           return if space_begin_pos != space_end_pos
 
-          add_offense(range, location: range, message: "Space #{msg} missing.")
+          target = node || range
+          message = "Space #{msg} missing."
+          add_offense(target, message: message) do |corrector|
+            if node
+              corrector.insert_before(node, ' ')
+            else
+              corrector.insert_after(target, ' ')
+            end
+          end
         end
 
         def check_no_space(space_begin_pos, space_end_pos, msg)
           return if space_begin_pos >= space_end_pos
 
           range = range_between(space_begin_pos, space_end_pos)
-          add_offense(range, location: range,
-                             message: "#{msg} block parameter detected.")
-        end
+          return if range.source.include?("\n")
 
-        def autocorrect(range)
-          lambda do |corrector|
-            case range.source
-            when /^\s+$/ then corrector.remove(range)
-            else              corrector.insert_after(range, ' ')
-            end
+          message = "#{msg} block parameter detected."
+          add_offense(range, message: message) do |corrector|
+            corrector.remove(range)
           end
         end
       end