rubocop 0.52.1 → 0.53.0

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

@@ -20,6 +20,7 @@ module RuboCop
       #      var = "This is the #{ space } example"
       class SpaceInsideStringInterpolation < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         NO_SPACE_MSG = 'Space inside string interpolation detected.'.freeze
         SPACE_MSG = 'Missing space around string interpolation detected.'.freeze

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

@@ -6,23 +6,39 @@ module RuboCop
   module Cop
     module Layout
       # This cop checks for tabs inside the source code.
+      #
+      # @example
+      #   # bad
+      #   # This example uses a tab to indent bar.
+      #   def foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   # This example uses spaces to indent bar.
+      #   def foo
+      #     bar
+      #   end
+      #
       class Tab < Cop
         include Alignment
+        include RangeHelp
 
         MSG = 'Tab detected.'.freeze
 
         def investigate(processed_source)
-          str_lines = string_literal_lines(processed_source.ast)
+          str_ranges = string_literal_ranges(processed_source.ast)
 
-          processed_source.lines.each_with_index do |line, index|
-            match = line.match(/^( *)[\t ]*\t/)
+          processed_source.lines.each.with_index(1) do |line, lineno|
+            match = line.match(/^([^\t]*)\t+/)
             next unless match
-            next if str_lines.include?(index + 1)
+            prefix = match.captures[0]
+            col = prefix.length
+            next if in_string_literal?(str_ranges, lineno, col)
 
-            spaces = match.captures[0]
             range = source_range(processed_source.buffer,
-                                 index + 1,
-                                 (spaces.length)...(match.end(0)))
+                                 lineno,
+                                 col...match.end(0))
 
             add_offense(range, location: range)
           end
@@ -37,21 +53,31 @@ module RuboCop
 
         private
 
-        def string_literal_lines(ast)
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def in_string_literal?(ranges, line, col)
+          ranges.any? do |range|
+            (range.line == line && range.column <= col) ||
+              (range.line < line && line < range.last_line) ||
+              (range.line != line && range.last_line == line &&
+               range.last_column >= col)
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def string_literal_ranges(ast)
           # which lines start inside a string literal?
           return [] if ast.nil?
 
-          ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, lines|
+          ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, ranges|
             loc = str.location
 
-            str_lines = if loc.is_a?(Parser::Source::Map::Heredoc)
-                          body = loc.heredoc_body
-                          (body.first_line)..(body.last_line)
-                        else
-                          (loc.first_line + 1)..(loc.last_line)
-                        end
+            range = if str.heredoc?
+                      loc.heredoc_body
+                    else
+                      loc.expression
+                    end
 
-            lines.merge(str_lines.to_a)
+            ranges << range
           end
         end
       end

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

@@ -5,12 +5,45 @@ module RuboCop
     module Layout
       # This cop looks for trailing blank lines and a final newline in the
       # source code.
+      #
+      # @example EnforcedStyle: final_blank_line
+      #   # `final_blank_line` looks for one blank line followed by a new line
+      #   # at the end of files.
+      #
+      #   # bad
+      #   class Foo; end
+      #   # EOF
+      #
+      #   # bad
+      #   class Foo; end # EOF
+      #
+      #   # good
+      #   class Foo; end
+      #
+      #   # EOF
+      #
+      # @example EnforcedStyle: final_newline (default)
+      #   # `final_newline` looks for one newline at the end of files.
+      #
+      #   # bad
+      #   class Foo; end
+      #
+      #   # EOF
+      #
+      #   # bad
+      #   class Foo; end # EOF
+      #
+      #   # good
+      #   class Foo; end
+      #   # EOF
+      #
       class TrailingBlankLines < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         def investigate(processed_source)
-          sb = processed_source.buffer
-          return if sb.source.empty?
+          buffer = processed_source.buffer
+          return if buffer.source.empty?
 
           # The extra text that comes after the last token could be __END__
           # followed by some data to read. If so, we don't check it because
@@ -18,13 +51,13 @@ module RuboCop
           # number of newlines.
           return if ends_in_end?(processed_source)
 
-          whitespace_at_end = sb.source[/\s*\Z/]
+          whitespace_at_end = buffer.source[/\s*\Z/]
           blank_lines = whitespace_at_end.count("\n") - 1
           wanted_blank_lines = style == :final_newline ? 0 : 1
 
           return unless blank_lines != wanted_blank_lines
 
