rubocop 0.51.0 → 0.87.0

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

@@ -5,7 +5,7 @@ module RuboCop
     module Lint
       # This cop checks for unreachable code.
       # The check are based on the presence of flow of control
-      # statement in non-final position in *begin*(implicit) blocks.
+      # statement in non-final position in `begin` (implicit) blocks.
       #
       # @example
       #
@@ -35,15 +35,15 @@ module RuboCop
       #     do_something
       #   end
       class UnreachableCode < Cop
-        MSG = 'Unreachable code detected.'.freeze
+        MSG = 'Unreachable code detected.'
 
         def on_begin(node)
           expressions = *node
 
-          expressions.each_cons(2) do |e1, e2|
-            next unless flow_expression?(e1)
+          expressions.each_cons(2) do |expression1, expression2|
+            next unless flow_expression?(expression1)
 
-            add_offense(e2)
+            add_offense(expression2)
           end
         end
 
@@ -51,18 +51,19 @@ module RuboCop
 
         private
 
-        def_node_matcher :flow_command?, <<-PATTERN
+        def_node_matcher :flow_command?, <<~PATTERN
           {
             return next break retry redo
             (send
              {nil? (const {nil? cbase} :Kernel)}
-             {:raise :fail :throw}
+             {:raise :fail :throw :exit :exit! :abort}
              ...)
           }
         PATTERN
 
         def flow_expression?(node)
           return true if flow_command?(node)
+
           case node.type
           when :begin, :kwbegin
             expressions = *node
@@ -87,6 +88,7 @@ module RuboCop
           else_branch = node.else_branch
           return false unless else_branch
           return false unless flow_expression?(else_branch)
+
           node.when_branches.all? do |branch|
             branch.body && flow_expression?(branch.body)
           end

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

@@ -6,9 +6,7 @@ module RuboCop
       # This cop checks for unused block arguments.
       #
       # @example
-      #
       #   # bad
-      #
       #   do_something do |used, unused|
       #     puts used
       #   end
@@ -21,10 +19,7 @@ module RuboCop
       #     puts :baz
       #   end
       #
-      # @example
-      #
-      #   #good
-      #
+      #   # good
       #   do_something do |used, _unused|
       #     puts used
       #   end
@@ -36,9 +31,34 @@ module RuboCop
       #   define_method(:foo) do |_bar|
       #     puts :baz
       #   end
+      #
+      # @example IgnoreEmptyBlocks: true (default)
+      #   # good
+      #   do_something { |unused| }
+      #
+      # @example IgnoreEmptyBlocks: false
+      #   # bad
+      #   do_something { |unused| }
+      #
+      # @example AllowUnusedKeywordArguments: false (default)
+      #   # bad
+      #   do_something do |unused: 42|
+      #     foo
+      #   end
+      #
+      # @example AllowUnusedKeywordArguments: true
+      #   # good
+      #   do_something do |unused: 42|
+      #     foo
+      #   end
+      #
       class UnusedBlockArgument < Cop
         include UnusedArgument
 
+        def autocorrect(node)
+          UnusedArgCorrector.correct(processed_source, node)
+        end
+
         private
 
         def check_argument(variable)

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

@@ -6,39 +6,89 @@ 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
+      #
+      # @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 < Cop
         include UnusedArgument
 
+        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)
+        end
+
+        private
+
         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 = String.new("Unused method argument - `#{variable.name}`.")
+          message = +"Unused method argument - `#{variable.name}`."
 
           unless variable.keyword_argument?
             message << " If it's necessary, use `_` or `_#{variable.name}` " \

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

@@ -4,11 +4,11 @@ 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`
+      # `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.
+      # `CGI.unescape`, `URI.decode_www_form`,
+      # or `URI.decode_www_form_component` depending on your specific use case.
       #
       # @example
       #   # bad
@@ -17,7 +17,8 @@ module RuboCop
       #
       #   # good
       #   CGI.escape('http://example.com')
-      #   URI.encode_www_form('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
@@ -40,10 +41,11 @@ module RuboCop
           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
+        MSG = '`%<uri_method>s` method is obsolete and should not be used. ' \
+              'Instead, use %<replacements>s depending on your specific use ' \
+              'case.'
 
-        def_node_matcher :uri_escape_unescape?, <<-PATTERN
+        def_node_matcher :uri_escape_unescape?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) ${:escape :encode :unescape :decode}
             ...)
@@ -51,18 +53,18 @@ module RuboCop
 
         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
+            replacements = 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
+              MSG, uri_method: "#{double_colon}URI.#{obsolete_method}",
+                   replacements: "`#{replacements[0]}`, `#{replacements[1]}` " \
+                                 "or `#{replacements[2]}`"
             )
 
             add_offense(node, message: message)

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

@@ -16,15 +16,15 @@ module RuboCop
       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
+              'make_regexp%<arg>s`.'
 
-        def_node_matcher :uri_regexp_with_argument?, <<-PATTERN
+        def_node_matcher :uri_regexp_with_argument?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) :regexp
-            (str $_))
+            ${(str _) (array ...)})
         PATTERN
 
-        def_node_matcher :uri_regexp_without_argument?, <<-PATTERN
+        def_node_matcher :uri_regexp_without_argument?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) :regexp)
         PATTERN
@@ -32,7 +32,7 @@ module RuboCop
         def on_send(node)
           uri_regexp_with_argument?(node) do |double_colon, arg|
             register_offense(
-              node, top_level: double_colon ? '::' : '', arg: "('#{arg}')"
+              node, top_level: double_colon ? '::' : '', arg: "(#{arg.source})"
             )
           end
 
