rubocop 0.49.1 → 0.50.0

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

@@ -57,7 +57,7 @@ module RuboCop
 
           return unless first_else.source_range.line == node.loc.else.line
 
-          add_offense(first_else, :expression)
+          add_offense(first_else)
         end
       end
     end

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

@@ -28,7 +28,7 @@ module RuboCop
         def on_begin(node)
           return unless empty_expression?(node)
 
-          add_offense(node, node.source_range, MSG)
+          add_offense(node, node.source_range)
         end
 
         private

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

@@ -21,7 +21,7 @@ module RuboCop
 
         def on_dstr(node)
           node.each_child_node(:begin) do |begin_node|
-            add_offense(begin_node, :expression) if begin_node.children.empty?
+            add_offense(begin_node) if begin_node.children.empty?
           end
         end
 

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

@@ -29,7 +29,7 @@ module RuboCop
           node.each_when do |when_node|
             next if when_node.body
 
-            add_offense(when_node, when_node.source_range, MSG)
+            add_offense(when_node, when_node.source_range)
           end
         end
       end

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

@@ -34,7 +34,7 @@ module RuboCop
           return unless ensure_body
 
           ensure_body.each_node(:return) do |return_node|
-            add_offense(return_node, :expression)
+            add_offense(return_node)
           end
         end
       end

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

@@ -23,11 +23,11 @@ module RuboCop
 
         def on_float(node)
           value, = *node
-          if value.infinite?
-            add_offense(node, :expression, MSG)
-          elsif value.zero? && node.source =~ /[1-9]/
-            add_offense(node, :expression, MSG)
-          end
+
+          return unless value.infinite? ||
+                        value.zero? && node.source =~ /[1-9]/
+
+          add_offense(node)
         end
       end
     end

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
@@ -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/ineffective_access_modifier.rb

@@ -53,10 +53,6 @@ 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 $...)
         PATTERN
@@ -105,25 +101,34 @@ module RuboCop
         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)

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

@@ -54,18 +54,15 @@ module RuboCop
         def on_class(node)
           _class, base_class, _body = *node
 
-          return if base_class.nil?
+          return unless base_class && illegal_class_name?(base_class)
 
-          check(base_class)
+          add_offense(base_class)
         end
 
         private
 
-        def check(node)
-          return unless ILLEGAL_CLASSES.include?(node.const_name)
-
-          msg = format(MSG, preferred_base_class, node.const_name)
-          add_offense(node, :expression, msg)
+        def message(node)
+          format(MSG, preferred_base_class, node.const_name)
         end
 
         def autocorrect(node)
@@ -74,6 +71,10 @@ module RuboCop
           end
         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,36 @@
+# 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 unless scrub_string(node.str_content) =~ /#\{.*\}/
+          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

@@ -60,7 +60,7 @@ 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
@@ -73,7 +73,7 @@ module RuboCop
 
         def check_for_literal(node)
           if node.condition.literal?
-            add_offense(node.condition, :expression)
+            add_offense(node.condition)
           else
             check_node(node.condition)
           end
@@ -107,7 +107,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

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/multiple_compare.rb

@@ -31,7 +31,7 @@ module RuboCop
         def on_send(node)
           return unless multiple_compare?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

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

@@ -55,17 +55,17 @@ module RuboCop
       #     end
       #   end
       class NestedMethodDefinition < Cop
-        include OnMethodDef
-        extend RuboCop::NodePattern::Macros
-
         MSG = 'Method definitions must not be nested. ' \
               'Use `lambda` instead.'.freeze
 
-        def on_method_def(node, _method_name, _args, _body)
+        def on_def(node)
           find_nested_defs(node) do |nested_def_node|
-            add_offense(nested_def_node, :expression)
+            add_offense(nested_def_node)
           end
         end
+        alias on_defs on_def
+
+        private
 
         def find_nested_defs(node, &block)
           node.each_child_node do |child|
@@ -81,8 +81,6 @@ module RuboCop
           end
         end
 
-        private
-
         def scoping_method_call?(child)
           eval_call?(child) || exec_call?(child) || child.sclass_type? ||
             class_or_module_or_struct_new_call?(child)

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

@@ -35,7 +35,7 @@ module RuboCop
               n.children.empty? && parent_block_node(n) == node
             end
 
-            add_offense(void_next, :expression) if void_next
+            add_offense(void_next) if void_next
           end
         end
 

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

@@ -37,7 +37,7 @@ module RuboCop
         def on_percent_literal(node)
           return unless contains_quotes_or_commas?(node)
 
-          add_offense(node, :expression, MSG)
+          add_offense(node)
         end
 
         private
@@ -53,6 +53,7 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Performance/HashEachMethods
         def autocorrect(node)
           lambda do |corrector|
             node.values.each do |value|
@@ -67,17 +68,7 @@ module RuboCop
             end
           end
         end
-
-        def scrub_string(string)
-          if string.respond_to?(:scrub)
-            string.scrub
-          else
-            string
-              .encode('UTF-16BE', 'UTF-8',
-                      invalid: :replace, undef: :replace, replace: '?')
-              .encode('UTF-8')
-          end
-        end
+        # rubocop:enable Performance/HashEachMethod
       end
     end
   end