rubocop 0.49.1 → 0.52.0

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

@@ -23,7 +23,7 @@ module RuboCop
         MSG = "Number of arguments (%i) to `%s` doesn't match the number of " \
               'fields (%i).'.freeze
         FIELD_REGEX =
-          /(%(([\s#+-0\*]*)(\d*)?(.\d+)?[bBdiouxXeEfgGaAcps]|%))/
+          /(%(([\s#+-0\*]*)(\d*)?(\.\d+)?[bBdiouxXeEfgGaAcps]|%))/
         NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/
         KERNEL = 'Kernel'.freeze
         SHOVEL = '<<'.freeze
@@ -35,7 +35,7 @@ module RuboCop
         def on_send(node)
           return unless offending_node?(node)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
         private
@@ -73,12 +73,10 @@ module RuboCop
         end
 
         def named_mode?(node)
-          receiver_node, _method_name, *args = *node
-
           relevant_node = if sprintf?(node) || format?(node)
-                            args.first
+                            node.first_argument
                           elsif percent?(node)
-                            receiver_node
+                            node.receiver
                           end
 
           !relevant_node.source.scan(NAMED_FIELD_REGEX).empty?
@@ -95,31 +93,38 @@ module RuboCop
         end
 
         def count_matches(node)
-          receiver_node, _method_name, *args = *node
-
-          if (sprintf?(node) || format?(node)) && !heredoc?(node)
-            number_of_args_for_format = arguments_count(args) - 1
-            number_of_expected_fields = expected_fields_count(args.first)
-          elsif percent?(node) && args.first.array_type?
-            number_of_expected_fields = expected_fields_count(receiver_node)
-            number_of_args_for_format = arguments_count(args.first.child_nodes)
+          if countable_format?(node)
+            count_format_matches(node)
+          elsif countable_percent?(node)
+            count_percent_matches(node)
           else
-            number_of_args_for_format = number_of_expected_fields = :unknown
+            [:unknown] * 2
           end
+        end
 
-          [number_of_args_for_format, number_of_expected_fields]
+        def countable_format?(node)
+          (sprintf?(node) || format?(node)) && !heredoc?(node)
         end
 
-        def format_method?(name, node)
-          receiver, method_name, *args = *node
+        def countable_percent?(node)
+          percent?(node) && node.first_argument.array_type?
+        end
 
-          if receiver && receiver.const_type?
-            return false unless receiver.loc.name.is?(KERNEL)
-          end
+        def count_format_matches(node)
+          [node.arguments.count - 1, expected_fields_count(node.first_argument)]
+        end
 
-          return false unless method_name == name
+        def count_percent_matches(node)
+          [node.first_argument.child_nodes.count,
+           expected_fields_count(node.receiver)]
+        end
+
+        def format_method?(name, node)
+          return false if node.const_receiver? &&
+                          !node.receiver.loc.name.is?(KERNEL)
+          return false unless node.method?(name)
 
-          args.size > 1 && args.first.str_type?
+          node.arguments.size > 1 && node.first_argument.str_type?
         end
 
         def expected_fields_count(node)
@@ -130,17 +135,12 @@ module RuboCop
             .source
             .scan(FIELD_REGEX)
             .reject { |x| x.first == PERCENT_PERCENT }
-            .reduce(0) { |acc, elem| acc + (elem[2] =~ /\*/ ? 2 : 1) }
+            .reduce(0) { |acc, elem| acc + arguments_count(elem[2]) }
         end
 
-        def arguments_count(args)
-          if args.empty?
-            0
-          elsif args.last.splat_type?
-            -(args.count - 1)
-          else
-            args.count
-          end
+        # number of arguments required for the format sequence
+        def arguments_count(format)
+          format.scan('*').count + 1
         end
 
         def format?(node)
@@ -154,13 +154,12 @@ module RuboCop
         def percent?(node)
           receiver = node.receiver
 
-          percent = node.method_name == :% &&
+          percent = node.method?(:%) &&
                     (STRING_TYPES.include?(receiver.type) ||
                      node.first_argument.array_type?)
 
-          if percent && STRING_TYPES.include?(receiver.type)
-            return false if heredoc?(node)
-          end
+          return false if percent && STRING_TYPES.include?(receiver.type) &&
+                          heredoc?(node)
 
           percent
         end
@@ -168,11 +167,7 @@ module RuboCop
         def message(node)
           num_args_for_format, num_expected_fields = count_matches(node)
 
-          method_name = if node.method_name.to_s == PERCENT
-                          'String#%'
-                        else
-                          node.method_name
-                        end
+          method_name = node.method?(:%) ? 'String#%' : node.method_name
 
           format(MSG, num_args_for_format, method_name, num_expected_fields)
         end

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

@@ -48,7 +48,7 @@ module RuboCop
         MSG = 'Do not suppress exceptions.'.freeze
 
         def on_resbody(node)
-          add_offense(node, :expression) unless node.body
+          add_offense(node) unless node.body
         end
       end
     end

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

@@ -39,7 +39,7 @@ module RuboCop
             elsif node.parent && node.parent.send_type?
               message << FOR_METHOD
             end
-            add_offense(node, range, message)
+            add_offense(node, location: range, message: message)
           end
         end
 

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

@@ -53,12 +53,8 @@ module RuboCop
         ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
                                 'block'.freeze
 
-        def_node_matcher :access_modifier, <<-PATTERN
-          (send nil ${:public :protected :private})
-        PATTERN
-
         def_node_matcher :private_class_method, <<-PATTERN
-          (send nil :private_class_method $...)
+          (send nil? :private_class_method $...)
         PATTERN
 
         def on_class(node)
@@ -83,8 +79,9 @@ module RuboCop
           check_scope(node)
 
           @useless.each do |_name, (defs_node, visibility, modifier)|
-            add_offense(defs_node, :keyword,
-                        format_message(visibility, modifier))
+            add_offense(defs_node,
+                        location: :keyword,
+                        message: format_message(visibility, modifier))
           end
         end
 
@@ -99,42 +96,50 @@ module RuboCop
         end
 
         def check_scope(node, cur_vis = :public)
-          node.children.reduce(cur_vis) do |visibility, child|
+          node.each_child_node.reduce(cur_vis) do |visibility, child|
             check_child_scope(child, visibility)
           end
         end
 
         def check_child_scope(node, cur_vis)
-          if (new_vis = access_modifier(node))
-            cur_vis = change_visibility(node, new_vis)
-          elsif node.defs_type?
-            mark_method_as_useless(node, cur_vis) if cur_vis != :public
+          case node.type
+          when :send
+            cur_vis = check_send(node, cur_vis)
+          when :defs
+            check_defs(node, cur_vis)
+          when :kwbegin
+            check_scope(node, cur_vis)
+          end
+
+          cur_vis
+        end
+
+        def check_send(node, cur_vis)
+          if node.access_modifier? && !node.method?(:module_function)
+            @last_access_modifier = node
+            return node.method_name
           elsif (methods = private_class_method(node))
             # don't warn about defs nodes which are followed by a call to
             # `private_class_method :name`
             # obviously the programmer knows what they are doing
             revert_method_uselessness(methods)
-          elsif node.kwbegin_type?
-            cur_vis = check_scope(node, cur_vis)
           end
 
           cur_vis
         end
 
-        def change_visibility(node, new_vis)
-          @last_access_modifier = node
-          new_vis
+        def check_defs(node, cur_vis)
+          mark_method_as_useless(node, cur_vis) if cur_vis != :public
         end
 
         def mark_method_as_useless(node, cur_vis)
-          _, method_name, = *node
-          @useless[method_name] = [node, cur_vis, @last_access_modifier]
+          @useless[node.method_name] = [node, cur_vis, @last_access_modifier]
         end
 
         def revert_method_uselessness(methods)
           methods.each do |sym|
             next unless sym.sym_type?
-            @useless.delete(sym.children[0])
+            @useless.delete(sym.value)
           end
         end
       end

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

@@ -8,23 +8,19 @@ module RuboCop
       # `StandardError`. It is configurable to suggest using either
       # `RuntimeError` (default) or `StandardError` instead.
       #
-      # @example
-      #
+      # @example EnforcedStyle: runtime_error (default)
       #   # bad
       #
       #   class C < Exception; end
       #
-      # @example
-      #
-      #   # EnforcedStyle: runtime_error (default)
-      #
       #   # good
       #
       #   class C < RuntimeError; end
       #
-      # @example
+      # @example EnforcedStyle: standard_error
+      #   # bad
       #
-      #   # EnforcedStyle: standard_error
+      #   class C < Exception; end
       #
       #   # good
       #
@@ -54,18 +50,9 @@ module RuboCop
         def on_class(node)
           _class, base_class, _body = *node
 
-          return if base_class.nil?
-
-          check(base_class)
-        end
-
-        private
-
-        def check(node)
-          return unless ILLEGAL_CLASSES.include?(node.const_name)
+          return unless base_class && illegal_class_name?(base_class)
 
-          msg = format(MSG, preferred_base_class, node.const_name)
-          add_offense(node, :expression, msg)
+          add_offense(base_class)
         end
 
         def autocorrect(node)
@@ -74,6 +61,16 @@ module RuboCop
           end
         end
 
+        private
+
+        def message(node)
+          format(MSG, preferred_base_class, node.const_name)
+        end
+
+        def illegal_class_name?(class_node)
+          ILLEGAL_CLASSES.include?(class_node.const_name)
+        end
+
         def preferred_base_class
           PREFERRED_BASE_CLASS[style]
         end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for interpolation in a single quoted string.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   foo = 'something with #{interpolation} inside'
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   foo = "something with #{interpolation} inside"
+      class InterpolationCheck < Cop
+        MSG = 'Interpolation in single quoted string detected. '\
+	      '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 =~ /#\{.*\}/
+          add_offense(node)
+        end
+
+        def heredoc?(node)
+          node.loc.is_a?(Parser::Source::Map::Heredoc) ||
+            (node.parent && heredoc?(node.parent))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/{literal_in_condition.rb → literal_as_condition.rb}

@@ -30,8 +30,8 @@ module RuboCop
       #   if some_var && some_condition
       #     do_something
       #   end
-      class LiteralInCondition < Cop
-        MSG = 'Literal `%s` appeared in a condition.'.freeze
+      class LiteralAsCondition < Cop
+        MSG = 'Literal `%s` appeared as a condition.'.freeze
 
         def on_if(node)
           check_for_literal(node)
@@ -60,11 +60,16 @@ module RuboCop
             case_node.each_when do |when_node|
               next unless when_node.conditions.all?(&:literal?)
 
-              add_offense(when_node, :expression)
+              add_offense(when_node)
             end
           end
         end
 
+        def on_send(node)
+          return unless node.negation_method?
+          check_for_literal(node)
+        end
+
         def message(node)
           format(MSG, node.source)
         end
@@ -72,10 +77,11 @@ module RuboCop
         private
 
         def check_for_literal(node)
-          if node.condition.literal?
-            add_offense(node.condition, :expression)
+          cond = condition(node)
+          if cond.literal?
+            add_offense(cond)
           else
-            check_node(node.condition)
+            check_node(cond)
           end
         end
 
@@ -107,7 +113,7 @@ module RuboCop
 
         def handle_node(node)
           if node.literal?
-            add_offense(node, :expression)
+            add_offense(node)
           elsif %i[send and or begin].include?(node.type)
             check_node(node)
           end
@@ -121,6 +127,14 @@ module RuboCop
 
           handle_node(condition)
         end
+
+        def condition(node)
+          if node.send_type?
+            node.receiver
+          else
+            node.condition
+          end
+        end
       end
     end
   end

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

@@ -27,7 +27,7 @@ module RuboCop
             next if special_keyword?(final_node)
             next unless prints_as_self?(final_node)
 
-            add_offense(final_node, :expression)
+            add_offense(final_node)
           end
         end
 

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

@@ -55,7 +55,7 @@ module RuboCop
         private
 
         def register_offense(node)
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
       end
     end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/UnneededDisable
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there is an `# rubocop:enable ...` statement
+      # after a `# rubocop:disable ...` statement. This will prevent leaving
+      # cop disables on wide ranges of code, that latter contributors to
+      # a file wouldn't be aware of.
+      #
+      # @example
+      #   # Lint/MissingCopEnableDirective:
+      #   #   MaximumRangeSize: .inf
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #   # y = 1
+      #   # EOF
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # EOF
+      #
+      # @example
+      #   # Lint/MissingCopEnableDirective:
+      #   #   MaximumRangeSize: 2
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # With the previous, there are 2 lines on which cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   x += 1
+      #   # Including this, that's 3 lines on which the cop is disabled.
+      #   # 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 ' \
+                    'disabling it.'.freeze
+
+        def investigate(processed_source)
+          max_range = cop_config['MaximumRangeSize']
+          processed_source.disabled_line_ranges.each do |cop, line_ranges|
+            line_ranges.each do |line_range|
+              # This has to remain a strict inequality to handle
+              # the case when max_range is Float::INFINITY
+              next if line_range.max - line_range.min < max_range + 2
+              range = source_range(processed_source.buffer,
+                                   line_range.min,
+                                   (0..0))
+              add_offense(range,
+                          location: range,
+                          message: message(max_range: max_range, cop: cop))
+            end
+          end
+        end
+
+        private
+
+        def message(max_range:, cop:)
+          if max_range == Float::INFINITY
+            format(MSG, cop: cop)
+          else
+            format(MSG_BOUND, cop: cop, max_range: max_range)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Lint/UnneededDisable, Layout/SpaceAroundOperators