rubocop 0.78.0 → 1.13.0

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

@@ -20,7 +20,9 @@ module RuboCop
       #   File.exist?(some_path)
       #   Dir.exist?(some_path)
       #   block_given?
-      class DeprecatedClassMethods < Cop
+      class DeprecatedClassMethods < Base
+        extend AutoCorrector
+
         # Inner class to DeprecatedClassMethods.
         # This class exists to add abstraction and clean naming to the
         # objects that are going to be operated on.
@@ -56,24 +58,18 @@ module RuboCop
           DeprecatedClassMethod.new(deprecated: :exists?,
                                     replacement: :exist?,
                                     class_constant: :Dir),
-          DeprecatedClassMethod.new(deprecated: :iterator?,
-                                    replacement: :block_given?)
+          DeprecatedClassMethod.new(deprecated: :iterator?, replacement: :block_given?)
         ].freeze
 
+        RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.map(&:deprecated_method).freeze
+
         def on_send(node)
           check(node) do |data|
             message = format(MSG, current: deprecated_method(data),
                                   prefer: replacement_method(data))
 
-            add_offense(node, location: :selector, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            check(node) do |data|
-              corrector.replace(node.loc.selector,
-                                data.replacement_method.to_s)
+            add_offense(node.loc.selector, message: message) do |corrector|
+              corrector.replace(node.loc.selector, data.replacement_method.to_s)
             end
           end
         end
@@ -99,8 +95,7 @@ module RuboCop
 
         def method_call(class_constant, method)
           if class_constant
-            format('%<constant>s.%<method>s', constant: class_constant,
-                                              method: method)
+            format('%<constant>s.%<method>s', constant: class_constant, method: method)
           else
             format('%<method>s', method: method)
           end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for deprecated constants.
+      #
+      # It has `DeprecatedConstants` config. If there is an alternative method, you can set
+      # alternative value as `Alternative`. And you can set the deprecated version as
+      # `DeprecatedVersion`. These options can be omitted if they are not needed.
+      #
+      #   DeprecatedConstants:
+      #     'DEPRECATED_CONSTANT':
+      #       Alternative: 'alternative_value'
+      #       DeprecatedVersion: 'deprecated_version'
+      #
+      # By default, `NIL`, `TRUE`, `FALSE` and `Random::DEFAULT` are configured.
+      #
+      # @example
+      #
+      #   # bad
+      #   NIL
+      #   TRUE
+      #   FALSE
+      #   Random::DEFAULT # Return value of Ruby 2 is `Random` instance, Ruby 3.0 is `Random` class.
+      #
+      #   # good
+      #   nil
+      #   true
+      #   false
+      #   Random.new # `::DEFAULT` has been deprecated in Ruby 3, `.new` is compatible with Ruby 2.
+      #
+      class DeprecatedConstants < Base
+        extend AutoCorrector
+
+        SUGGEST_GOOD_MSG = 'Use `%<good>s` instead of `%<bad>s`%<deprecated_message>s.'
+        DO_NOT_USE_MSG = 'Do not use `%<bad>s`%<deprecated_message>s.'
+
+        def on_const(node)
+          # FIXME: Workaround for "`undefined method `expression' for nil:NilClass`" when processing
+          #        `__ENCODING__`. It is better to be able to work without this condition.
+          #        Maybe further investigation of RuboCop AST will lead to an essential solution.
+          return unless node.loc
+
+          constant = node.absolute? ? constant_name(node, node.short_name.to_s) : node.source
+          return unless (deprecated_constant = deprecated_constants[constant])
+
+          alternative = deprecated_constant['Alternative']
+          version = deprecated_constant['DeprecatedVersion']
+
+          add_offense(node, message: message(alternative, node.source, version)) do |corrector|
+            corrector.replace(node, alternative)
+          end
+        end
+
+        private
+
+        def constant_name(node, nested_constant_name)
+          return nested_constant_name unless node.namespace.const_type?
+
+          constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
+        end
+
+        def message(good, bad, deprecated_version)
+          deprecated_message = ", deprecated since Ruby #{deprecated_version}" if deprecated_version
+
+          if good
+            format(SUGGEST_GOOD_MSG, good: good, bad: bad, deprecated_message: deprecated_message)
+          else
+            format(DO_NOT_USE_MSG, bad: bad, deprecated_message: deprecated_message)
+          end
+        end
+
+        def deprecated_constants
+          cop_config.fetch('DeprecatedConstants', {})
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Algorithmic constants for `OpenSSL::Cipher` and `OpenSSL::Digest`
+      # deprecated since OpenSSL version 2.2.0. Prefer passing a string
+      # instead.
+      #
+      # @example
+      #
+      #   # Example for OpenSSL::Cipher instantiation.
+      #
+      #   # bad
+      #   OpenSSL::Cipher::AES.new(128, :GCM)
+      #
+      #   # good
+      #   OpenSSL::Cipher.new('aes-128-gcm')
+      #
+      # @example
+      #
+      #   # Example for OpenSSL::Digest instantiation.
+      #
+      #   # bad
+      #   OpenSSL::Digest::SHA256.new
+      #
+      #   # good
+      #   OpenSSL::Digest.new('SHA256')
+      #
+      # @example
+      #
+      #   # Example for ::Digest inherited class methods.
+      #
+      #   # bad
+      #   OpenSSL::Digest::SHA256.digest('foo')
+      #
+      #   # good
+      #   OpenSSL::Digest.digest('SHA256', 'foo')
+      #
+      class DeprecatedOpenSSLConstant < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)` instead of `%<original>s`.'
+
+        NO_ARG_ALGORITHM = %w[BF DES IDEA RC4].freeze
+
+        # @!method algorithm_const(node)
+        def_node_matcher :algorithm_const, <<~PATTERN
+          (send
+            $(const
+              (const
+                (const {nil? cbase} :OpenSSL) {:Cipher :Digest})
+              _)
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return if node.arguments.any? { |arg| arg.variable? || arg.send_type? || arg.const_type? }
+          return unless algorithm_const(node)
+
+          message = message(node)
+
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          algorithm_constant, = algorithm_const(node)
+
+          corrector.remove(algorithm_constant.loc.double_colon)
+          corrector.remove(algorithm_constant.loc.name)
+
+          corrector.replace(
+            correction_range(node),
+            "#{node.loc.selector.source}(#{replacement_args(node)})"
+          )
+        end
+
+        def message(node)
+          algorithm_constant, = algorithm_const(node)
+          parent_constant = openssl_class(algorithm_constant)
+          replacement_args = replacement_args(node)
+          method = node.loc.selector.source
+
+          format(
+            MSG,
+            constant: parent_constant,
+            method: method,
+            replacement_args: replacement_args,
+            original: node.source
+          )
+        end
+
+        def correction_range(node)
+          range_between(node.loc.dot.end_pos, node.loc.expression.end_pos)
+        end
+
+        def openssl_class(node)
+          node.children.first.source
+        end
+
+        def algorithm_name(node)
+          name = node.loc.name.source
+
+          if openssl_class(node) == 'OpenSSL::Cipher' && !NO_ARG_ALGORITHM.include?(name)
+            name.scan(/.{3}/).join('-')
+          else
+            name
+          end
+        end
+
+        def sanitize_arguments(arguments)
+          arguments.flat_map do |arg|
+            argument = arg.str_type? ? arg.value : arg.source
+
+            argument.tr(":'", '').split('-')
+          end
+        end
+
+        def replacement_args(node)
+          algorithm_constant, = algorithm_const(node)
+          algorithm_name = algorithm_name(algorithm_constant)
+
+          if openssl_class(algorithm_constant) == 'OpenSSL::Cipher'
+            build_cipher_arguments(node, algorithm_name, node.arguments.empty?)
+          else
+            (["'#{algorithm_name}'"] + node.arguments.map(&:source)).join(', ')
+          end
+        end
+
+        def build_cipher_arguments(node, algorithm_name, no_arguments)
+          algorithm_parts = algorithm_name.downcase.split('-')
+          size_and_mode = sanitize_arguments(node.arguments).map(&:downcase)
+
+          if NO_ARG_ALGORITHM.include?(algorithm_parts.first.upcase) && no_arguments
+            "'#{algorithm_parts.first}'"
+          else
+            mode = 'cbc' unless size_and_mode == ['cbc']
+
+            "'#{(algorithm_parts + size_and_mode + [mode]).compact.take(3).join('-')}'"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -22,7 +22,9 @@ module RuboCop
       #   def initialize
       #     @x = 1
       #   end
-      class DisjunctiveAssignmentInConstructor < Cop
+      class DisjunctiveAssignmentInConstructor < Base
+        extend AutoCorrector
+
         MSG = 'Unnecessary disjunctive assignment. Use plain assignment.'
 
         def on_def(node)
@@ -73,7 +75,11 @@ module RuboCop
         # @param [Node] node a disjunctive assignment
         def check_disjunctive_assignment(node)
           lhs = node.child_nodes.first
-          add_offense(node, location: :operator) if lhs.ivasgn_type?
+          return unless lhs.ivasgn_type?
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '=')
+          end
         end
       end
     end

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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there are no repeated bodies
+      # within `if/unless`, `case-when` and `rescue` constructs.
+      #
+      # With `IgnoreLiteralBranches: true`, branches are not registered
+      # as offenses if they return a basic literal value (string, symbol,
+      # integer, float, rational, complex, `true`, `false`, or `nil`), or
+      # return an array, hash, regexp or range that only contains one of
+      # the above basic literal values.
+      #
+      # With `IgnoreConstantBranches: true`, branches are not registered
+      # as offenses if they return a constant value.
+      #
+      # @example
+      #   # bad
+      #   if foo
+      #     do_foo
+      #     do_something_else
+      #   elsif bar
+      #     do_foo
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   if foo || bar
+      #     do_foo
+      #     do_something_else
+      #   end
+      #
+      #   # bad
+      #   case x
+      #   when foo
+      #     do_foo
+      #   when bar
+      #     do_foo
+      #   else
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   case x
+      #   when foo, bar
+      #     do_foo
+      #   else
+      #     do_something_else
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue FooError
+      #     handle_error
+      #   rescue BarError
+      #     handle_error
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue FooError, BarError
+      #     handle_error
+      #   end
+      #
+      # @example IgnoreLiteralBranches: true
+      #   # good
+      #   case size
+      #   when "small" then 100
+      #   when "medium" then 250
+      #   when "large" then 1000
+      #   else 250
+      #   end
+      #
+      # @example IgnoreConstantBranches: true
+      #   # good
+      #   case size
+      #   when "small" then SMALL_SIZE
+      #   when "medium" then MEDIUM_SIZE
+      #   when "large" then LARGE_SIZE
+      #   else MEDIUM_SIZE
+      #   end
+      #
+      class DuplicateBranch < Base
+        include RescueNode
+
+        MSG = 'Duplicate branch body detected.'
+
+        def on_branching_statement(node)
+          branches(node).each_with_object(Set.new) do |branch, previous|
+            next unless consider_branch?(branch)
+
+            add_offense(offense_range(branch)) unless previous.add?(branch)
+          end
+        end
+        alias on_if on_branching_statement
+        alias on_case on_branching_statement
+        alias on_rescue on_branching_statement
+
+        private
+
+        def offense_range(duplicate_branch)
+          parent = duplicate_branch.parent
+
+          if parent.respond_to?(:else_branch) && parent.else_branch.equal?(duplicate_branch)
+            if parent.if_type? && parent.ternary?
+              duplicate_branch.source_range
+            else
+              parent.loc.else
+            end
+          else
+            parent.source_range
+          end
+        end
+
+        def branches(node)
+          node.branches.compact
+        end
+
+        def consider_branch?(branch)
+          return false if ignore_literal_branches? && literal_branch?(branch)
+          return false if ignore_constant_branches? && const_branch?(branch)
+
+          true
+        end
+
+        def ignore_literal_branches?
+          cop_config.fetch('IgnoreLiteralBranches', false)
+        end
+
+        def ignore_constant_branches?
+          cop_config.fetch('IgnoreConstantBranches', false)
+        end
+
+        def literal_branch?(branch) # rubocop:disable Metrics/CyclomaticComplexity
+          return false if !branch.literal? || branch.xstr_type?
+          return true if branch.basic_literal?
+
+          branch.each_descendant.all? do |node|
+            node.basic_literal? ||
+              node.pair_type? || # hash keys and values are contained within a `pair` node
+              (node.const_type? && ignore_constant_branches?)
+          end
+        end
+
+        def const_branch?(branch)
+          branch.const_type?
+        end
+      end
+    end
+  end
+end