rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,43 +7,82 @@ module RuboCop
       #
       # @example
       #
-      #   do_something do |used, unused, _unused_but_allowed|
+      #   # bad
+      #
+      #   do_something do |used, unused|
+      #     puts used
+      #   end
+      #
+      #   do_something do |bar|
+      #     puts :foo
+      #   end
+      #
+      #   define_method(:foo) do |bar|
+      #     puts :baz
+      #   end
+      #
+      # @example
+      #
+      #   #good
+      #
+      #   do_something do |used, _unused|
       #     puts used
       #   end
+      #
+      #   do_something do
+      #     puts :foo
+      #   end
+      #
+      #   define_method(:foo) do |_bar|
+      #     puts :baz
+      #   end
       class UnusedBlockArgument < Cop
         include UnusedArgument
 
-        def check_argument(variable)
-          return unless variable.block_argument?
-          return if variable.keyword_argument? &&
-                    cop_config && cop_config['AllowUnusedKeywordArguments']
+        def autocorrect(node)
+          UnusedArgCorrector.correct(processed_source, node)
+        end
 
-          if cop_config['IgnoreEmptyBlocks']
-            _send, _args, body = *variable.scope.node
-            return if body.nil?
-          end
+        private
+
+        def check_argument(variable)
+          return if allowed_block?(variable) ||
+                    allowed_keyword_argument?(variable)
 
           super
         end
 
-        def message(variable)
-          message = String.new("Unused #{variable_type(variable)} - " \
-                               "`#{variable.name}`.")
+        def allowed_block?(variable)
+          !variable.block_argument? ||
+            (ignore_empty_blocks? && empty_block?(variable))
+        end
 
-          return message if variable.explicit_block_local_variable?
+        def allowed_keyword_argument?(variable)
+          variable.keyword_argument? &&
+            allow_unused_keyword_arguments?
+        end
+
+        def message(variable)
+          message = "Unused #{variable_type(variable)} - `#{variable.name}`."
 
-          message << ' '
+          if variable.explicit_block_local_variable?
+            message
+          else
+            augment_message(message, variable)
+          end
+        end
 
+        def augment_message(message, variable)
           scope = variable.scope
           all_arguments = scope.variables.each_value.select(&:block_argument?)
 
-          message << if scope.node.lambda?
-                       message_for_lambda(variable, all_arguments)
-                     else
-                       message_for_normal_block(variable, all_arguments)
-                     end
+          augmentation = if scope.node.lambda?
+                           message_for_lambda(variable, all_arguments)
+                         else
+                           message_for_normal_block(variable, all_arguments)
+                         end
 
-          message
+          [message, augmentation].join(' ')
         end
 
         def variable_type(variable)
@@ -56,7 +94,8 @@ module RuboCop
         end
 
         def message_for_normal_block(variable, all_arguments)
-          if all_arguments.none?(&:referenced?)
+          if all_arguments.none?(&:referenced?) &&
+             !define_method_call?(variable)
             if all_arguments.count > 1
               "You can omit all the arguments if you don't care about them."
             else
@@ -68,21 +107,42 @@ module RuboCop
         end
 
         def message_for_lambda(variable, all_arguments)
-          message = String.new(message_for_underscore_prefix(variable))
+          message = message_for_underscore_prefix(variable)
 
           if all_arguments.none?(&:referenced?)
-            message << ' Also consider using a proc without arguments ' \
-                       'instead of a lambda if you want it ' \
-                        "to accept any arguments but don't care about them."
+            proc_message = 'Also consider using a proc without arguments ' \
+                           'instead of a lambda if you want it ' \
+                           "to accept any arguments but don't care about them."
           end
 
-          message
+          [message, proc_message].compact.join(' ')
         end
 
         def message_for_underscore_prefix(variable)
           "If it's necessary, use `_` or `_#{variable.name}` " \
           "as an argument name to indicate that it won't be used."
         end
+
+        def define_method_call?(variable)
+          call, = *variable.scope.node
+          _, method, = *call
+
+          method == :define_method
+        end
+
+        def empty_block?(variable)
+          _send, _args, body = *variable.scope.node
+
+          body.nil?
+        end
+
+        def allow_unused_keyword_arguments?
+          cop_config['AllowUnusedKeywordArguments']
+        end
+
+        def ignore_empty_blocks?
+          cop_config['IgnoreEmptyBlocks']
+        end
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,19 +7,36 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   def some_method(used, unused, _unused_but_allowed)
       #     puts used
       #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method(used, _unused, _unused_but_allowed)
+      #     puts used
+      #   end
       class UnusedMethodArgument < Cop
         include UnusedArgument
 
+        def autocorrect(node)
+          UnusedArgCorrector.correct(processed_source, node)
+        end
+
+        private
+
         def check_argument(variable)
           return unless variable.method_argument?
           return if variable.keyword_argument? &&
                     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,75 @@
+# 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([['example', 'param'], ['lang', 'en']])
+      #   URI.encode_www_form(page: 10, locale: 'en')
+      #   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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -79,6 +78,18 @@ module RuboCop
       #     def some_other_private_method
       #     end
       #   end
