rubocop 0.49.1 → 0.52.0

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

@@ -12,14 +12,14 @@ module RuboCop
       #   # good
       #
       #   begin
-      #     ...
+      #     # ...
       #   end
       #
       #   # bad
       #
       #   begin
       #
-      #     ...
+      #     # ...
       #
       #   end
       class EmptyLinesAroundBeginBody < Cop

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

@@ -6,24 +6,20 @@ module RuboCop
       # This cops checks if empty lines around the bodies of blocks match
       # the configuration.
       #
-      # @example
-      #
-      #   # EnforcedStyle: empty_lines
-      #
+      # @example EnforcedStyle: empty_lines
       #   # good
       #
       #   foo do |bar|
       #
-      #     ...
+      #     # ...
       #
       #   end
       #
-      #   # EnforcedStyle: no_empty_lines
-      #
+      # @example EnforcedStyle: no_empty_lines (default)
       #   # good
       #
       #   foo do |bar|
-      #     ...
+      #     # ...
       #   end
       class EmptyLinesAroundBlockBody < Cop
         include EmptyLinesAroundBody

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

@@ -6,18 +6,43 @@ module RuboCop
       # This cops checks if empty lines around the bodies of classes match
       # the configuration.
       #
-      # @example
+      # @example EnforcedStyle: empty_lines
+      #   # good
+      #
+      #   class Foo
+      #
+      #     def bar
+      #       # ...
+      #     end
       #
-      #   EnforcedStyle: empty_lines
+      #   end
       #
+      # @example EnforcedStyle: empty_lines_except_namespace
       #   # good
       #
       #   class Foo
+      #     class Bar
+      #
+      #       # ...
+      #
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: empty_lines_special
+      #   # good
+      #   class Foo
+      #
+      #     def bar; end
       #
-      #      def bar
-      #        ...
-      #      end
+      #   end
+      #
+      # @example EnforcedStyle: no_empty_lines (default)
+      #   # good
       #
+      #   class Foo
+      #     def bar
+      #       # ...
+      #     end
       #   end
       class EmptyLinesAroundClassBody < Cop
         include EmptyLinesAroundBody

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

@@ -60,13 +60,13 @@ module RuboCop
       #   end
       class EmptyLinesAroundExceptionHandlingKeywords < Cop
         include EmptyLinesAroundBody
-        include OnMethodDef
 
-        MSG = 'Extra empty line detected %s the `%s`.'.freeze
+        MSG = 'Extra empty line detected %<location>s the `%<keyword>s`.'.freeze
 
-        def on_method_def(_node, _method_name, _args, body)
-          check_body(body)
+        def on_def(node)
+          check_body(node.body)
         end
+        alias on_defs on_def
 
         def on_kwbegin(node)
           body, = *node
@@ -81,15 +81,19 @@ module RuboCop
             line = loc.line
             keyword = loc.source
             # below the keyword
-            check_line(style, line, format(MSG, 'after', keyword), &:empty?)
+            check_line(style, line, message('after', keyword), &:empty?)
             # above the keyword
             check_line(style,
                        line - 2,
-                       format(MSG, 'before', keyword),
+                       message('before', keyword),
                        &:empty?)
           end
         end
 
+        def message(location, keyword)
+          format(MSG, location: location, keyword: keyword)
+        end
+
         def style
           :no_empty_lines
         end

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

@@ -10,25 +10,25 @@ module RuboCop
       #   # good
       #
       #   def foo
-      #     ...
+      #     # ...
       #   end
       #
       #   # bad
       #
       #   def bar
       #
-      #     ...
+      #     # ...
       #
       #   end
       class EmptyLinesAroundMethodBody < Cop
         include EmptyLinesAroundBody
-        include OnMethodDef
 
         KIND = 'method'.freeze
 
-        def on_method_def(node, _method_name, _args, body)
-          check(node, body)
+        def on_def(node)
+          check(node, node.body)
         end
+        alias on_defs on_def
 
         private
 

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

@@ -6,27 +6,42 @@ module RuboCop
       # This cops checks if empty lines around the bodies of modules match
       # the configuration.
       #