-          offense_detected(sb, wanted_blank_lines, blank_lines,
+          offense_detected(buffer, wanted_blank_lines, blank_lines,
                            whitespace_at_end)
         end
 
@@ -36,12 +69,12 @@ module RuboCop
 
         private
 
-        def offense_detected(sb, wanted_blank_lines, blank_lines,
+        def offense_detected(buffer, wanted_blank_lines, blank_lines,
                              whitespace_at_end)
-          begin_pos = sb.source.length - whitespace_at_end.length
-          autocorrect_range = range_between(begin_pos, sb.source.length)
+          begin_pos = buffer.source.length - whitespace_at_end.length
+          autocorrect_range = range_between(begin_pos, buffer.source.length)
           begin_pos += 1 unless whitespace_at_end.empty?
-          report_range = range_between(begin_pos, sb.source.length)
+          report_range = range_between(begin_pos, buffer.source.length)
 
           add_offense(autocorrect_range,
                       location: report_range,
@@ -49,12 +82,12 @@ module RuboCop
         end
 
         def ends_in_end?(processed_source)
-          sb = processed_source.buffer
+          buffer = processed_source.buffer
 
-          return true if sb.source.strip.start_with?('__END__')
+          return true if buffer.source.strip.start_with?('__END__')
           return false if processed_source.tokens.empty?
 
-          extra = sb.source[processed_source.tokens.last.end_pos..-1]
+          extra = buffer.source[processed_source.tokens.last.end_pos..-1]
           extra && extra.strip.start_with?('__END__')
         end
 
@@ -70,8 +103,8 @@ module RuboCop
                          else
                            "instead of #{wanted_blank_lines} "
                          end
-            format('%d trailing blank lines %sdetected.', blank_lines,
-                   instead_of)
+            format('%<current>d trailing blank lines %<prefer>sdetected.',
+                   current: blank_lines, prefer: instead_of)
           end
         end
       end

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

@@ -4,7 +4,19 @@ module RuboCop
   module Cop
     module Layout
       # This cop looks for trailing whitespace in the source code.
+      #
+      # @example
+      #   # The line in this example contains spaces after the 0.
+      #   # bad
+      #   x = 0
+      #
+      #   # The line in this example ends directly after the 0.
+      #   # good
+      #   x = 0
+      #
       class TrailingWhitespace < Cop
+        include RangeHelp
+
         MSG = 'Trailing whitespace detected.'.freeze
 
         def investigate(processed_source)

data/lib/rubocop/cop/lint/ambiguous_block_association.rb

@@ -25,8 +25,9 @@ module RuboCop
       #   # Lambda arguments require no disambiguation
       #   foo = ->(bar) { bar.baz }
       class AmbiguousBlockAssociation < Cop
-        MSG = 'Parenthesize the param `%s` to make sure that the block will be'\
-              ' associated with the `%s` method call.'.freeze
+        MSG = 'Parenthesize the param `%<param>s` to make sure that the ' \
+              'block will be associated with the `%<method>s` method ' \
+              'call.'.freeze
 
         def on_send(node)
           return if !node.arguments? || node.parenthesized? ||
@@ -51,7 +52,8 @@ module RuboCop
         def message(send_node)
           block_param = send_node.last_argument
 
-          format(MSG, block_param.source, block_param.send_node.source)
+          format(MSG, param: block_param.source,
+                      method: block_param.send_node.source)
         end
       end
     end

data/lib/rubocop/cop/lint/big_decimal_new.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # `BigDecimal.new()` is deprecated since BigDecimal 1.3.3.
+      # This cop identifies places where `BigDecimal.new()`
+      # can be replaced by `BigDecimal()`.
+      #
+      # @example
+      #   # bad
+      #   BigDecimal.new(123.456, 3)
+      #
+      #   # good
+      #   BigDecimal(123.456, 3)
+      #
+      class BigDecimalNew < Cop
+        MSG = '`%<double_colon>sBigDecimal.new()` is deprecated. ' \
+              'Use `%<double_colon>sBigDecimal()` instead.'.freeze
+
+        def_node_matcher :big_decimal_new, <<-PATTERN
+          (send
+            (const ${nil? cbase} :BigDecimal) :new ...)
+        PATTERN
+
+        def on_send(node)
+          return unless big_decimal_new(node) do |captured_value|
+            double_colon = captured_value ? '::' : ''
+            message = format(MSG, double_colon: double_colon)
+
+            add_offense(node, location: :selector, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.selector)
+            corrector.remove(node.loc.dot)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/boolean_symbol.rb

@@ -23,14 +23,14 @@ module RuboCop
       #   false
       class BooleanSymbol < Cop
         MSG = 'Symbol with a boolean name - ' \
-              'you probably meant to use `%s`.'.freeze
+              'you probably meant to use `%<boolean>s`.'.freeze
 
         def_node_matcher :boolean_symbol?, '(sym {:true :false})'
 
         def on_sym(node)
           return unless boolean_symbol?(node)
 
-          add_offense(node, message: format(MSG, node.value))
+          add_offense(node, message: format(MSG, boolean: node.value))
         end
       end
     end

data/lib/rubocop/cop/lint/circular_argument_reference.rb

@@ -48,7 +48,7 @@ module RuboCop
       #     dry_ingredients.combine
       #   end
       class CircularArgumentReference < Cop
-        MSG = 'Circular argument reference - `%s`.'.freeze
+        MSG = 'Circular argument reference - `%<arg_name>s`.'.freeze
 
         def on_kwoptarg(node)
           check_for_circular_argument_references(*node)
@@ -64,7 +64,7 @@ module RuboCop
           return unless arg_value.lvar_type?
           return unless arg_value.to_a == [arg_name]
 
-          add_offense(arg_value, message: format(MSG, arg_name))
+          add_offense(arg_value, message: format(MSG, arg_name: arg_name))
         end
       end
     end

data/lib/rubocop/cop/lint/debugger.rb

@@ -33,7 +33,7 @@ module RuboCop
       #     do_something
       #   end
       class Debugger < Cop
-        MSG = 'Remove debugger entry point `%s`.'.freeze
+        MSG = 'Remove debugger entry point `%<source>s`.'.freeze
 
         def_node_matcher :kernel?, <<-PATTERN
           {
@@ -67,7 +67,7 @@ module RuboCop
         private
 
         def message(node)
-          format(MSG, node.source)
+          format(MSG, source: node.source)
         end
 
         def binding_irb?(node)

data/lib/rubocop/cop/lint/deprecated_class_methods.rb

@@ -39,7 +39,7 @@ module RuboCop
           end
         end
 
-        MSG = '`%s` is deprecated in favor of `%s`.'.freeze
+        MSG = '`%<current>s` is deprecated in favor of `%<prefer>s`.'.freeze
         DEPRECATED_METHODS_OBJECT = [
           DeprecatedClassMethod.new(:File, :exists?, :exist?),
           DeprecatedClassMethod.new(:Dir, :exists?, :exist?)
@@ -47,8 +47,8 @@ module RuboCop
 
         def on_send(node)
           check(node) do |data|
-            message = format(MSG, deprecated_method(data),
-                             replacement_method(data))
+            message = format(MSG, current: deprecated_method(data),
+                                  prefer: replacement_method(data))
 
             add_offense(node, location: :selector, message: message)
           end
@@ -82,7 +82,8 @@ module RuboCop
         end
 
         def method_call(class_constant, method)
-          format('%s.%s', class_constant, method)
+          format('%<constant>s.%<method>s', constant: class_constant,
+                                            method: method)
         end
       end
     end

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -10,11 +10,11 @@ module RuboCop
       #
       #   # bad
       #
-      #   def duplicated
+      #   def foo
       #     1
       #   end
       #
-      #   def duplicated
+      #   def foo
       #     2
       #   end
       #
@@ -22,25 +22,36 @@ module RuboCop
       #
       #   # bad
       #
-      #   def duplicated
+      #   def foo
       #     1
       #   end
       #
-      #   alias duplicated other_duplicated
+      #   alias foo bar
       #
       # @example
       #
       #   # good
       #
-      #   def duplicated
+      #   def foo
       #     1
       #   end
       #
-      #   def other_duplicated
+      #   def bar
       #     2
       #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     1
+      #   end
+      #
+      #   alias bar foo
       class DuplicateMethods < Cop
-        MSG = 'Method `%s` is defined at both %s and %s.'.freeze
+        MSG = 'Method `%<method>s` is defined at both %<defined>s and ' \
+              '%<current>s.'.freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -121,8 +132,8 @@ module RuboCop
         end
 
         def message_for_dup(node, method_name)
-          format(MSG, method_name, @definitions[method_name],
-                 source_location(node))
+          format(MSG, method: method_name, defined: @definitions[method_name],
+                      current: source_location(node))
         end
 
         def found_instance_method(node, name)

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -20,8 +20,8 @@ module RuboCop
       #   format('A value: %s and another: %i', a_value, another)
       class FormatParameterMismatch < Cop
         # http://rubular.com/r/CvpbxkcTzy
-        MSG = "Number of arguments (%i) to `%s` doesn't match the number of " \
-              'fields (%i).'.freeze
+        MSG = "Number of arguments (%<arg_num>i) to `%<method>s` doesn't " \
+              'match the number of fields (%<field_num>i).'.freeze
         FIELD_REGEX =
           /(%(([\s#+-0\*]*)(\d*)?(\.\d+)?[bBdiouxXeEfgGaAcps]|%))/
         NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/
@@ -169,7 +169,8 @@ module RuboCop
 
           method_name = node.method?(:%) ? 'String#%' : node.method_name
 
-          format(MSG, num_args_for_format, method_name, num_expected_fields)
+          format(MSG, arg_num: num_args_for_format, method: method_name,
+                      field_num: num_expected_fields)
         end
       end
     end