rubocop 0.70.0 → 1.6.1

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

@@ -6,43 +6,92 @@ module RuboCop
       # This cop checks for unused method arguments.
       #
       # @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
+      #
+      # @example AllowUnusedKeywordArguments: false (default)
+      #   # bad
+      #   def do_something(used, unused: 42)
+      #     used
+      #   end
+      #
+      # @example AllowUnusedKeywordArguments: true
+      #   # good
+      #   def do_something(used, unused: 42)
+      #     used
+      #   end
+      #
+      # @example IgnoreEmptyMethods: true (default)
+      #   # good
+      #   def do_something(unused)
+      #   end
+      #
+      # @example IgnoreEmptyMethods: false
+      #   # bad
+      #   def do_something(unused)
+      #   end
+      #
+      # @example IgnoreNotImplementedMethods: true (default)
+      #   # good
+      #   def do_something(unused)
+      #     raise NotImplementedError
+      #   end
+      #
+      #   def do_something_else(unused)
+      #     fail "TODO"
+      #   end
+      #
+      # @example IgnoreNotImplementedMethods: false
+      #   # bad
+      #   def do_something(unused)
+      #     raise NotImplementedError
+      #   end
+      #
+      #   def do_something_else(unused)
+      #     fail "TODO"
+      #   end
+      #
+      class UnusedMethodArgument < Base
         include UnusedArgument
+        extend AutoCorrector
+
+        def_node_matcher :not_implemented?, <<~PATTERN
+          {(send nil? :raise (const {nil? cbase} :NotImplementedError))
+           (send nil? :fail ...)}
+        PATTERN
 
-        def autocorrect(node)
-          UnusedArgCorrector.correct(processed_source, node)
+        def self.joining_forces
+          VariableForce
         end
 
         private
 
+        def autocorrect(corrector, node)
+          UnusedArgCorrector.correct(corrector, processed_source, node)
+        end
+
         def check_argument(variable)
           return unless variable.method_argument?
           return if variable.keyword_argument? &&
                     cop_config['AllowUnusedKeywordArguments']
-
-          if cop_config['IgnoreEmptyMethods']
-            body = variable.scope.node.body
-
-            return if body.nil?
-          end
+          return if ignored_method?(variable.scope.node.body)
 
           super
         end
 
+        def ignored_method?(body)
+          cop_config['IgnoreEmptyMethods'] && body.nil? ||
+            cop_config['IgnoreNotImplementedMethods'] &&
+              not_implemented?(body)
+        end
+
         def message(variable)
           message = +"Unused method argument - `#{variable.name}`."
 

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

@@ -29,7 +29,7 @@ module RuboCop
       #   CGI.unescape(enc_uri)
       #   URI.decode_www_form(enc_uri)
       #   URI.decode_www_form_component(enc_uri)
