rubocop 0.49.1 → 0.50.0

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, :expression, 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, :selector, format)
+        end
+      end
+    end
+  end
+end

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

@@ -113,10 +113,6 @@ 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} ...)}
         PATTERN
@@ -138,8 +134,8 @@ 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, :expression, format(MSG, node.method_name))
           end
         end
 
@@ -151,9 +147,9 @@ module RuboCop
 
         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)

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

@@ -25,26 +25,25 @@ 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))
         end
+        alias on_defs on_def
+
+        private
 
         def last_expression(body)
           expression = body.begin_type? ? body.children : body
@@ -54,9 +53,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,60 +48,66 @@ 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, :selector, 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))
         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))
         end
 
-        def check_for_self(node)
+        def check_self(node)
           return unless node.self_type?
 
           add_offense(node, :expression, 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))
         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
   end

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

@@ -118,12 +118,12 @@ module RuboCop
         def valid_uri?(uri_ish_string)
           URI.parse(uri_ish_string)
           true
-        rescue
+        rescue URI::InvalidURIError, NoMethodError
           false
         end
 
         def uri_regexp
-          @regexp ||= URI::Parser.new.make_regexp(cop_config['URISchemes'])
+          @regexp ||= URI::DEFAULT_PARSER.make_regexp(cop_config['URISchemes'])
         end
 
         def check_directive_line(line, index)

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

@@ -7,17 +7,22 @@ module RuboCop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       class MethodLength < Cop
-        include OnMethodDef
         include TooManyLines
 
         LABEL = 'Method'.freeze
 
-        private
+        def on_def(node)
+          check_code_length(node)
+        end
+        alias on_defs on_def
 
-        def on_method_def(node, _method_name, _args, _body)
+        def on_block(node)
+          return unless node.send_node.method_name == :define_method
           check_code_length(node)
         end
 
+        private
+
         def cop_label
           LABEL
         end

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

@@ -16,14 +16,17 @@ module RuboCop
           count = args_count(node)
           return unless count > max_params
 
-          message = format(MSG, max_params, count, max_params)
-          add_offense(node, :expression, message) do
+          add_offense(node) do
             self.max = count
           end
         end
 
         private
 
+        def message(node)
+          format(MSG, max_params, args_count(node), max_params)
+        end
+
         def args_count(node)
           if count_keyword_args?
             node.children.size

data/lib/rubocop/cop/mixin/autocorrect_alignment.rb

@@ -41,7 +41,7 @@ module RuboCop
             # offense again and correct it.
             add_offense(nil, expr)
           else
-            add_offense(current, :expression)
+            add_offense(current)
           end
         end
       end

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -16,13 +16,13 @@ module RuboCop
 
       def on_class(node)
         class_definition(node) do
-          add_offense(node.children[1], :expression, self.class::MSG)
+          add_offense(node.children[1])
         end
       end
 
       def on_send(node)
         class_new_definition(node) do
-          add_offense(node.children.last, :expression, self.class::MSG)
+          add_offense(node.children.last)
         end
       end
 

data/lib/rubocop/cop/mixin/first_element_line_break.rb

@@ -28,13 +28,22 @@ module RuboCop
         return if children.size < 2
 
         line = start.loc.line
-        min = children.min_by { |n| n.loc.first_line }
+
+        min = first_by_line(children)
         return if line != min.loc.first_line
 
-        max = children.max_by { |n| n.loc.last_line }
+        max = last_by_line(children)
         return if line == max.loc.last_line
 
-        add_offense(min, :expression, self.class::MSG)
+        add_offense(min)
+      end
+
+      def first_by_line(nodes)
+        nodes.min_by { |n| n.loc.first_line }
+      end
+
+      def last_by_line(nodes)
+        nodes.max_by { |n| n.loc.last_line }
       end
     end
   end