-      # @example
-      #
-      #   EnforcedStyle: empty_lines
-      #
+      # @example EnforcedStyle: empty_lines
       #   # good
       #
       #   module Foo
       #
       #     def bar
-      #       ...
+      #       # ...
       #     end
       #
       #   end
       #
-      #   EnforcedStyle: no_empty_lines
+      # @example EnforcedStyle: empty_lines_except_namespace
+      #   # good
+      #
+      #   module Foo
+      #     module Bar
+      #
+      #       # ...
+      #
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: empty_lines_special
+      #   # good
+      #   module Foo
+      #
+      #     def bar; end
+      #
+      #   end
       #
+      # @example EnforcedStyle: no_empty_lines (default)
       #   # good
       #
       #   module Foo
       #     def bar
-      #       ...
+      #       # ...
       #     end
       #   end
       class EmptyLinesAroundModuleBody < Cop

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

@@ -13,7 +13,7 @@ module RuboCop
         def investigate(processed_source)
           last_token = processed_source.tokens.last
           last_line =
-            last_token ? last_token.pos.line : processed_source.lines.length
+            last_token ? last_token.line : processed_source.lines.length
 
           processed_source.raw_source.each_line.with_index do |line, index|
             break if index >= last_line
@@ -23,7 +23,7 @@ module RuboCop
 
             range =
               source_range(processed_source.buffer, index + 1, 0, line.length)
-            add_offense(nil, range, msg)
+            add_offense(nil, location: range, message: msg)
             # Usually there will be carriage return characters on all or none
             # of the lines in a file, so we report only one offense.
             break

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

@@ -23,14 +23,15 @@ module RuboCop
         include PrecedingFollowingAlignment
 
         MSG_UNNECESSARY = 'Unnecessary spacing detected.'.freeze
-        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %s assignment.'.freeze
+        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s ' \
+                             'assignment.'.freeze
 
         def investigate(processed_source)
           return if processed_source.ast.nil?
 
           if force_equal_sign_alignment?
             @asgn_tokens = assignment_tokens
-            @asgn_lines  = @asgn_tokens.map { |t| t.pos.line }
+            @asgn_lines  = @asgn_tokens.map(&:line)
             # Don't attempt to correct the same = more than once
             @corrected   = Set.new
           end
@@ -53,14 +54,14 @@ module RuboCop
         private
 
         def assignment_tokens
-          tokens = processed_source.tokens.select { |t| equal_sign?(t) }
+          tokens = processed_source.tokens.select(&:equal_sign?)
           # we don't want to operate on equals signs which are part of an
           #   optarg in a method definition
           # e.g.: def method(optarg = default_val); end
           tokens = remove_optarg_equals(tokens, processed_source)
 
           # Only attempt to align the first = on each line
-          Set.new(tokens.uniq { |t| t.pos.line })
+          Set.new(tokens.uniq(&:line))
         end
 
         def check_tokens(ast, t1, t2)
@@ -68,8 +69,8 @@ module RuboCop
 
           if force_equal_sign_alignment? &&
              @asgn_tokens.include?(t2) &&
-             (@asgn_lines.include?(t2.pos.line - 1) ||
-              @asgn_lines.include?(t2.pos.line + 1))
+             (@asgn_lines.include?(t2.line - 1) ||
+              @asgn_lines.include?(t2.line + 1))
             check_assignment(t2)
           else
             check_other(t1, t2, ast)
@@ -81,25 +82,25 @@ module RuboCop
           message = ''
           if should_aligned_with_preceding_line?(token)
             assignment_line = preceding_line(token)
-            message = format(MSG_UNALIGNED_ASGN, 'preceding')
+            message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
           else
             assignment_line = following_line(token)
-            message = format(MSG_UNALIGNED_ASGN, 'following')
+            message = format(MSG_UNALIGNED_ASGN, location: 'following')
           end
           return if aligned_assignment?(token.pos, assignment_line)
-          add_offense(token.pos, token.pos, message)
+          add_offense(token.pos, location: token.pos, message: message)
         end
 
         def should_aligned_with_preceding_line?(token)
