rubocop 0.52.1 → 0.53.0

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

@@ -23,17 +23,19 @@ module RuboCop
       #     'Item 2'
       #   ]
       class ImplicitStringConcatenation < Cop
-        MSG = 'Combine %s and %s into a single string literal, rather than ' \
-              'using implicit string concatenation.'.freeze
+        MSG = 'Combine %<string1>s and %<string2>s into a single string ' \
+              'literal, rather than using implicit string concatenation.'.freeze
         FOR_ARRAY = ' Or, if they were intended to be separate array ' \
                     'elements, separate them with a comma.'.freeze
         FOR_METHOD = ' Or, if they were intended to be separate method ' \
                      'arguments, separate them with a comma.'.freeze
 
         def on_dstr(node)
-          each_bad_cons(node) do |child1, child2|
-            range   = child1.source_range.join(child2.source_range)
-            message = format(MSG, display_str(child1), display_str(child2))
+          each_bad_cons(node) do |child_node1, child_node2|
+            range   = child_node1.source_range.join(child_node2.source_range)
+            message = format(MSG,
+                             string1: display_str(child_node1),
+                             string2: display_str(child_node2))
             if node.parent && node.parent.array_type?
               message << FOR_ARRAY
             elsif node.parent && node.parent.send_type?
@@ -46,17 +48,17 @@ module RuboCop
         private
 
         def each_bad_cons(node)
-          node.children.each_cons(2) do |child1, child2|
+          node.children.each_cons(2) do |child_node1, child_node2|
             # `'abc' 'def'` -> (dstr (str "abc") (str "def"))
-            next unless string_literal?(child1) && string_literal?(child2)
-            next unless child1.last_line == child2.first_line
+            next unless string_literals?(child_node1, child_node2)
+            next unless child_node1.last_line == child_node2.first_line
 
             # Make sure we don't flag a string literal which simply has
             # embedded newlines
             # `"abc\ndef"` also -> (dstr (str "abc") (str "def"))
-            next unless child1.source[-1] == ending_delimiter(child1)
+            next unless child_node1.source[-1] == ending_delimiter(child_node1)
 
-            yield child1, child2
+            yield child_node1, child_node2
           end
         end
 
@@ -74,6 +76,10 @@ module RuboCop
             (node.dstr_type? && node.children.all? { |c| string_literal?(c) })
         end
 
+        def string_literals?(node1, node2)
+          string_literal?(node1) && string_literal?(node2)
+        end
+
         def display_str(node)
           if node.source =~ /\n/
             str_content(node).inspect

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

@@ -46,8 +46,8 @@ module RuboCop
       #     end
       #   end
       class IneffectiveAccessModifier < Cop
-        MSG = '`%s` (on line %d) does not make singleton methods %s. ' \
-              'Use %s instead.'.freeze
+        MSG = '`%<modifier>s` (on line %<line>d) does not make singleton ' \
+              'methods %<modifier>s. Use %<alternative>s instead.'.freeze
         ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a ' \
                               '`class << self` block'.freeze
         ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
@@ -91,8 +91,9 @@ module RuboCop
                         else
                           ALTERNATIVE_PROTECTED
                         end
-          format(MSG, visibility, modifier.location.expression.line, visibility,
-                 alternative)
+          format(MSG, modifier: visibility,
+                      line: modifier.location.expression.line,
+                      alternative: alternative)
         end
 
         def check_scope(node, cur_vis = :public)

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

@@ -28,7 +28,7 @@ module RuboCop
       class InheritException < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Inherit from `%s` instead of `%s`.'.freeze
