rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/{style → layout}/multiline_operation_indentation.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks the indentation of the right hand side operand in
       # binary operations that span more than one line.
       #
@@ -13,9 +12,15 @@ module RuboCop
       #   b
       #     something
       #   end
+      #
+      #   # good
+      #   if a +
+      #      b
+      #     something
+      #   end
       class MultilineOperationIndentation < Cop
         include ConfigurableEnforcedStyle
-        include AutocorrectAlignment
+        include Alignment
         include MultilineExpressionIndentation
 
         def on_and(node)
@@ -27,12 +32,16 @@ module RuboCop
         end
 
         def validate_config
-          if style == :aligned && cop_config['IndentationWidth']
-            raise ValidationError, 'The `Style/MultilineOperationIndentation`' \
-                                  ' cop only accepts an `IndentationWidth` ' \
-                                  'configuration parameter when ' \
-                                  '`EnforcedStyle` is `indented`.'
-          end
+          return unless style == :aligned && cop_config['IndentationWidth']
+
+          raise ValidationError, 'The `Layout/MultilineOperationIndentation`' \
+                                ' cop only accepts an `IndentationWidth` ' \
+                                'configuration parameter when ' \
+                                '`EnforcedStyle` is `indented`.'
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
         end
 
         private
@@ -49,7 +58,7 @@ module RuboCop
 
         def offending_range(node, lhs, rhs, given_style)
           return false unless begins_its_line?(rhs)
-          return false if lhs.loc.line == rhs.line # Needed for unary op.
+          return false if lhs.first_line == rhs.line # Needed for unary op.
           return false if not_for_this_cop?(node)
 
           correct_column = if should_align?(node, rhs, given_style)
@@ -68,9 +77,10 @@ module RuboCop
             return true if begins_its_line?(assignment_rhs.source_range)
           end
 
-          given_style == :aligned && (kw_node_with_special_indentation(node) ||
-                                      assignment_node ||
-                                      argument_in_method_call(node))
+          given_style == :aligned &&
+            (kw_node_with_special_indentation(node) ||
+             assignment_node ||
+             argument_in_method_call(node, :with_or_without_parentheses))
         end
 
         def message(node, lhs, rhs)

data/lib/rubocop/cop/{style → layout}/rescue_ensure_alignment.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks whether the rescue and ensure keywords are aligned
       # properly.
       #
@@ -23,7 +22,9 @@ module RuboCop
       #     puts 'error'
       #   end
       class RescueEnsureAlignment < Cop
-        MSG = '`%s` at %d, %d is not aligned with `end` at %d, %d.'.freeze
+        MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
+              'aligned with `end` at %<end_loc_line>d, %<end_loc_column>d.'
+              .freeze
 
         def on_resbody(node)
           check(node) unless modifier?(node)
@@ -42,12 +43,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          source_buffer = node.loc.keyword.source_buffer
-          begin_pos = node.loc.keyword.begin_pos
-          current_column = node.loc.keyword.column
-          whitespace = Parser::Source::Range.new(source_buffer,
-                                                 begin_pos - current_column,
-                                                 begin_pos)
+          whitespace = whitespace_range(node)
           return false unless whitespace.source.strip.empty?
 
           new_column = ancestor_node(node).loc.end.column
@@ -63,12 +59,18 @@ module RuboCop
           return if end_loc.column == kw_loc.column
           return if end_loc.line == kw_loc.line
 
-          add_offense(node, kw_loc, format_message(kw_loc, end_loc))
+          add_offense(node,
+                      location: kw_loc,
+                      message: format_message(kw_loc, end_loc))
         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)
+          format(MSG,
+                 kw_loc: kw_loc.source,
+                 kw_loc_line: kw_loc.line,
+                 kw_loc_column: kw_loc.column,
+                 end_loc_line: end_loc.line,
+                 end_loc_column: end_loc.column)
         end
 
         def modifier?(node)
@@ -76,8 +78,17 @@ module RuboCop
           @modifier_locations.include?(node.loc.keyword)
         end
 
+        def whitespace_range(node)
+          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
+          types = %i[kwbegin def defs class module]
+          types << :block if target_ruby_version >= 2.5
+          node.each_ancestor(*types).first
         end
       end
     end

data/lib/rubocop/cop/{style → layout}/space_after_colon.rb

@@ -1,23 +1,27 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Checks for colon (:) not followed by some kind of space.
       # N.B. this cop does not handle spaces after a ternary operator, which are
-      # instead handled by Style/SpaceAroundOperators.
+      # instead handled by Layout/SpaceAroundOperators.
+      #
+      # @example
+      #   # bad
+      #   def f(a:, b:2); {a:3}; end
+      #
+      #   # good
+      #   def f(a:, b: 2); {a: 3}; end
       class SpaceAfterColon < Cop
-        include IfNode
-
         MSG = 'Space missing after colon.'.freeze
 
         def on_pair(node)
-          colon = node.loc.operator
+          return unless node.colon?
 
-          return unless colon.is?(':')
+          colon = node.loc.operator
 