-          @asgn_lines.include?(token.pos.line - 1)
+          @asgn_lines.include?(token.line - 1)
         end
 
         def preceding_line(token)
-          processed_source.lines[token.pos.line - 2]
+          processed_source.lines[token.line - 2]
         end
 
         def following_line(token)
-          processed_source.lines[token.pos.line]
+          processed_source.lines[token.line]
         end
 
         def check_other(t1, t2, ast)
@@ -108,15 +109,15 @@ module RuboCop
             next if ignored_range?(ast, range.begin_pos)
             next if unary_plus_non_offense?(range)
 
-            add_offense(range, range, MSG_UNNECESSARY)
+            add_offense(range, location: range, message: MSG_UNNECESSARY)
           end
         end
 
         def extra_space_range(t1, t2)
-          return if t1.pos.line != t2.pos.line
+          return if t1.line != t2.line
 
-          start_pos = t1.pos.end_pos
-          end_pos = t2.pos.begin_pos - 1
+          start_pos = t1.end_pos
+          end_pos = t2.begin_pos - 1
           return if end_pos <= start_pos
 
           return if allow_for_alignment? && aligned_tok?(t2)
@@ -125,7 +126,7 @@ module RuboCop
         end
 
         def aligned_tok?(token)
-          if token.type == :tCOMMENT
+          if token.comment?
             aligned_comments?(token)
           else
             aligned_with_something?(token.pos)
@@ -156,7 +157,7 @@ module RuboCop
 
         def aligned_comments?(token)
           ix = processed_source.comments.index do |c|
-            c.loc.expression.begin_pos == token.pos.begin_pos
+            c.loc.expression.begin_pos == token.begin_pos
           end
           aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
         end
@@ -178,13 +179,9 @@ module RuboCop
           cop_config['ForceEqualSignAlignment']
         end
 
-        def equal_sign?(token)
-          token.type == :tEQL || token.type == :tOP_ASGN
-        end
-
         def align_equal_signs(range, corrector)
           lines  = contiguous_assignment_lines(range)
-          tokens = @asgn_tokens.select { |t| lines.include?(t.pos.line) }
+          tokens = @asgn_tokens.select { |t| lines.include?(t.line) }
 
           columns  = tokens.map { |t| align_column(t) }
           align_to = columns.max
@@ -220,8 +217,8 @@ module RuboCop
         def align_column(asgn_token)
           # if we removed unneeded spaces from the beginning of this =,
           # what column would it end from?
-          line    = processed_source.lines[asgn_token.pos.line - 1]
-          leading = line[0...asgn_token.pos.column]
+          line    = processed_source.lines[asgn_token.line - 1]
+          leading = line[0...asgn_token.column]
           spaces  = leading.size - (leading =~ / *\Z/)
           asgn_token.pos.last_column - spaces + 1
         end
@@ -229,7 +226,7 @@ module RuboCop
         def remove_optarg_equals(asgn_tokens, processed_source)
           optargs    = processed_source.ast.each_node(:optarg)
           optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
-          asgn_tokens.reject { |t| optarg_eql.include?(t.pos.begin_pos) }
+          asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
         end
       end
     end

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

@@ -27,15 +27,15 @@ module RuboCop
       #       do_something
       #     end
       class FirstMethodParameterLineBreak < Cop
-        include OnMethodDef
         include FirstElementLineBreak
 
         MSG = 'Add a line break before the first parameter of a ' \
               'multi-line method parameter list.'.freeze
 
-        def on_method_def(node, _method_name, args, _body)
-          check_method_line_break(node, args.to_a)
+        def on_def(node)
+          check_method_line_break(node, node.arguments)
         end
+        alias on_defs on_def
       end
     end
   end

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

@@ -22,6 +22,8 @@ module RuboCop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
 
+        MSG = 'Indent the first parameter one step more than %<base>s.'.freeze
+
         def on_send(node)
           return if !node.arguments? || node.operator_method?
 
@@ -44,7 +46,8 @@ module RuboCop
                  else
                    'the start of the previous line'
                  end
