rubocop 0.87.1

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

@@ -0,0 +1,76 @@
+# 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 = '`%<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
+          (send
+            (const ${nil? cbase} :URI) ${:escape :encode :unescape :decode}
+            ...)
+        PATTERN
+
+        def on_send(node)
+          uri_escape_unescape?(node) do |top_level, obsolete_method|
+            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, uri_method: "#{double_colon}URI.#{obsolete_method}",
+                   replacements: "`#{replacements[0]}`, `#{replacements[1]}` " \
+                                 "or `#{replacements[2]}`"
+            )
+
+            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`.'
+
+        def_node_matcher :uri_regexp_with_argument?, <<~PATTERN
+          (send
+            (const ${nil? cbase} :URI) :regexp
+            ${(str _) (array ...)})
+        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.source})"
+            )
+          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.source})" : ''
+
+            corrector.replace(
+              node,
+              "#{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

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for redundant access modifiers, including those with no
+      # code, those which are repeated, and leading `public` modifiers in a
+      # class or module body. Conditionally-defined methods are considered as
+      # always being defined, and thus access modifiers guarding such methods
+      # are not redundant.
+      #
+      # 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
+      #
+      #   # 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
+      #
+      #   # 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)
+      #     private
+      #
+      #     if condition?
+      #       def method
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     protected # this is not redundant (a method is defined)
+      #
+      #     define_method(:method2) do
+      #     end
+      #   end
+      #
+      # @example ContextCreatingMethods: concerning
+      #   # Lint/UselessAccessModifier:
+      #   #   ContextCreatingMethods:
+      #   #     - concerning
+      #
+      #   # good
+      #   require 'active_support/concern'
+      #   class Foo
+      #     concerning :Bar do
+      #       def some_public_method
+      #       end
+      #
+      #       private
+      #
+      #       def some_private_method
+      #       end
+      #     end
+      #
+      #     # this is not redundant because `concerning` created its own context
+      #     private
+      #
+      #     def some_other_private_method
+      #     end
+      #   end
+      #
+      # @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
+      #     private
+      #
+      #     delegate :method_a, to: :method_b
+      #   end
+      class UselessAccessModifier < Cop
+        include RangeHelp
+
+        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
+        end
+
+        def on_block(node)
+          return unless eval_call?(node)
+
+          check_node(node.body)
+        end
+
+        def on_sclass(node)
+          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 (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 ...) ...)}
+        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? cbase} {:Class :Module :Struct}) :new ...) ...)
+        PATTERN
+
+        def check_node(node)
+          return if node.nil?
+
+          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))
+          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, current: cur_vis)) if unused
+        end
+
+        def check_child_nodes(node, unused, cur_vis)
+          node.child_nodes.each do |child|
+            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)
+              check_scope(child)
+            elsif !child.defs_type?
+              cur_vis, unused = check_child_nodes(child, unused, cur_vis)
+            end
+          end
+
+          [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, current: cur_vis))
+          else
+            # was the previous modifier never applied to any defs?
+            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
+          end
+
+          [new_vis, unused]
+        end
+
+        def 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)
+          child.module_type? || child.class_type? ||
+            child.sclass_type? || eval_call?(child)
+        end
+
+        def eval_call?(child)
+          class_or_instance_eval?(child) ||
+            class_or_module_or_struct_new_call?(child) ||
+            any_context_creating_methods?(child)
+        end
+
+        def any_context_creating_methods?(child)
+          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
+                (block (send {nil? const} {:#{m}} ...) ...)
+              PATTERN
+            end
+
+            send(matcher_name, child)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for every useless assignment to local variable in every
+      # scope.
+      # The basic idea for this cop was from the warning of `ruby -cw`:
+      #
+      #   assigned but unused variable - foo
+      #
+      # 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
+        MSG = 'Useless assignment to variable - `%<variable>s`.'
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_for_unused_assignments(variable)
+          end
+        end
+
+        def check_for_unused_assignments(variable)
+          return if variable.should_be_unused?
+
+          variable.assignments.each do |assignment|
+            next if assignment.used?
+
+            message = message_for_useless_assignment(assignment)
+
+            location = if assignment.regexp_named_capture?
+                         assignment.node.children.first.source_range
+                       else
+                         assignment.node.loc.name
+                       end
+
+            add_offense(nil, location: location, message: message)
+          end
+        end
+
+        def message_for_useless_assignment(assignment)
+          variable = assignment.variable
+
+          format(MSG, variable: variable.name) +
+            message_specification(assignment, variable).to_s
+        end
+
+        def message_specification(assignment, variable)
+          if assignment.multiple_assignment?
+            multiple_assignment_message(variable.name)
+          elsif assignment.operator_assignment?
+            operator_assignment_message(variable.scope, assignment)
+          else
+            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
+
+        def similar_name_message(variable)
+          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
+
+        # TODO: More precise handling (rescue, ensure, nested begin, etc.)
+        def return_value_node_of_scope(scope)
+          body_node = scope.body_node
+
+          if body_node.begin_type?
+            body_node.children.last
+          else
+            body_node
+          end
+        end
+
+        def collect_variable_like_names(scope)
+          names = scope.each_node.with_object(Set.new) do |node, set|
+            set << node.method_name if variable_like_method_invocation?(node)
+          end
+
+          variable_names = scope.variables.each_value.map(&:name)
+          names.merge(variable_names)
+        end
+
+        def variable_like_method_invocation?(node)
+          return false unless node.send_type?
+
+          node.receiver.nil? && !node.arguments?
+        end
+      end
+    end
+  end
+end