+        MSG = 'Inherit from `%<prefer>s` instead of `%<current>s`.'.freeze
         PREFERRED_BASE_CLASS = {
           runtime_error: 'RuntimeError',
           standard_error: 'StandardError'
@@ -64,7 +64,7 @@ module RuboCop
         private
 
         def message(node)
-          format(MSG, preferred_base_class, node.const_name)
+          format(MSG, prefer: preferred_base_class, current: node.const_name)
         end
 
         def illegal_class_name?(class_node)

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

@@ -18,12 +18,13 @@ module RuboCop
       #   foo = "something with #{interpolation} inside"
       class InterpolationCheck < Cop
         MSG = 'Interpolation in single quoted string detected. '\
-	      'Use double quoted strings if you need interpolation.'.freeze
+              'Use double quoted strings if you need interpolation.'.freeze
 
         def on_str(node)
           return if heredoc?(node)
-          return if node.parent && node.parent.dstr_type?
-          return unless node.str_content.scrub =~ /#\{.*\}/
+          parent = node.parent
+          return if parent && (parent.dstr_type? || parent.regexp_type?)
+          return unless node.source.scrub =~ /(?<!\\)#\{.*\}/
           add_offense(node)
         end
 

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

@@ -31,7 +31,7 @@ module RuboCop
       #     do_something
       #   end
       class LiteralAsCondition < Cop
-        MSG = 'Literal `%s` appeared as a condition.'.freeze
+        MSG = 'Literal `%<literal>s` appeared as a condition.'.freeze
 
         def on_if(node)
           check_for_literal(node)
@@ -71,7 +71,7 @@ module RuboCop
         end
 
         def message(node)
-          format(MSG, node.source)
+          format(MSG, literal: node.source)
         end
 
         private

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

@@ -17,6 +17,8 @@ module RuboCop
       #
       #   "result is 10"
       class LiteralInInterpolation < Cop
+        include RangeHelp
+
         MSG = 'Literal interpolation detected.'.freeze
         COMPOSITE = %i[array hash pair irange erange].freeze
 

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/UnneededDisable
+# rubocop:disable Lint/UnneededCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -43,9 +43,11 @@ module RuboCop
       #   # rubocop:enable Layout/SpaceAroundOperators
       #
       class MissingCopEnableDirective < Cop
-        MSG = 'Re-enable %{cop} cop with `# rubocop:enable` after disabling it.'
-              .freeze
-        MSG_BOUND = 'Re-enable %{cop} cop within %{max_range} lines after ' \
+        include RangeHelp
+
+        MSG = 'Re-enable %<cop>s cop with `# rubocop:enable` after ' \
+              'disabling it.'.freeze
+        MSG_BOUND = 'Re-enable %<cop>s cop within %<max_range>s lines after ' \
                     'disabling it.'.freeze
 
         def investigate(processed_source)
@@ -78,4 +80,4 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/UnneededDisable, Layout/SpaceAroundOperators
+# rubocop:enable Lint/UnneededCopDisableDirective, Layout/SpaceAroundOperators

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

@@ -25,7 +25,7 @@ module RuboCop
         # if found within a percent literal expression, will cause a
         # NestedPercentLiteral violation to be emitted.
         REGEXES = PercentLiteral::PERCENT_LITERAL_TYPES.map do |percent_literal|
-          /#{percent_literal}\W/
+          /\A#{percent_literal}\W/
         end.freeze
 
         def on_array(node)

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop warns the usage of unsafe number conversions. Unsafe
+      # number conversion can cause unexpected error if auto type conversion
+      # fails. Cop prefer parsing with number class instead.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   '10'.to_i
+      #   '10.2'.to_f
+      #   '10'.to_c
+      #
+      #   # good
+      #
+      #   Integer('10', 10)
+      #   Float('10.2')
+      #   Complex('10')
+      class NumberConversion < Cop
+        CONVERSION_METHOD_CLASS_MAPPING = {
+          to_i: "#{Integer.name}(%<number_object>s, 10)",
+          to_f: "#{Float.name}(%<number_object>s)",
+          to_c: "#{Complex.name}(%<number_object>s)"
+        }.freeze
+        MSG = 'Replace unsafe number conversion with number '\
+              'class parsing, instead of using '\
+              '%<number_object>s.%<to_method>s, use stricter '\
+              '%<corrected_method>s.'.freeze
+
+        def_node_matcher :to_method, <<-PATTERN
+          (send $_ ${:to_i :to_f :to_c})
+        PATTERN
+
+        def on_send(node)
+          to_method(node) do |receiver, to_method|
+            message = format(
+              MSG,
+              number_object: receiver.source,
+              to_method: to_method,
+              corrected_method: correct_method(node, receiver)
+            )
+            add_offense(node, message: message)
+          end
+        end
+
+        private
+
+        def correct_method(node, receiver)
+          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
+                 number_object: receiver.source)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # Checks the proper ordering of magic comments and whether
+      # a magic comment is not placed before a shebang.
+      #
+      # @example
+      #   # bad
+      #
+      #   # frozen_string_literal: true
+      #   # encoding: ascii
+      #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:UTF-8>]
+      #
+      #   # good
+      #
+      #   # encoding: ascii
+      #   # frozen_string_literal: true
+      #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>]
+      #
+      #   # good
+      #
+      #   #!/usr/bin/env ruby
+      #   # encoding: ascii
+      #   # frozen_string_literal: true
+      #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>]
+      #
+      class OrderedMagicComments < Cop
+        include FrozenStringLiteral
+
+        MSG = 'The encoding magic comment should precede all other ' \
+              'magic comments.'.freeze
+
+        def investigate(processed_source)
+          return if processed_source.buffer.source.empty?
+
+          encoding_line, frozen_string_literal_line = magic_comment_lines
+
+          return unless encoding_line && frozen_string_literal_line
+          return if encoding_line < frozen_string_literal_line
+
+          range = processed_source.buffer.line_range(encoding_line + 1)
+
+          add_offense(range, location: range)
+        end
+
+        def autocorrect(_node)
+          encoding_line, frozen_string_literal_line = magic_comment_lines
+
+          range1 = processed_source.buffer.line_range(encoding_line + 1)
+          range2 =
+            processed_source.buffer.line_range(frozen_string_literal_line + 1)
+
+          lambda do |corrector|
+            corrector.replace(range1, range2.source)
+            corrector.replace(range2, range1.source)
+          end
+        end
+
+        private
+
+        def magic_comment_lines
+          lines = [nil, nil]
+
+          magic_comments.each.with_index do |comment, index|
+            if comment.encoding_specified?
+              lines[0] = index
+            elsif comment.frozen_string_literal_specified?
+              lines[1] = index
+            end
+
+            return lines if lines[0] && lines[1]
+          end
+
+          lines
+        end
+
+        def magic_comments
+          leading_comment_lines.map { |line| MagicComment.parse(line) }
+        end
+      end
+    end
+  end
+end

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