-          add_offense(colon, colon) unless followed_by_space?(colon)
+          add_offense(colon, location: colon) unless followed_by_space?(colon)
         end
 
         def on_kwoptarg(node)
@@ -25,7 +29,11 @@ module RuboCop
           # optional keyword argument's name, so must construct one.
           colon = node.loc.name.end.resize(1)
 
-          add_offense(colon, colon) unless followed_by_space?(colon)
+          add_offense(colon, location: colon) unless followed_by_space?(colon)
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.insert_after(range, ' ') }
         end
 
         private
@@ -33,10 +41,6 @@ module RuboCop
         def followed_by_space?(colon)
           colon.source_buffer.source[colon.end_pos] =~ /\s/
         end
-
-        def autocorrect(range)
-          ->(corrector) { corrector.insert_after(range, ' ') }
-        end
       end
     end
   end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for comma (,) not followed by some kind of space.
+      #
+      # @example
+      #
+      #   # bad
+      #   [1,2]
+      #   { foo:bar,}
+      #
+      #   # good
+      #   [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.comma?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → layout}/space_after_method_name.rb

@@ -1,34 +1,34 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Checks for space between a method name and a left parenthesis in defs.
       #
       # @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 OnMethodDef
-
         MSG = 'Do not put a space between a method name and the opening ' \
               'parenthesis.'.freeze
 
-        def on_method_def(_node, _method_name, args, _body)
+        def on_def(node)
+          args = node.arguments
           return unless args.loc.begin && args.loc.begin.is?('(')
           expr = args.source_range
-          pos_before_left_paren = Parser::Source::Range.new(expr.source_buffer,
-                                                            expr.begin_pos - 1,
-                                                            expr.begin_pos)
+          pos_before_left_paren = range_between(expr.begin_pos - 1,
+                                                expr.begin_pos)
           return unless pos_before_left_paren.source =~ /\s/
 
-          add_offense(pos_before_left_paren, pos_before_left_paren)
+          add_offense(pos_before_left_paren, location: pos_before_left_paren)
         end
+        alias on_defs on_def
 
         def autocorrect(pos_before_left_paren)
           ->(corrector) { corrector.remove(pos_before_left_paren) }

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for space after `!`.
+      #
+      # @example
+      #   # bad
+      #   ! something
+      #
+      #   # good
+      #   !something
+      class SpaceAfterNot < Cop
+        MSG = 'Do not leave space between `!` and its argument.'.freeze
+
+        def on_send(node)
+          return unless node.keyword_bang? && whitespace_after_operator?(node)
+
+          add_offense(node)
+        end
+
+        def whitespace_after_operator?(node)
+          node.receiver.loc.column - node.loc.column > 1
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(
+              range_between(node.loc.selector.end_pos,
+                            node.receiver.source_range.begin_pos)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → layout}/space_after_semicolon.rb

@@ -1,20 +1,30 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    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('Style/SpaceInsideBlockBraces')
+          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/{style → layout}/space_around_block_parameters.rb

@@ -1,40 +1,61 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Checks the spacing inside and after block parameters pipes.
       #
-      # @example
-      #
+      # @example EnforcedStyleInsidePipes: no_space (default)
       #   # bad
       #   {}.each { | x,  y |puts x }
+      #   ->( x,  y ) { puts x }
       #
       #   # good
       #   {}.each { |x, y| puts x }
+      #   ->(x, y) { puts x }
+      #
+      # @example EnforcedStyleInsidePipes: space
+      #   # bad
+      #   {}.each { |x,  y| puts x }
+      #   ->(x,  y) { puts x }
+      #
+      #   # good
+      #   {}.each { | x, y | puts x }
+      #   ->( x, y ) { puts x }
       class SpaceAroundBlockParameters < Cop
         include ConfigurableEnforcedStyle
 
         def on_block(node)
-          _method, args, body = *node
+          return unless node.arguments?
+
+          args = node.arguments
+
           opening_pipe = args.loc.begin
           closing_pipe = args.loc.end
-          return unless !args.children.empty? && opening_pipe
+          return if opening_pipe.nil? || closing_pipe.nil?
 
           check_inside_pipes(args.children, opening_pipe, closing_pipe)
 