+      #
+      # @example
+      #   # Lint/UselessAccessModifier:
+      #   #   MethodCreatingMethods:
+      #   #     - delegate
+      #   require 'active_support/core_ext/module/delegation'
+      #   class Foo
+      #     # this is not redundant because `delegate` creates methods
+      #     private
+      #
+      #     delegate :method_a, to: :method_b
+      #   end
       class UselessAccessModifier < Cop
         MSG = 'Useless `%s` access modifier.'.freeze
 
@@ -93,7 +104,7 @@ module RuboCop
         def on_block(node)
           return unless eval_call?(node)
 
-          check_node(node.children[2]) # block body
+          check_node(node.body)
         end
 
         def on_sclass(node)
@@ -102,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
@@ -119,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)
@@ -127,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)
@@ -158,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
@@ -171,7 +178,22 @@ module RuboCop
         end
 
         def method_definition?(child)
-          static_method_definition?(child) || dynamic_method_definition?(child)
+          static_method_definition?(child) ||
+            dynamic_method_definition?(child) ||
+            any_method_definition?(child)
+        end
+
+        def any_method_definition?(child)
+          cop_config.fetch('MethodCreatingMethods', []).any? do |m|
+            matcher_name = "#{m}_method?".to_sym
+            unless respond_to?(matcher_name)
+              self.class.def_node_matcher matcher_name, <<-PATTERN
+                {def (send nil? :#{m} ...)}
+              PATTERN
+            end
+
+            send(matcher_name, child)
+          end
         end
 
         def start_of_new_scope?(child)
@@ -190,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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -13,6 +12,24 @@ module RuboCop
       # Currently this cop has advanced logic that detects unreferenced
       # reassignments and properly handles varied cases such as branch, loop,
       # rescue, ensure, etc.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     some_var = 1
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     some_var = 1
+      #     do_something(some_var)
+      #   end
       class UselessAssignment < Cop
         include NameSimilarity
         MSG = 'Useless assignment to variable - `%s`.'.freeze
@@ -41,37 +58,51 @@ module RuboCop
                          assignment.node.loc.name
                        end
 
-            add_offense(nil, location, message)
+            add_offense(nil, location: location, message: message)
           end
         end
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
 
-          message = format(MSG, variable.name)
+          format(MSG, variable.name) +
+            message_specification(assignment, variable).to_s
+        end
 
+        def message_specification(assignment, variable)
           if assignment.multiple_assignment?
-            message << " Use `_` or `_#{variable.name}` as a variable name " \
-                       "to indicate that it won't be used."
+            multiple_assignment_message(variable.name)
           elsif assignment.operator_assignment?
-            return_value_node = return_value_node_of_scope(variable.scope)
-            if assignment.meta_assignment_node.equal?(return_value_node)
-              non_assignment_operator = assignment.operator.sub(/=$/, '')
-              message << " Use just operator `#{non_assignment_operator}`."
-            end
+            operator_assignment_message(variable.scope, assignment)
           else
-            similar_name = find_similar_name(variable.name, variable.scope)
-            message << " Did you mean `#{similar_name}`?" if similar_name
+            similar_name_message(variable)
           end
+        end
+
+        def multiple_assignment_message(variable_name)
+          " Use `_` or `_#{variable_name}` as a variable name to indicate " \
+            "that it won't be used."
+        end
+
+        def operator_assignment_message(scope, assignment)
+          return_value_node = return_value_node_of_scope(scope)
+          return unless assignment.meta_assignment_node
+                                  .equal?(return_value_node)
+
+          " Use `#{assignment.operator.sub(/=$/, '')}` " \
+          "instead of `#{assignment.operator}`."
+        end
 
-          message
+        def similar_name_message(variable)
+          similar_name = find_similar_name(variable.name, variable.scope)
+          " Did you mean `#{similar_name}`?" if similar_name
         end
 
         # TODO: More precise handling (rescue, ensure, nested begin, etc.)
         def return_value_node_of_scope(scope)
           body_node = scope.body_node
 
-          if body_node.type == :begin
+          if body_node.begin_type?
             body_node.children.last
           else
             body_node

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,21 +7,20 @@ module RuboCop
       #
       # @example
       #
-      #  x.top >= x.top
+      #   # bad
+      #
+      #   x.top >= x.top
       class UselessComparison < Cop
         MSG = 'Comparison of something with itself detected.'.freeze
+        OPS = %w[== === != < > <= >= <=>].freeze
 
-        OPS = %w(== === != < > <= >= <=>).freeze
+        def_node_matcher :useless_comparison?,
+                         "(send $_match {:#{OPS.join(' :')}} $_match)"
 
         def on_send(node)
-          # lambda.() does not have a selector
-          return unless node.loc.selector
-
-          op = node.loc.selector.source
-          return unless OPS.include?(op)
+          return unless useless_comparison?(node)
 
-          receiver, _method, args = *node
-          add_offense(node, :selector) if receiver == args
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,10 +6,25 @@ module RuboCop
       # This cop checks for useless `else` in `begin..end` without `rescue`.
       #
       # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   else
+      #     do_something_else # This will never be run.
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
       #   begin
       #     do_something
+      #   rescue
+      #     handle_errors
       #   else
-      #     handle_errors # This will never be run.
+      #     do_something_else
       #   end
       class UselessElseWithoutRescue < Cop
         include ParserDiagnostic