@@ -51,10 +51,10 @@ module RuboCop
             double_colon, arg = captured_values
 
             top_level = double_colon ? '::' : ''
-            argument = arg ? "('#{arg}')" : ''
+            argument = arg ? "(#{arg.source})" : ''
 
             corrector.replace(
-              node.loc.expression,
+              node,
               "#{top_level}URI::DEFAULT_PARSER.make_regexp#{argument}"
             )
           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
@@ -91,7 +125,9 @@ module RuboCop
       #     delegate :method_a, to: :method_b
       #   end
       class UselessAccessModifier < Cop
-        MSG = 'Useless `%s` access modifier.'.freeze
+        include RangeHelp
+
+        MSG = 'Useless `%<current>s` access modifier.'
 
         def on_class(node)
           check_node(node.children[2]) # class body
@@ -111,22 +147,32 @@ module RuboCop
           check_node(node.children[1]) # singleton class body
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_by_whole_lines(
+              node.source_range, include_final_newline: true
+            )
+
+            corrector.remove(range)
+          end
+        end
+
         private
 
-        def_node_matcher :static_method_definition?, <<-PATTERN
+        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)
@@ -134,22 +180,26 @@ module RuboCop
 
           if node.begin_type?
             check_scope(node)
-          elsif node.send_type? && node.access_modifier?
-            add_offense(node, message: format(MSG, node.method_name))
+          elsif node.send_type? && node.bare_access_modifier?
+            add_offense(node, message: format(MSG, current: node.method_name))
           end
         end
 
+        def access_modifier?(node)
+          node.bare_access_modifier? ||
+            node.method?(:private_class_method)
+        end
+
         def check_scope(node)
           cur_vis, unused = check_child_nodes(node, nil, :public)
 
-          add_offense(unused, message: format(MSG, cur_vis)) if unused
+          add_offense(unused, message: format(MSG, current: cur_vis)) if unused
         end
 
         def check_child_nodes(node, unused, cur_vis)
           node.child_nodes.each do |child|
-            if child.send_type? && child.access_modifier?
-              cur_vis, unused =
-                check_new_visibility(child, unused, child.method_name, cur_vis)
+            if child.send_type? && access_modifier?(child)
+              cur_vis, unused = check_send_node(child, cur_vis, unused)
             elsif method_definition?(child)
               unused = nil
             elsif start_of_new_scope?(child)
@@ -162,13 +212,22 @@ module RuboCop
           [cur_vis, unused]
         end
 
+        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?(:private_class_method) && !node.arguments?
+            add_offense(node, message: format(MSG, current: node.method_name))
+            [cur_vis, unused]
+          end
+        end
+
         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, cur_vis))
+            add_offense(node, message: format(MSG, current: cur_vis))
           else
             # was the previous modifier never applied to any defs?
-            add_offense(unused, message: format(MSG, cur_vis)) if unused
+            add_offense(unused, message: format(MSG, current: 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
@@ -187,7 +246,7 @@ 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
@@ -211,7 +270,7 @@ 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

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

@@ -31,8 +31,7 @@ module RuboCop
       #     do_something(some_var)
       #   end
       class UselessAssignment < Cop
-        include NameSimilarity
-        MSG = 'Useless assignment to variable - `%s`.'.freeze
+        MSG = 'Useless assignment to variable - `%<variable>s`.'
 
         def join_force?(force_class)
           force_class == VariableForce
@@ -65,7 +64,7 @@ module RuboCop
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
 
-          format(MSG, variable.name) +
+          format(MSG, variable: variable.name) +
             message_specification(assignment, variable).to_s
         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
 
@@ -111,10 +112,7 @@ module RuboCop
 
         def collect_variable_like_names(scope)
           names = scope.each_node.with_object(Set.new) do |node, set|
-            if variable_like_method_invocation?(node)
-              _receiver, method_name, = *node
-              set << method_name
-            end
+            set << node.method_name if variable_like_method_invocation?(node)
           end
 
           variable_names = scope.variables.each_value.map(&:name)
@@ -123,8 +121,8 @@ module RuboCop
 
         def variable_like_method_invocation?(node)
           return false unless node.send_type?
-          receiver, _method_name, *args = *node
-          receiver.nil? && args.empty?
+
+          node.receiver.nil? && !node.arguments?
         end
       end
     end

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

@@ -11,7 +11,7 @@ module RuboCop
       #
       #   x.top >= x.top
       class UselessComparison < Cop
-        MSG = 'Comparison of something with itself detected.'.freeze
+        MSG = 'Comparison of something with itself detected.'
         OPS = %w[== === != < > <= >= <=>].freeze
 
         def_node_matcher :useless_comparison?,

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

@@ -5,6 +5,9 @@ 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
+      # this cop is going to be removed at some point the future.
+      #
       # @example
       #
       #   # bad
@@ -29,7 +32,7 @@ module RuboCop
       class UselessElseWithoutRescue < Cop
         include ParserDiagnostic
 
-        MSG = '`else` without `rescue` is useless.'.freeze
+        MSG = '`else` without `rescue` is useless.'
 
         private
 
@@ -37,6 +40,11 @@ module RuboCop
           diagnostic.reason == :useless_else
         end
 
+        def find_offense_node_by(diagnostic)
+          # TODO: When implementing auto-correction, this method should return
+          # an offense node passed as first argument of `add_offense` method.
+        end
+
         def alternative_message(_diagnostic)
           MSG
         end