-          if body
-            check_space(closing_pipe.end_pos, body.source_range.begin_pos,
+          if node.body
+            check_space(closing_pipe.end_pos, node.body.source_range.begin_pos,
                         closing_pipe, 'after closing `|`')
           end
 
           check_each_arg(args)
         end
 
+        def autocorrect(range)
+          lambda do |corrector|
+            case range.source
+            when /^\s+$/ then corrector.remove(range)
+            else              corrector.insert_after(range, ' ')
+            end
+          end
+        end
+
         private
 
-        def parameter_name
+        def style_parameter_name
           'EnforcedStyleInsidePipes'
         end
 
@@ -57,16 +78,25 @@ module RuboCop
         end
 
         def check_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+          check_opening_pipe_space(args, opening_pipe)
+          check_closing_pipe_space(args, closing_pipe)
+        end
+
+        def check_opening_pipe_space(args, opening_pipe)
           first = args.first.source_range
-          last = args.last.source_range
-          last_end_pos = last_end_pos_inside_pipes(last.end_pos)
 
           check_space(opening_pipe.end_pos, first.begin_pos, first,
                       'before first block parameter')
-          check_space(last_end_pos, closing_pipe.begin_pos, last,
-                      'after last block parameter')
           check_no_space(opening_pipe.end_pos, first.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)
+
+          check_space(last_end_pos, closing_pipe.begin_pos, last,
+                      'after last block parameter')
           check_no_space(last_end_pos + 1, closing_pipe.begin_pos,
                          'Extra space after last')
         end
@@ -78,32 +108,26 @@ module RuboCop
         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')
+            check_no_space(
+              range_with_surrounding_space(range: expr, side: :left).begin_pos,
+              expr.begin_pos - 1,
+              'Extra space before'
+            )
           end
         end
 
         def check_space(space_begin_pos, space_end_pos, range, msg)
           return if space_begin_pos != space_end_pos
 
-          add_offense(range, range, "Space #{msg} missing.")
+          add_offense(range, location: range, message: "Space #{msg} missing.")
         end
 
         def check_no_space(space_begin_pos, space_end_pos, msg)
           return if space_begin_pos >= space_end_pos
 
-          range = Parser::Source::Range.new(processed_source.buffer,
-                                            space_begin_pos, space_end_pos)
-          add_offense(range, range, "#{msg} block parameter detected.")
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            case range.source
-            when /^\s+$/ then corrector.remove(range)
-            else              corrector.insert_after(range, ' ')
-            end
-          end
+          range = range_between(space_begin_pos, space_end_pos)
+          add_offense(range, location: range,
+                             message: "#{msg} block parameter detected.")
         end
       end
     end

data/lib/rubocop/cop/{style → layout}/space_around_equals_in_parameter_default.rb

@@ -1,26 +1,44 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Checks that the equals signs in parameter default assignments
       # have or don't have surrounding space depending on configuration.
+      # @example
+      #   # bad
+      #   def some_method(arg1=:default, arg2=nil, arg3=[])
+      #     # do something...
+      #   end
+      #
+      #   # good
+      #   def some_method(arg1 = :default, arg2 = nil, arg3 = [])
+      #     # do something...
+      #   end
       class SpaceAroundEqualsInParameterDefault < Cop
         include SurroundingSpace
         include ConfigurableEnforcedStyle
 
+        MSG = 'Surrounding space %<type>s in default value assignment.'.freeze
+
         def on_optarg(node)
           index = index_of_first_token(node)
           arg, equals, value = processed_source.tokens[index, 3]
           check_optarg(arg, equals, value)
         end
 
+        def autocorrect(range)
+          m = range.source.match(/=\s*(\S+)/)
+          rest = m ? m.captures[0] : ''
+          replacement = style == :space ? ' = ' : '='
+          ->(corrector) { corrector.replace(range, replacement + rest) }
+        end
+
         private
 
         def check_optarg(arg, equals, value)
-          space_on_both_sides = space_on_both_sides?(arg, equals, value)
-          no_surrounding_space = no_surrounding_space?(arg, equals, value)
+          space_on_both_sides = space_on_both_sides?(arg, equals)
+          no_surrounding_space = no_surrounding_space?(arg, equals)
 
           if style == :space && space_on_both_sides ||
              style == :no_space && no_surrounding_space
@@ -33,10 +51,8 @@ module RuboCop
 
         def incorrect_style_detected(arg, value, space_on_both_sides,
                                      no_surrounding_space)
-          range = Parser::Source::Range.new(processed_source.buffer,
-                                            arg.pos.end_pos,
-                                            value.pos.begin_pos)
-          add_offense(range, range) do
+          range = range_between(arg.end_pos, value.begin_pos)
+          add_offense(range, location: range) do
             if style == :space && no_surrounding_space ||
                style == :no_space && space_on_both_sides
               opposite_style_detected
@@ -46,24 +62,16 @@ module RuboCop
           end
         end
 
-        def space_on_both_sides?(arg, equals, value)
-          space_between?(arg, equals) && space_between?(equals, value)
+        def space_on_both_sides?(arg, equals)
+          arg.space_after? && equals.space_after?
         end
 
-        def no_surrounding_space?(arg, equals, value)
-          !space_between?(arg, equals) && !space_between?(equals, value)
+        def no_surrounding_space?(arg, equals)
+          !arg.space_after? && !equals.space_after?
         end
 
         def message(_)
-          format('Surrounding space %s in default value assignment.',
-                 style == :space ? 'missing' : 'detected')
-        end
-
-        def autocorrect(range)
-          m = range.source.match(/=\s*(\S+)/)
-          rest = m ? m.captures[0] : ''
-          replacement = style == :space ? ' = ' : '='
-          ->(corrector) { corrector.replace(range, replacement + rest) }
+          format(MSG, type: style == :space ? 'missing' : 'detected')
         end
       end
     end