rubocop 0.49.1 → 0.52.0

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

@@ -34,6 +34,7 @@ module RuboCop
       #     def foo(a,
       #       b
       #     )
+      #     end
       #
       #     # symmetrical: bad
       #     # new_line: bad
@@ -41,12 +42,14 @@ module RuboCop
       #     def foo(
       #       a,
       #       b)
+      #     end
       #
       #     # symmetrical: good
       #     # new_line: bad
       #     # same_line: good
       #     def foo(a,
       #       b)
+      #     end
       #
       #     # symmetrical: good
       #     # new_line: good
@@ -55,8 +58,8 @@ module RuboCop
       #       a,
       #       b
       #     )
+      #     end
       class MultilineMethodDefinitionBraceLayout < Cop
-        include OnMethodDef
         include MultilineLiteralBraceLayout
 
         SAME_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
@@ -73,9 +76,10 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
           'on the same line as the last parameter.'.freeze
 
-        def on_method_def(_node, _method_name, args, _body)
-          check_brace_layout(args)
+        def on_def(node)
+          check_brace_layout(node.arguments)
         end
+        alias on_defs on_def
       end
     end
   end

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

@@ -12,6 +12,12 @@ module RuboCop
       #   b
       #     something
       #   end
+      #
+      #   # good
+      #   if a +
+      #      b
+      #     something
+      #   end
       class MultilineOperationIndentation < Cop
         include ConfigurableEnforcedStyle
         include AutocorrectAlignment

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

@@ -22,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)
@@ -57,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)

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

@@ -6,6 +6,13 @@ module RuboCop
       # 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 Layout/SpaceAroundOperators.
+      #
+      # @example
+      #   # bad
+      #   def f(a:, b:2); {a:3}; end
+      #
+      #   # good
+      #   def f(a:, b: 2); {a: 3}; end
       class SpaceAfterColon < Cop
         MSG = 'Space missing after colon.'.freeze
 
@@ -14,7 +21,7 @@ module RuboCop
 
           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)
@@ -22,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
@@ -30,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

@@ -4,6 +4,16 @@ 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
 
@@ -13,7 +23,7 @@ module RuboCop
         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,25 +8,27 @@ 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 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 = 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

@@ -17,7 +17,7 @@ module RuboCop
         def on_send(node)
           return unless node.keyword_bang? && whitespace_after_operator?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def whitespace_after_operator?(node)

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

@@ -4,6 +4,13 @@ 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
 
@@ -13,7 +20,7 @@ module RuboCop
         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

@@ -5,10 +5,7 @@ module RuboCop
     module Layout
       # Checks the spacing inside and after block parameters pipes.
       #
-      # @example
-      #
-      #   # EnforcedStyleInsidePipes: no_space (default)
-      #
+      # @example EnforcedStyleInsidePipes: no_space (default)
       #   # bad
       #   {}.each { | x,  y |puts x }
       #   ->( x,  y ) { puts x }
@@ -17,10 +14,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 }
@@ -50,6 +44,15 @@ module RuboCop
           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 style_parameter_name
@@ -75,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
@@ -96,31 +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 = range_between(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
+          add_offense(range, location: range,
+                             message: "#{msg} block parameter detected.")
         end
       end
     end

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

@@ -5,21 +5,40 @@ module RuboCop
     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
@@ -32,8 +51,8 @@ module RuboCop
 
         def incorrect_style_detected(arg, value, space_on_both_sides,
                                      no_surrounding_space)
-          range = range_between(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
@@ -43,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

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

@@ -25,8 +25,8 @@ module RuboCop
       #
       #   something = 123 if test
       class SpaceAroundKeyword < Cop
-        MSG_BEFORE = 'Space before keyword `%s` is missing.'.freeze
-        MSG_AFTER = 'Space after keyword `%s` is missing.'.freeze
+        MSG_BEFORE = 'Space before keyword `%<range>s` is missing.'.freeze
+        MSG_AFTER = 'Space after keyword `%<range>s` is missing.'.freeze
 
         DO = 'do'.freeze
         SAFE_NAVIGATION = '&.'.freeze
@@ -127,6 +127,14 @@ module RuboCop
           check(node, [:keyword].freeze)
         end
 
+        def autocorrect(range)
+          if space_before_missing?(range)
+            ->(corrector) { corrector.insert_before(range, ' '.freeze) }
+          else
+            ->(corrector) { corrector.insert_after(range, ' '.freeze) }
+          end
+        end
+
         private
 
         def check(node, locations, begin_keyword = DO)
@@ -166,7 +174,9 @@ module RuboCop
         end
 
         def offense(range, msg)
-          add_offense(range, range, msg % range.source)
+          add_offense(range,
+                      location: range,
+                      message: format(msg, range: range.source))
         end
 
         def space_before_missing?(range)
@@ -178,16 +188,20 @@ module RuboCop
         def space_after_missing?(range)
           pos = range.end_pos
           char = range.source_buffer.source[pos]
-          return false unless char
-          return false if accept_left_parenthesis?(range) &&
-                          char == '('.freeze
-          return false if accept_left_square_bracket?(range) &&
-                          char == '['.freeze
+
+          return false if accepted_opening_delimiter?(range, char)
           return false if safe_navigation_call?(range, pos)
 
           char !~ /[\s;,#\\\)\}\]\.]/
         end
 
+        def accepted_opening_delimiter?(range, char)
+          return true unless char
+
+          accept_left_square_bracket?(range) && char == '[' ||
+            accept_left_parenthesis?(range) && char == '('
+        end
+
         def accept_left_parenthesis?(range)
           ACCEPT_LEFT_PAREN.include?(range.source)
         end
@@ -210,14 +224,6 @@ module RuboCop
           end
           false
         end
-
-        def autocorrect(range)
-          if space_before_missing?(range)
-            ->(corrector) { corrector.insert_before(range, ' '.freeze) }
-          else
-            ->(corrector) { corrector.insert_after(range, ' '.freeze) }
-          end
-        end
       end
     end
   end