-      class UriEscapeUnescape < Cop
+      class UriEscapeUnescape < Base
         ALTERNATE_METHODS_OF_URI_ESCAPE = %w[
           CGI.escape
           URI.encode_www_form
@@ -44,10 +44,12 @@ module RuboCop
         MSG = '`%<uri_method>s` method is obsolete and should not be used. ' \
               'Instead, use %<replacements>s depending on your specific use ' \
               'case.'
+        METHOD_NAMES = %i[escape encode unescape decode].freeze
+        RESTRICT_ON_SEND = METHOD_NAMES
 
-        def_node_matcher :uri_escape_unescape?, <<-PATTERN
+        def_node_matcher :uri_escape_unescape?, <<~PATTERN
           (send
-            (const ${nil? cbase} :URI) ${:escape :encode :unescape :decode}
+            (const ${nil? cbase} :URI) ${:#{METHOD_NAMES.join(' :')}}
             ...)
         PATTERN
 

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

@@ -13,60 +13,25 @@ module RuboCop
       #   # 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`.'
+      class UriRegexp < Base
+        extend AutoCorrector
 
-        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
+        MSG = '`%<current>s` is obsolete and should not be used. Instead, use `%<preferred>s`.'
+        URI_CONSTANTS = ['URI', '::URI'].freeze
+        RESTRICT_ON_SEND = %i[regexp].freeze
 
         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
+          return unless node.receiver
+          return unless URI_CONSTANTS.include?(node.receiver.source)
 
-            double_colon, arg = captured_values
+          argument = node.first_argument ? "(#{node.first_argument.source})" : ''
+          preferred_method = "#{node.receiver.source}::DEFAULT_PARSER.make_regexp#{argument}"
+          message = format(MSG, current: node.source, preferred: preferred_method)
 
-            top_level = double_colon ? '::' : ''
-            argument = arg ? "('#{arg}')" : ''
-
-            corrector.replace(
-              node.loc.expression,
-              "#{top_level}URI::DEFAULT_PARSER.make_regexp#{argument}"
-            )
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node, preferred_method)
           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

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

@@ -9,23 +9,64 @@ module RuboCop
       # always being defined, and thus access modifiers guarding such methods
       # are not redundant.
       #
-      # @example
+      # This cop has `ContextCreatingMethods` option. The default setting value
+      # is an empty array that means no method is specified.
+      # This setting is an array of methods which, when called, are known to
+      # create its own context in the module's current access context.
+      #
+      # It also has `MethodCreatingMethods` option. The default setting value
+      # is an empty array that means no method is specified.
+      # This setting is an array of methods which, when called, are known to
+      # create other methods in the module's current access context.
       #
+      # @example
+      #   # bad
       #   class Foo
       #     public # this is redundant (default access is public)
       #
       #     def method
       #     end
+      #   end
       #
-      #     private # this is not redundant (a method is defined)
-      #     def method2
+      #   # bad
+      #   class Foo
+      #     # The following is redundant (methods defined on the class'
+      #     # singleton class are not affected by the public modifier)
+      #     public
+      #
+      #     def self.method3
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
+      #     protected
+      #
+      #     define_method(:method2) do
       #     end
       #
+      #     protected # this is redundant (repeated from previous modifier)
+      #
+      #     [1,2,3].each do |i|
+      #       define_method("foo#{i}") do
+      #       end
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
       #     private # this is redundant (no following methods are defined)
       #   end
       #
-      # @example
+      #   # good
+      #   class Foo
+      #     private # this is not redundant (a method is defined)
+      #
+      #     def method2
+      #     end
+      #   end
       #
+      #   # good
       #   class Foo
       #     # The following is not redundant (conditionally defined methods are
       #     # considered as always defining a method)
@@ -35,31 +76,22 @@ module RuboCop
       #       def method
       #       end
       #     end
+      #   end
       #
-      #     protected # this is not redundant (method is defined)
+      #   # good
+      #   class Foo
+      #     protected # this is not redundant (a method is defined)
       #
       #     define_method(:method2) do
       #     end
-      #
-      #     protected # this is redundant (repeated from previous modifier)
-      #
-      #     [1,2,3].each do |i|
-      #       define_method("foo#{i}") do
-      #       end
-      #     end
-      #
-      #     # The following is redundant (methods defined on the class'
-      #     # singleton class are not affected by the public modifier)
-      #     public
-      #
-      #     def self.method3
-      #     end
       #   end
       #
-      # @example
+      # @example ContextCreatingMethods: concerning
       #   # Lint/UselessAccessModifier:
       #   #   ContextCreatingMethods:
       #   #     - concerning
+      #
+      #   # good
       #   require 'active_support/concern'
       #   class Foo
       #     concerning :Bar do
@@ -79,10 +111,12 @@ module RuboCop
       #     end
       #   end
       #
-      # @example
+      # @example MethodCreatingMethods: delegate
       #   # Lint/UselessAccessModifier:
       #   #   MethodCreatingMethods:
       #   #     - delegate
+      #
+      #   # good
       #   require 'active_support/core_ext/module/delegation'
       #   class Foo
       #     # this is not redundant because `delegate` creates methods
@@ -90,16 +124,17 @@ module RuboCop
       #
       #     delegate :method_a, to: :method_b
       #   end
-      class UselessAccessModifier < Cop
+      class UselessAccessModifier < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Useless `%<current>s` access modifier.'
 
         def on_class(node)
-          check_node(node.children[2]) # class body
-        end
-
-        def on_module(node)
-          check_node(node.children[1]) # module body
+          check_node(node.body)
         end
+        alias on_module on_class
+        alias on_sclass on_class
 
         def on_block(node)
           return unless eval_call?(node)
@@ -107,26 +142,28 @@ module RuboCop
           check_node(node.body)
         end
 
-        def on_sclass(node)
-          check_node(node.children[1]) # singleton class body
-        end
-
         private
 
-        def_node_matcher :static_method_definition?, <<-PATTERN
+        def autocorrect(corrector, node)
+          range = range_by_whole_lines(node.source_range, include_final_newline: true)
+
+          corrector.remove(range)
+        end
+
+        def_node_matcher :static_method_definition?, <<~PATTERN
           {def (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)}
         PATTERN
 
-        def_node_matcher :dynamic_method_definition?, <<-PATTERN
+        def_node_matcher :dynamic_method_definition?, <<~PATTERN
           {(send nil? :define_method ...) (block (send nil? :define_method ...) ...)}
         PATTERN
 
-        def_node_matcher :class_or_instance_eval?, <<-PATTERN
+        def_node_matcher :class_or_instance_eval?, <<~PATTERN
           (block (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
-        def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
-          (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
+        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
+          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN
 
         def check_node(node)
@@ -135,19 +172,24 @@ module RuboCop
           if node.begin_type?
             check_scope(node)
           elsif node.send_type? && node.bare_access_modifier?
-            add_offense(node, message: format(MSG, current: node.method_name))
+            add_offense(node, message: format(MSG, current: node.method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
         def access_modifier?(node)
           node.bare_access_modifier? ||
-            node.method_name == :private_class_method
+            node.method?(:private_class_method)
         end
 
         def check_scope(node)
           cur_vis, unused = check_child_nodes(node, nil, :public)
+          return unless unused
 
-          add_offense(unused, message: format(MSG, current: cur_vis)) if unused
+          add_offense(unused, message: format(MSG, current: cur_vis)) do |corrector|
+            autocorrect(corrector, unused)
+          end
         end
 
         def check_child_nodes(node, unused, cur_vis)
@@ -169,8 +211,10 @@ module RuboCop
         def check_send_node(node, cur_vis, unused)
           if node.bare_access_modifier?
             check_new_visibility(node, unused, node.method_name, cur_vis)
-          elsif node.method_name == :private_class_method && !node.arguments?
-            add_offense(node, message: format(MSG, current: node.method_name))
+          elsif node.method?(:private_class_method) && !node.arguments?
+            add_offense(node, message: format(MSG, current: node.method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
             [cur_vis, unused]
           end
         end
@@ -178,11 +222,15 @@ 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, message: format(MSG, current: cur_vis))
+            add_offense(node, message: format(MSG, current: cur_vis)) do |corrector|
+              autocorrect(corrector, node)
+            end
           else
             # was the previous modifier never applied to any defs?
             if unused
-              add_offense(unused, message: format(MSG, current: cur_vis))
+              add_offense(unused, message: format(MSG, current: cur_vis)) do |corrector|
+                autocorrect(corrector, unused)
+              end
             end
             # once we have already warned about a certain modifier, don't
             # warn again even if it is never applied to any method defs
@@ -202,12 +250,12 @@ module RuboCop
           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
+              self.class.def_node_matcher matcher_name, <<~PATTERN
                 {def (send nil? :#{m} ...)}
               PATTERN
             end
 
-            send(matcher_name, child)
+            public_send(matcher_name, child)
           end
         end
 
@@ -226,12 +274,12 @@ module RuboCop
           cop_config.fetch('ContextCreatingMethods', []).any? do |m|
             matcher_name = "#{m}_block?".to_sym
             unless respond_to?(matcher_name)
-              self.class.def_node_matcher matcher_name, <<-PATTERN
+              self.class.def_node_matcher matcher_name, <<~PATTERN
                 (block (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end
 
-            send(matcher_name, child)
+            public_send(matcher_name, child)
           end
         end
       end

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

@@ -30,12 +30,11 @@ module RuboCop
       #     some_var = 1
       #     do_something(some_var)
       #   end
-      class UselessAssignment < Cop
-        include NameSimilarity
+      class UselessAssignment < Base
         MSG = 'Useless assignment to variable - `%<variable>s`.'
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)
@@ -58,7 +57,7 @@ module RuboCop
                          assignment.node.loc.name
                        end
 
-            add_offense(nil, location: location, message: message)
+            add_offense(location, message: message)
           end
         end
 
@@ -94,7 +93,9 @@ module RuboCop
         end
 
         def similar_name_message(variable)
-          similar_name = find_similar_name(variable.name, variable.scope)
+          variable_like_names = collect_variable_like_names(variable.scope)
+          similar_name = NameSimilarity.find_similar_name(variable.name,
+                                                          variable_like_names)
           " Did you mean `#{similar_name}`?" if similar_name
         end
 

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

@@ -5,7 +5,7 @@ module RuboCop
     module Lint
       # This cop checks for useless `else` in `begin..end` without `rescue`.
       #
-      # Note: This syntax is no longer valid on Ruby 2.6 or higher and
+      # NOTE: This syntax is no longer valid on Ruby 2.6 or higher and
       # this cop is going to be removed at some point the future.
       #
       # @example
@@ -29,19 +29,15 @@ module RuboCop
       #   else
       #     do_something_else
       #   end
-      class UselessElseWithoutRescue < Cop
-        include ParserDiagnostic
-
+      class UselessElseWithoutRescue < Base
         MSG = '`else` without `rescue` is useless.'
 
-        private
-
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :useless_else
-        end
+        def on_new_investigation
+          processed_source.diagnostics.each do |diagnostic|
+            next unless diagnostic.reason == :useless_else
 
-        def alternative_message(_diagnostic)
-          MSG
+            add_offense(diagnostic.location, severity: diagnostic.level)
+          end
         end
       end
     end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for useless method definitions, specifically: empty constructors
+      # and methods just delegating to `super`.
+      #
+      # This cop is marked as unsafe as it can trigger false positives for cases when
+      # an empty constructor just overrides the parent constructor, which is bad anyway.
+      #
+      # @example
+      #   # bad
+      #   def initialize
+      #     super
+      #   end
+      #
+      #   def method
+      #     super
+      #   end
+      #
+      #   # good - with default arguments
+      #   def initialize(x = Object.new)
+      #     super
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     super
+      #     initialize_internals
+      #   end
+      #
+      #   def method(*args)
+      #     super(:extra_arg, *args)
+      #   end
+      #
+      class UselessMethodDefinition < Base
+        extend AutoCorrector
+
+        MSG = 'Useless method definition detected.'
+
+        def on_def(node)
+          return if optional_args?(node)
+          return unless delegating?(node.body, node)
+
+          add_offense(node) { |corrector| corrector.remove(node) }
+        end
+        alias on_defs on_def
+
+        private
+
+        def optional_args?(node)
+          node.arguments.any? { |arg| arg.optarg_type? || arg.kwoptarg_type? }
+        end
+
+        def delegating?(node, def_node)
+          if node&.zsuper_type?
+            true
+          elsif node&.super_type?
+            node.arguments.map(&:source) == def_node.arguments.map(&:source)
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,11 @@ module RuboCop
     module Lint
       # This cop checks for setter call to local variable as the final
       # expression of a function definition.
+      # Its auto-correction is marked as unsafe because return value will be changed.
+      #
+      # NOTE: There are edge cases in which the local variable references a
+      # value that is also accessible outside the local scope. This is not
+      # detected by the cop, and it can yield a false positive.
       #
       # @example
       #
@@ -24,7 +29,9 @@ module RuboCop
       #     x.attr = 5
       #     x
       #   end
-      class UselessSetterCall < Cop
+      class UselessSetterCall < Base
+        extend AutoCorrector
+
         MSG = 'Useless setter call to local variable `%<variable>s`.'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
@@ -39,17 +46,17 @@ module RuboCop
           variable_name, = *receiver
           return unless tracker.contain_local_object?(variable_name)
 
-          add_offense(
-            receiver,
-            location: :name,
-            message: format(MSG, variable: receiver.loc.name.source)
-          )
+          loc_name = receiver.loc.name
+
+          add_offense(loc_name, message: format(MSG, variable: loc_name.source)) do |corrector|
+            corrector.insert_after(last_expr, "\n#{indent(last_expr)}#{loc_name.source}")
+          end
         end
         alias on_defs on_def
 
         private
 
-        def_node_matcher :setter_call_to_local_variable?, <<-PATTERN
+        def_node_matcher :setter_call_to_local_variable?, <<~PATTERN
           [(send (lvar _) ...) setter_method?]
         PATTERN
 
@@ -155,7 +162,7 @@ module RuboCop
             return true if node.literal?
             return false unless node.send_type?
 
-            node.method_name == :new
+            node.method?(:new)
           end
         end
       end