-          format('Indent the first parameter one step more than %s.', base)
+
+          format(MSG, base: base)
         end
 
         def base_indentation(node)
@@ -60,8 +63,7 @@ module RuboCop
 
           parent = node.parent
 
-          return false unless parent && parent.send_type? &&
-                              !parent.method?(:[]=)
+          return false unless eligible_method_call?(parent)
           return false if !parent.parenthesized? &&
                           style == :special_for_inner_method_call_in_parentheses
 
@@ -70,6 +72,10 @@ module RuboCop
           node.source_range.begin_pos > parent.source_range.begin_pos
         end
 
+        def_node_matcher :eligible_method_call?, <<-PATTERN
+          (send _ !:[]= ...)
+        PATTERN
+
         def base_range(send_node, arg_node)
           range_between(send_node.source_range.begin_pos,
                         arg_node.source_range.begin_pos)

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

@@ -19,30 +19,74 @@ module RuboCop
       # This default style is called 'special_inside_parentheses'. Alternative
       # styles are 'consistent' and 'align_brackets'. Here are examples:
       #
-      #     # special_inside_parentheses
-      #     array = [
-      #       :value
-      #     ]
-      #     but_in_a_method_call([
-      #                            :its_like_this
-      #                          ])
-      #     # consistent
-      #     array = [
-      #       :value
-      #     ]
-      #     and_in_a_method_call([
-      #       :no_difference
-      #     ])
-      #     # align_brackets
-      #     and_now_for_something = [
-      #                               :completely_different
-      #                             ]
+      # @example EnforcedStyle: special_inside_parentheses
+      #   # The `special_inside_parentheses` style enforces that the first
+      #   # element in an array literal where the opening bracket and first
+      #   # element are on seprate lines is indented one step (two spaces) more
+      #   # than the position inside the opening parenthesis.
       #
+      #   #bad
+      #   array = [
+      #     :value
+      #   ]
+      #   and_in_a_method_call([
+      #     :no_difference
+      #                        ])
+      #
+      #   #good
+      #   array = [
+      #     :value
+      #   ]
+      #   but_in_a_method_call([
+      #                          :its_like_this
+      #                        ])
+      #
+      # @example EnforcedStyle: consistent
+      #   # The `consistent` style enforces that the first element in an array
+      #   # literal where the opening bracket and the first element are on
+      #   # seprate lines is indented the same as an array literal which is not
+      #   # defined inside a method call.
+      #
+      #   #bad
+      #   # consistent
+      #   array = [
+      #     :value
+      #   ]
+      #   but_in_a_method_call([
+      #                          :its_like_this
+      #   ])
+      #
+      #   #good
+      #   array = [
+      #     :value
+      #   ]
+      #   and_in_a_method_call([
+      #     :no_difference
+      #   ])
+      #
+      # @example EnforcedStyle: align_brackets
+      #   # The `align_brackets` style enforces that the opening and closing
+      #   # brackets are indented to the same position.
+      #
+      #   #bad
+      #   # align_brackets
+      #   and_now_for_something = [
+      #                             :completely_different
+      #   ]
+      #
+      #   #good
+      #   # align_brackets
+      #   and_now_for_something = [
+      #                             :completely_different
+      #                           ]
       class IndentArray < Cop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
         include ArrayHashIndentation
 
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+              'in an array, relative to %<base_description>s.'.freeze
+
         def on_array(node)
           check(node, nil) if node.loc.begin
         end
@@ -90,7 +134,7 @@ module RuboCop
                   'Indent the right bracket the same as the start of the line' \
                   ' where the left bracket is.'
                 end
-          add_offense(right_bracket, right_bracket, msg)
+          add_offense(right_bracket, location: right_bracket, message: msg)
         end
 
         # Returns the description of what the correct indentation is based on.
@@ -105,8 +149,11 @@ module RuboCop
         end
 
         def message(base_description)
-          format('Use %d spaces for indentation in an array, relative to %s.',
-                 configured_indentation_width, base_description)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            base_description: base_description
+          )
         end
       end
     end