@@ -18,6 +18,8 @@ module RuboCop
       #
       #   puts(x + y)
       class ParenthesesAsGroupedExpression < Cop
+        include RangeHelp
+
         MSG = '`(...)` interpreted as grouped expression.'.freeze
 
         def on_send(node)

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

@@ -40,7 +40,6 @@ module RuboCop
           add_offense(node)
         end
 
-        # rubocop:disable Performance/HashEachMethods
         def autocorrect(node)
           lambda do |corrector|
             node.values.each do |value|
@@ -55,7 +54,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Performance/HashEachMethods
 
         private
 

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

@@ -21,7 +21,7 @@ module RuboCop
       #
       #   0 # just use 0 instead
       class RandOne < Cop
-        MSG = '`%s` always returns `0`. ' \
+        MSG = '`%<method>s` always returns `0`. ' \
               'Perhaps you meant `rand(2)` or `rand`?'.freeze
 
         def_node_matcher :rand_one?, <<-PATTERN
@@ -37,7 +37,7 @@ module RuboCop
         private
 
         def message(node)
-          format(MSG, node.source)
+          format(MSG, method: node.source)
         end
       end
     end

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

@@ -27,6 +27,8 @@ module RuboCop
       #   end
       #
       class RedundantWithIndex < Cop
+        include RangeHelp
+
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'.freeze
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'.freeze
 

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

@@ -27,6 +27,8 @@ module RuboCop
       #   end
       #
       class RedundantWithObject < Cop
+        include RangeHelp
+
         MSG_EACH_WITH_OBJECT = 'Use `each` instead of `each_with_object`.'
                                .freeze
         MSG_WITH_OBJECT = 'Remove redundant `with_object`.'.freeze

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

@@ -28,6 +28,8 @@ module RuboCop
       #     # ...
       #   end
       class RequireParentheses < Cop
+        include RangeHelp
+
         MSG = 'Use parentheses in the method call to avoid confusion about ' \
               'precedence.'.freeze
 

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

@@ -37,8 +37,8 @@ module RuboCop
       class RescueType < Cop
         include RescueNode
 
-        MSG = 'Rescuing from `%s` will raise a `TypeError` instead of ' \
-              'catching the actual exception.'.freeze
+        MSG = 'Rescuing from `%<invalid_exceptions>s` will raise a ' \
+              '`TypeError` instead of catching the actual exception.'.freeze
         INVALID_TYPES = %i[array dstr float hash nil int str sym].freeze
 
         def on_resbody(node)
@@ -51,7 +51,10 @@ module RuboCop
           add_offense(
             node,
             location: node.loc.keyword.join(rescued.loc.expression),
-            message: format(MSG, invalid_exceptions.map(&:source).join(', '))
+            message: format(
+              MSG, invalid_exceptions: invalid_exceptions.map(&:source)
+                                                         .join(', ')
+            )
           )
         end
 

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

@@ -32,7 +32,7 @@ module RuboCop
       #     return
       #   end
       class ReturnInVoidContext < Cop
-        MSG = 'Do not return a value in `%s`.'.freeze
+        MSG = 'Do not return a value in `%<method>s`.'.freeze
 
         def on_return(return_node)
           return unless return_node.descendants.any?
@@ -47,7 +47,7 @@ module RuboCop
 
           add_offense(return_node,
                       location: :keyword,
-                      message: format(message, method_name))
+                      message: format(message, method: method_name))
         end
 
         private