rubocop 0.49.1 → 0.52.0

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

@@ -29,7 +29,8 @@ module RuboCop
                     cop_config['AllowUnusedKeywordArguments']
 
           if cop_config['IgnoreEmptyMethods']
-            _name, _args, body = *variable.scope.node
+            body = variable.scope.node.body
+
             return if body.nil?
           end
 

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop identifies places where `URI.escape` can be replaced by
+      # `CGI.escape`, `URI.encode_www_form` or `URI.encode_www_form_component`
+      # depending on your specific use case.
+      # Also this cop identifies places where `URI.unescape` can be replaced by
+      # `CGI.unescape`, `URI.decode_www_form` or `URI.decode_www_form_component`
+      # depending on your specific use case.
+      #
+      # @example
+      #   # bad
+      #   URI.escape('http://example.com')
+      #   URI.encode('http://example.com')
+      #
+      #   # good
+      #   CGI.escape('http://example.com')
+      #   URI.encode_www_form('http://example.com')
+      #   URI.encode_www_form_component('http://example.com')
+      #
+      #   # bad
+      #   URI.unescape(enc_uri)
+      #   URI.decode(enc_uri)
+      #
+      #   # good
+      #   CGI.unescape(enc_uri)
+      #   URI.decode_www_form(enc_uri)
+      #   URI.decode_www_form_component(enc_uri)
+      class UriEscapeUnescape < Cop
+        ALTERNATE_METHODS_OF_URI_ESCAPE = %w[
+          CGI.escape
+          URI.encode_www_form
+          URI.encode_www_form_component
+        ].freeze
+        ALTERNATE_METHODS_OF_URI_UNESCAPE = %w[
+          CGI.unescape
+          URI.decode_www_form
+          URI.decode_www_form_component
+        ].freeze
+
+        MSG = '`%s` method is obsolete and should not be used. Instead, use ' \
+              '`%s`, `%s` or `%s` depending on your specific use case.'.freeze
+
+        def_node_matcher :uri_escape_unescape?, <<-PATTERN
+          (send
+            (const ${nil? cbase} :URI) ${:escape :encode :unescape :decode}
+            ...)
+        PATTERN
+
+        def on_send(node)
+          uri_escape_unescape?(node) do |top_level, obsolete_method|
+            replacement_methods = if %i[escape encode].include?(obsolete_method)
+                                    ALTERNATE_METHODS_OF_URI_ESCAPE
+                                  else
+                                    ALTERNATE_METHODS_OF_URI_UNESCAPE
+                                  end
+
+            double_colon = top_level ? '::' : ''
+
+            message = format(
+              MSG,
+              "#{double_colon}URI.#{obsolete_method}",
+              *replacement_methods
+            )
+
+            add_offense(node, message: message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop identifies places where `URI.regexp` is obsolete and should
+      # not be used. Instead, use `URI::DEFAULT_PARSER.make_regexp`.
+      #
+      # @example
+      #   # bad
+      #   URI.regexp('http://example.com')
+      #
+      #   # good
+      #   URI::DEFAULT_PARSER.make_regexp('http://example.com')
+      #
+      class UriRegexp < Cop
+        MSG = '`%<top_level>sURI.regexp%<arg>s` is obsolete and should not ' \
+              'be used. Instead, use `%<top_level>sURI::DEFAULT_PARSER.' \
+              'make_regexp%<arg>s`.'.freeze
+
+        def_node_matcher :uri_regexp_with_argument?, <<-PATTERN
+          (send
+            (const ${nil? cbase} :URI) :regexp
+            (str $_))
+        PATTERN
+
+        def_node_matcher :uri_regexp_without_argument?, <<-PATTERN
+          (send
+            (const ${nil? cbase} :URI) :regexp)
+        PATTERN
+
+        def on_send(node)
+          uri_regexp_with_argument?(node) do |double_colon, arg|
+            register_offense(
+              node, top_level: double_colon ? '::' : '', arg: "('#{arg}')"
+            )
+          end
+
+          uri_regexp_without_argument?(node) do |double_colon|
+            register_offense(node, top_level: double_colon ? '::' : '')
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if (captured_values = uri_regexp_with_argument?(node))
+            else
+              captured_values = uri_regexp_without_argument?(node)
+            end
+
+            double_colon, arg = captured_values
+
+            top_level = double_colon ? '::' : ''
+            argument = arg ? "('#{arg}')" : ''
+
+            corrector.replace(
+              node.loc.expression,
+              "#{top_level}URI::DEFAULT_PARSER.make_regexp#{argument}"
+            )
+          end
+        end
+
+        private
+
+        def register_offense(node, top_level: '', arg: '')
+          format = format(MSG, top_level: top_level, arg: arg)
+
+          add_offense(node, location: :selector, message: format)
+        end
+      end
+    end
+  end
+end

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

@@ -113,16 +113,12 @@ module RuboCop
 
         private
 
-        def_node_matcher :access_modifier, <<-PATTERN
-          (send nil ${:public :protected :private})
-        PATTERN
-
         def_node_matcher :static_method_definition?, <<-PATTERN
-          {def (send nil {:attr :attr_reader :attr_writer :attr_accessor} ...)}
+          {def (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)}
         PATTERN
 
         def_node_matcher :dynamic_method_definition?, <<-PATTERN
-          {(send nil :define_method ...) (block (send nil :define_method ...) ...)}
+          {(send nil? :define_method ...) (block (send nil? :define_method ...) ...)}
         PATTERN
 
         def_node_matcher :class_or_instance_eval?, <<-PATTERN
@@ -130,7 +126,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
-          (block (send (const nil {:Class :Module :Struct}) :new ...) ...)
+          (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
         PATTERN
 
         def check_node(node)
@@ -138,22 +134,22 @@ module RuboCop
 
           if node.begin_type?
             check_scope(node)
-          elsif (vis = access_modifier(node))
-            add_offense(node, :expression, format(MSG, vis))
+          elsif node.send_type? && node.access_modifier?
+            add_offense(node, message: format(MSG, node.method_name))
           end
         end
 
         def check_scope(node)
           cur_vis, unused = check_child_nodes(node, nil, :public)
 
-          add_offense(unused, :expression, format(MSG, cur_vis)) if unused
+          add_offense(unused, message: format(MSG, cur_vis)) if unused
         end
 
         def check_child_nodes(node, unused, cur_vis)
           node.child_nodes.each do |child|
-            if (new_vis = access_modifier(child))
+            if child.send_type? && child.access_modifier?
               cur_vis, unused =
-                check_new_visibility(child, unused, new_vis, cur_vis)
+                check_new_visibility(child, unused, child.method_name, cur_vis)
             elsif method_definition?(child)
               unused = nil
             elsif start_of_new_scope?(child)
@@ -169,10 +165,10 @@ module RuboCop
         def check_new_visibility(node, unused, new_vis, cur_vis)
           # does this modifier just repeat the existing visibility?
           if new_vis == cur_vis
-            add_offense(node, :expression, format(MSG, cur_vis))
+            add_offense(node, message: format(MSG, cur_vis))
           else
             # was the previous modifier never applied to any defs?
-            add_offense(unused, :expression, format(MSG, cur_vis)) if unused
+            add_offense(unused, message: format(MSG, cur_vis)) if unused
             # once we have already warned about a certain modifier, don't
             # warn again even if it is never applied to any method defs
             unused = node
@@ -192,7 +188,7 @@ module RuboCop
             matcher_name = "#{m}_method?".to_sym
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<-PATTERN
-                {def (send nil :#{m} ...)}
+                {def (send nil? :#{m} ...)}
               PATTERN
             end
 
@@ -216,7 +212,7 @@ module RuboCop
             matcher_name = "#{m}_block?".to_sym
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<-PATTERN
-                (block (send {nil const} {:#{m}} ...) ...)
+                (block (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end
 

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

@@ -58,7 +58,7 @@ module RuboCop
                          assignment.node.loc.name
                        end
 
-            add_offense(nil, location, message)
+            add_offense(nil, location: location, message: message)
           end
         end
 

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

@@ -20,7 +20,7 @@ module RuboCop
         def on_send(node)
           return unless useless_comparison?(node)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -25,26 +25,29 @@ module RuboCop
       #     x
       #   end
       class UselessSetterCall < Cop
-        include OnMethodDef
-
         MSG = 'Useless setter call to local variable `%s`.'.freeze
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
-        private
-
-        def on_method_def(_node, _method_name, _args, body)
-          return unless body
+        def on_def(node)
+          return unless node.body
 
-          last_expr = last_expression(body)
+          last_expr = last_expression(node.body)
           return unless setter_call_to_local_variable?(last_expr)
 
-          tracker = MethodVariableTracker.new(body)
+          tracker = MethodVariableTracker.new(node.body)
           receiver, = *last_expr
           variable_name, = *receiver
           return unless tracker.contain_local_object?(variable_name)
 
-          add_offense(receiver, :name, format(MSG, receiver.loc.name.source))
+          add_offense(
+            receiver,
+            location: :name,
+            message: format(MSG, receiver.loc.name.source)
+          )
         end
+        alias on_defs on_def
+
+        private
 
         def last_expression(body)
           expression = body.begin_type? ? body.children : body
@@ -54,9 +57,9 @@ module RuboCop
 
         def setter_call_to_local_variable?(node)
           return unless node && node.send_type?
-          receiver, method, _args = *node
-          return unless receiver && receiver.lvar_type?
-          method =~ /(?:\w|\[\])=$/
+          return unless node.receiver && node.receiver.lvar_type?
+
+          node.method_name =~ /(?:\w|\[\])=$/
         end
 
         # This class tracks variable assignments in a method body

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

@@ -19,7 +19,7 @@ module RuboCop
       #
       #   # bad
       #
-      #   def some_method
+      #   def some_method(some_var)
       #     some_var
       #     do_something
       #   end
@@ -37,7 +37,7 @@ module RuboCop
       #
       #   # good
       #
-      #   def some_method
+      #   def some_method(some_var)
       #     do_something
       #     some_var
       #   end
@@ -48,59 +48,70 @@ module RuboCop
         SELF_MSG = '`self` used in void context.'.freeze
         DEFINED_MSG = '`%s` used in void context.'.freeze
 
-        OPS = %w[* / % + - == === != < > <= >= <=>].freeze
+        BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
+        UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
+        OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
+        VOID_CONTEXT_TYPES = %i[def for block].freeze
 
         def on_begin(node)
           check_begin(node)
         end
-
-        def on_kwbegin(node)
-          check_begin(node)
-        end
+        alias on_kwbegin on_begin
 
         private
 
         def check_begin(node)
           expressions = *node
-
-          expressions.drop_last(1).each do |expr|
-            check_for_void_op(expr)
-            check_for_literal(expr)
-            check_for_var(expr)
-            check_for_self(expr)
-            check_for_defined(expr)
+          expressions = expressions.drop_last(1) unless in_void_context?(node)
+          expressions.each do |expr|
+            check_void_op(expr)
+            check_literal(expr)
+            check_var(expr)
+            check_self(expr)
+            check_defined(expr)
           end
         end
 
-        def check_for_void_op(node)
-          return unless node.send_type? && node.loc.selector
+        def check_void_op(node)
+          return unless node.send_type? && OPERATORS.include?(node.method_name)
 
-          op = node.loc.selector.source
-
-          add_offense(node, :selector, format(OP_MSG, op)) if OPS.include?(op)
+          add_offense(node,
+                      location: :selector,
+                      message: format(OP_MSG, node.method_name))
         end
 
-        def check_for_var(node)
+        def check_var(node)
           return unless node.variable? || node.const_type?
-          add_offense(node, :name, format(VAR_MSG, node.loc.name.source))
+
+          add_offense(node,
+                      location: :name,
+                      message: format(VAR_MSG, node.loc.name.source))
         end
 
-        def check_for_literal(node)
+        def check_literal(node)
           return if !node.literal? || node.xstr_type?
 
-          add_offense(node, :expression, format(LIT_MSG, node.source))
+          add_offense(node, message: format(LIT_MSG, node.source))
         end
 
-        def check_for_self(node)
+        def check_self(node)
           return unless node.self_type?
 
-          add_offense(node, :expression, SELF_MSG)
+          add_offense(node, message: SELF_MSG)
         end
 
-        def check_for_defined(node)
+        def check_defined(node)
           return unless node.defined_type?
 
-          add_offense(node, :expression, format(DEFINED_MSG, node.source))
+          add_offense(node, message: format(DEFINED_MSG, node.source))
+        end
+
+        def in_void_context?(node)
+          parent = node.parent
+
+          return false unless parent && parent.children.last == node
+
+          VOID_CONTEXT_TYPES.include?(parent.type) && parent.void_context?
         end
       end
     end

data/lib/rubocop/cop/message_annotator.rb

@@ -103,8 +103,10 @@ module RuboCop
       end
 
       def display_cop_names?
-        debug? || options[:display_cop_names] ||
-          config.for_all_cops['DisplayCopNames']
+        return true if debug?
+        return false if options[:display_cop_names] == false
+        return true if options[:display_cop_names]
+        config.for_all_cops['DisplayCopNames']
       end
 
       def details

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -9,8 +9,8 @@ module RuboCop
       class AbcSize < Cop
         include MethodComplexity
 
-        MSG = 'Assignment Branch Condition size for %s is too high. ' \
-              '[%.4g/%.4g]'.freeze
+        MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
+              '[%<complexity>.4g/%<max>.4g]'.freeze
         BRANCH_NODES = %i[send csend].freeze
         CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze