rubocop 0.51.0 → 0.87.0

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

@@ -6,44 +6,58 @@ module RuboCop
       # This cop checks for assignments in the conditions of
       # if/while/until.
       #
-      # @example
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
       #
+      # @example
       #   # bad
-      #
       #   if some_var = true
       #     do_something
       #   end
       #
-      # @example
+      #   # good
+      #   if some_var == true
+      #     do_something
+      #   end
       #
+      # @example AllowSafeAssignment: true (default)
       #   # good
+      #   if (some_var = true)
+      #     do_something
+      #   end
       #
-      #   if some_var == true
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   if (some_var = true)
       #     do_something
       #   end
+      #
       class AssignmentInCondition < Cop
         include SafeAssignment
 
         MSG_WITH_SAFE_ASSIGNMENT_ALLOWED =
           'Use `==` if you meant to do a comparison or wrap the expression ' \
           'in parentheses to indicate you meant to assign in a ' \
-          'condition.'.freeze
+          'condition.'
         MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED =
           'Use `==` if you meant to do a comparison or move the assignment ' \
-          'up out of the condition.'.freeze
-        ASGN_TYPES = [:begin, *EQUALS_ASGN_NODES, :send].freeze
+          'up out of the condition.'
+        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send].freeze
 
         def on_if(node)
-          check(node)
-        end
+          return if node.condition.block_type?
 
-        def on_while(node)
-          check(node)
-        end
+          traverse_node(node.condition, ASGN_TYPES) do |asgn_node|
+            next :skip_children if skip_children?(asgn_node)
+            next if allowed_construct?(asgn_node)
 
-        def on_until(node)
-          check(node)
+            add_offense(asgn_node, location: :operator)
+          end
         end
+        alias on_while on_if
+        alias on_until on_if
 
         private
 
@@ -55,17 +69,6 @@ module RuboCop
           end
         end
 
-        def check(node)
-          return if node.condition.block_type?
-
-          traverse_node(node.condition, ASGN_TYPES) do |asgn_node|
-            next :skip_children if skip_children?(asgn_node)
-            next if allowed_construct?(asgn_node)
-
-            add_offense(asgn_node, location: :operator)
-          end
-        end
-
         def allowed_construct?(asgn_node)
           asgn_node.begin_type? || conditional_assignment?(asgn_node)
         end
@@ -75,7 +78,7 @@ module RuboCop
         end
 
         def skip_children?(asgn_node)
-          (asgn_node.send_type? && asgn_node.method_name !~ /=\z/) ||
+          (asgn_node.send_type? && !asgn_node.assignment_method?) ||
             empty_condition?(asgn_node) ||
             (safe_assignment_allowed? && safe_assignment?(asgn_node))
         end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # `BigDecimal.new()` is deprecated since BigDecimal 1.3.3.
+      # This cop identifies places where `BigDecimal.new()`
+      # can be replaced by `BigDecimal()`.
+      #
+      # @example
+      #   # bad
+      #   BigDecimal.new(123.456, 3)
+      #
+      #   # good
+      #   BigDecimal(123.456, 3)
+      #
+      class BigDecimalNew < Cop
+        MSG = '`%<double_colon>sBigDecimal.new()` is deprecated. ' \
+              'Use `%<double_colon>sBigDecimal()` instead.'
+
+        def_node_matcher :big_decimal_new, <<~PATTERN
+          (send
+            (const ${nil? cbase} :BigDecimal) :new ...)
+        PATTERN
+
+        def on_send(node)
+          return unless big_decimal_new(node) do |captured_value|
+            double_colon = captured_value ? '::' : ''
+            message = format(MSG, double_colon: double_colon)
+
+            add_offense(node, location: :selector, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.selector)
+            corrector.remove(node.loc.dot)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -23,14 +23,26 @@ module RuboCop
       #   false
       class BooleanSymbol < Cop
         MSG = 'Symbol with a boolean name - ' \
-              'you probably meant to use `%s`.'.freeze
+              'you probably meant to use `%<boolean>s`.'
 
         def_node_matcher :boolean_symbol?, '(sym {:true :false})'
 
         def on_sym(node)
           return unless boolean_symbol?(node)
 
-          add_offense(node, message: format(MSG, node.to_a.first))
+          add_offense(node, message: format(MSG, boolean: node.value))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            boolean_literal = node.source.delete(':')
+            parent = node.parent
+            if parent&.pair_type? && node.equal?(parent.children[0])
+              corrector.remove(parent.loc.operator)
+              boolean_literal = "#{node.source} =>"
+            end
+            corrector.replace(node, boolean_literal)
+          end
         end
       end
     end

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

@@ -48,7 +48,7 @@ module RuboCop
       #     dry_ingredients.combine
       #   end
       class CircularArgumentReference < Cop
-        MSG = 'Circular argument reference - `%s`.'.freeze
+        MSG = 'Circular argument reference - `%<arg_name>s`.'
 
         def on_kwoptarg(node)
           check_for_circular_argument_references(*node)
@@ -64,7 +64,7 @@ module RuboCop
           return unless arg_value.lvar_type?
           return unless arg_value.to_a == [arg_name]
 
-          add_offense(arg_value, message: format(MSG, arg_name))
+          add_offense(arg_value, message: format(MSG, arg_name: arg_name))
         end
       end
     end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Check that certain constants are fully qualified.
+      #
+      # This is not enabled by default because it would mark a lot of offenses
+      # unnecessarily.
+      #
+      # Generally, gems should fully qualify all constants to avoid conflicts with
+      # the code that uses the gem. Enable this cop without using `Only`/`Ignore`
+      #
+      # Large projects will over time end up with one or two constant names that
+      # are problematic because of a conflict with a library or just internally
+      # using the same name a namespace and a class. To avoid too many unnecessary
+      # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
+      #
+      # @example
+      #   # By default checks every constant
+      #
+      #   # bad
+      #   User
+      #
+      #   # bad
+      #   User::Login
+      #
+      #   # good
+      #   ::User
+      #
+      #   # good
+      #   ::User::Login
+      #
+      # @example Only: ['Login']
+      #   # Restrict this cop to only being concerned about certain constants
+      #
+      #   # bad
+      #   Login
+      #
+      #   # good
+      #   ::Login
+      #
+      #   # good
+      #   User::Login
+      #
+      # @example Ignore: ['Login']
+      #   # Restrict this cop not being concerned about certain constants
+      #
+      #   # bad
+      #   User
+      #
+      #   # good
+      #   ::User::Login
+      #
+      #   # good
+      #   Login
+      #
+      class ConstantResolution < Cop
+        MSG = 'Fully qualify this constant to avoid possibly ambiguous resolution.'
+
+        def_node_matcher :unqualified_const?, <<~PATTERN
+          (const nil? #const_name?)
+        PATTERN
+
+        def on_const(node)
+          return unless unqualified_const?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def const_name?(name)
+          name = name.to_s
+          (allowed_names.empty? || allowed_names.include?(name)) &&
+            !ignored_names.include?(name)
+        end
+
+        def allowed_names
+          cop_config['Only']
+        end
+
+        def ignored_names
+          cop_config['Ignore']
+        end
+      end
+    end
+  end
+end

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

@@ -33,31 +33,29 @@ module RuboCop
       #     do_something
       #   end
       class Debugger < Cop
-        MSG = 'Remove debugger entry point `%s`.'.freeze
+        MSG = 'Remove debugger entry point `%<source>s`.'
 
-        def_node_matcher :kernel?, <<-PATTERN
+        def_node_matcher :kernel?, <<~PATTERN
           {
             (const nil? :Kernel)
             (const (cbase) :Kernel)
           }
         PATTERN
 
-        def_node_matcher :debugger_call?, <<-PATTERN
-          {(send {nil? #kernel?} {:debugger :byebug} ...)
+        def_node_matcher :debugger_call?, <<~PATTERN
+          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
            (send (send {#kernel? nil?} :binding)
-             {:pry :remote_pry :pry_remote} ...)
+             {:pry :remote_pry :pry_remote :console} ...)
            (send (const {nil? (cbase)} :Pry) :rescue ...)
            (send nil? {:save_and_open_page
                       :save_and_open_screenshot
                       :save_screenshot} ...)}
         PATTERN
 
-        def_node_matcher :binding_irb_call?, <<-PATTERN
+        def_node_matcher :binding_irb_call?, <<~PATTERN
           (send (send {#kernel? nil?} :binding) :irb ...)
         PATTERN
 
-        def_node_matcher :pry_rescue?, '(send (const nil? :Pry) :rescue ...)'
-
         def on_send(node)
           return unless debugger_call?(node) || binding_irb?(node)
 
@@ -67,11 +65,11 @@ module RuboCop
         private
 
         def message(node)
-          format(MSG, node.source)
+          format(MSG, source: node.source)
         end
 
         def binding_irb?(node)
-          target_ruby_version >= 2.4 && binding_irb_call?(node)
+          binding_irb_call?(node)
         end
       end
     end

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

@@ -10,12 +10,16 @@ module RuboCop
       #   # bad
       #
       #   File.exists?(some_path)
+      #   Dir.exists?(some_path)
+      #   iterator?
       #
       # @example
       #
       #   # good
       #
       #   File.exist?(some_path)
+      #   Dir.exist?(some_path)
+      #   block_given?
       class DeprecatedClassMethods < Cop
         # Inner class to DeprecatedClassMethods.
         # This class exists to add abstraction and clean naming to the
@@ -25,30 +29,41 @@ module RuboCop
 
           attr_reader :class_constant, :deprecated_method, :replacement_method
 
-          def initialize(class_constant, deprecated_method, replacement_method)
+          def initialize(deprecated:, replacement:, class_constant: nil)
+            @deprecated_method = deprecated
+            @replacement_method = replacement
             @class_constant = class_constant
-            @deprecated_method = deprecated_method
-            @replacement_method = replacement_method
           end
 
           def class_nodes
-            @class_nodes ||= [
-              s(:const, nil, class_constant),
-              s(:const, s(:cbase), class_constant)
-            ]
+            @class_nodes ||=
+              if class_constant
+                [
+                  s(:const, nil, class_constant),
+                  s(:const, s(:cbase), class_constant)
+                ]
+              else
+                [nil]
+              end
           end
         end
 
-        MSG = '`%s` is deprecated in favor of `%s`.'.freeze
+        MSG = '`%<current>s` is deprecated in favor of `%<prefer>s`.'
         DEPRECATED_METHODS_OBJECT = [
-          DeprecatedClassMethod.new(:File, :exists?, :exist?),
-          DeprecatedClassMethod.new(:Dir, :exists?, :exist?)
+          DeprecatedClassMethod.new(deprecated: :exists?,
+                                    replacement: :exist?,
+                                    class_constant: :File),
+          DeprecatedClassMethod.new(deprecated: :exists?,
+                                    replacement: :exist?,
+                                    class_constant: :Dir),
+          DeprecatedClassMethod.new(deprecated: :iterator?,
+                                    replacement: :block_given?)
         ].freeze
 
         def on_send(node)
           check(node) do |data|
-            message = format(MSG, deprecated_method(data),
-                             replacement_method(data))
+            message = format(MSG, current: deprecated_method(data),
+                                  prefer: replacement_method(data))
 
             add_offense(node, location: :selector, message: message)
           end
@@ -69,6 +84,7 @@ module RuboCop
           DEPRECATED_METHODS_OBJECT.each do |data|
             next unless data.class_nodes.include?(node.receiver)
             next unless node.method?(data.deprecated_method)
+
             yield data
           end
         end
@@ -82,7 +98,12 @@ module RuboCop
         end
 
         def method_call(class_constant, method)
-          format('%s.%s', class_constant, method)
+          if class_constant
+            format('%<constant>s.%<method>s', constant: class_constant,
+                                              method: method)
+          else
+            format('%<method>s', method: method)
+          end
         end
       end
     end

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

@@ -0,0 +1,137 @@
+# 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 < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)`' \
+          ' instead of `%<original>s`.'
+
+        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? }
+
+          add_offense(node) if algorithm_const(node)
+        end
+
+        def autocorrect(node)
+          algorithm_constant, = algorithm_const(node)
+
+          lambda do |corrector|
+            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
+        end
+
+        private
+
+        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'
+            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)
+          else
+            (["'#{algorithm_name}'"] + node.arguments.map(&:source)).join(', ')
+          end
+        end
+
+        def build_cipher_arguments(node, algorithm_name)
+          algorithm_parts = algorithm_name.split('-')
+          size_and_mode = sanitize_arguments(node.arguments)
+          "'#{(algorithm_parts + size_and_mode + ['CBC']).take(3).join('-')}'"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks constructors for disjunctive assignments that should
+      # be plain assignments.
+      #
+      # So far, this cop is only concerned with disjunctive assignment of
+      # instance variables.
+      #
+      # In ruby, an instance variable is nil until a value is assigned, so the
+      # disjunction is unnecessary. A plain assignment has the same effect.
+      #
+      # @example
+      #   # bad
+      #   def initialize
+      #     @x ||= 1
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     @x = 1
+      #   end
+      class DisjunctiveAssignmentInConstructor < Cop
+        MSG = 'Unnecessary disjunctive assignment. Use plain assignment.'
+
+        def on_def(node)
+          check(node)
+        end
+
+        private
+
+        # @param [DefNode] node a constructor definition
+        def check(node)
+          return unless node.method?(:initialize)
+
+          check_body(node.body)
+        end
+
+        def check_body(body)
+          return if body.nil?
+
+          case body.type
+          when :begin
+            check_body_lines(body.child_nodes)
+          else
+            check_body_lines([body])
+          end
+        end
+
+        # @param [Array] lines the logical lines of the constructor
+        def check_body_lines(lines)
+          lines.each do |line|
+            case line.type
+            when :or_asgn
+              check_disjunctive_assignment(line)
+            else
+              # Once we encounter something other than a disjunctive
+              # assignment, we cease our investigation, because we can't be
+              # certain that any future disjunctive assignments are offensive.
+              # You're off the case, detective!
+              break
+            end
+          end
+        end
+
+        # Add an offense if the LHS of the given disjunctive assignment is
+        # an instance variable.
+        #
+        # For now, we only care about assignments to instance variables.
+        #
+        # @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?
+        end
+      end
+    end
+  end
+end

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

@@ -28,7 +28,7 @@ module RuboCop
       #     do_something_else
       #   end
       class DuplicateCaseCondition < Cop
-        MSG = 'Duplicate `when` condition detected.'.freeze
+        MSG = 'Duplicate `when` condition detected.'
 
         def on_case(case_node)
           case_node.when_branches.each_with_object([]) do |when_node, previous|

data/lib/rubocop/cop/lint/{duplicated_key.rb → duplicate_hash_key.rb}

@@ -18,10 +18,10 @@ module RuboCop
       #   # good
       #
       #   hash = { food: 'apple', other_food: 'orange' }
-      class DuplicatedKey < Cop
+      class DuplicateHashKey < Cop
         include Duplication
 
-        MSG = 'Duplicated key in hash literal.'.freeze
+        MSG = 'Duplicated key in hash literal.'
 
         def on_hash(node)
           keys = node.keys.select(&:recursive_basic_literal?)