rubocop 0.87.1

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for assignments in the conditions of
+      # if/while/until.
+      #
+      # `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
+      #
+      #   # good
+      #   if some_var == true
+      #     do_something
+      #   end
+      #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   if (some_var = true)
+      #     do_something
+      #   end
+      #
+      # @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.'
+        MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED =
+          'Use `==` if you meant to do a comparison or move the assignment ' \
+          'up out of the condition.'
+        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send].freeze
+
+        def on_if(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
+        alias on_while on_if
+        alias on_until on_if
+
+        private
+
+        def message(_node)
+          if safe_assignment_allowed?
+            MSG_WITH_SAFE_ASSIGNMENT_ALLOWED
+          else
+            MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED
+          end
+        end
+
+        def allowed_construct?(asgn_node)
+          asgn_node.begin_type? || conditional_assignment?(asgn_node)
+        end
+
+        def conditional_assignment?(asgn_node)
+          !asgn_node.loc.operator
+        end
+
+        def skip_children?(asgn_node)
+          (asgn_node.send_type? && !asgn_node.assignment_method?) ||
+            empty_condition?(asgn_node) ||
+            (safe_assignment_allowed? && safe_assignment?(asgn_node))
+        end
+
+        # each_node/visit_descendants_with_types with :skip_children
+        def traverse_node(node, types, &block)
+          result = yield node if types.include?(node.type)
+
+          return if result == :skip_children
+
+          node.each_child_node { |child| traverse_node(child, types, &block) }
+        end
+      end
+    end
+  end
+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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `:true` and `:false` symbols.
+      # In most cases it would be a typo.
+      #
+      # @example
+      #
+      #   # bad
+      #   :true
+      #
+      #   # good
+      #   true
+      #
+      # @example
+      #
+      #   # bad
+      #   :false
+      #
+      #   # good
+      #   false
+      class BooleanSymbol < Cop
+        MSG = 'Symbol with a boolean name - ' \
+              '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, 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
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for circular argument references in optional keyword
+      # arguments and optional ordinal arguments.
+      #
+      # This cop mirrors a warning produced by MRI since 2.2.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def bake(pie: pie)
+      #     pie.heat_up
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def bake(pie:)
+      #     pie.refrigerate
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def bake(pie: self.pie)
+      #     pie.feed_to(user)
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def cook(dry_ingredients = dry_ingredients)
+      #     dry_ingredients.reduce(&:+)
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def cook(dry_ingredients = self.dry_ingredients)
+      #     dry_ingredients.combine
+      #   end
+      class CircularArgumentReference < Cop
+        MSG = 'Circular argument reference - `%<arg_name>s`.'
+
+        def on_kwoptarg(node)
+          check_for_circular_argument_references(*node)
+        end
+
+        def on_optarg(node)
+          check_for_circular_argument_references(*node)
+        end
+
+        private
+
+        def check_for_circular_argument_references(arg_name, arg_value)
+          return unless arg_value.lvar_type?
+          return unless arg_value.to_a == [arg_name]
+
+          add_offense(arg_value, message: format(MSG, arg_name: arg_name))
+        end
+      end
+    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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for calls to debugger or pry.
+      #
+      # @example
+      #
+      #   # bad (ok during development)
+      #
+      #   # using pry
+      #   def some_method
+      #     binding.pry
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # bad (ok during development)
+      #
+      #   # using byebug
+      #   def some_method
+      #     byebug
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   end
+      class Debugger < Cop
+        MSG = 'Remove debugger entry point `%<source>s`.'
+
+        def_node_matcher :kernel?, <<~PATTERN
+          {
+            (const nil? :Kernel)
+            (const (cbase) :Kernel)
+          }
+        PATTERN
+
+        def_node_matcher :debugger_call?, <<~PATTERN
+          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
+           (send (send {#kernel? nil?} :binding)
+             {: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
+          (send (send {#kernel? nil?} :binding) :irb ...)
+        PATTERN
+
+        def on_send(node)
+          return unless debugger_call?(node) || binding_irb?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, source: node.source)
+        end
+
+        def binding_irb?(node)
+          binding_irb_call?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of the deprecated class method usages.
+      #
+      # @example
+      #
+      #   # 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
+        # objects that are going to be operated on.
+        class DeprecatedClassMethod
+          include RuboCop::AST::Sexp
+
+          attr_reader :class_constant, :deprecated_method, :replacement_method
+
+          def initialize(deprecated:, replacement:, class_constant: nil)
+            @deprecated_method = deprecated
+            @replacement_method = replacement
+            @class_constant = class_constant
+          end
+
+          def class_nodes
+            @class_nodes ||=
+              if class_constant
+                [
+                  s(:const, nil, class_constant),
+                  s(:const, s(:cbase), class_constant)
+                ]
+              else
+                [nil]
+              end
+          end
+        end
+
+        MSG = '`%<current>s` is deprecated in favor of `%<prefer>s`.'
+        DEPRECATED_METHODS_OBJECT = [
+          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, 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)
+            end
+          end
+        end
+
+        private
+
+        def check(node)
+          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
+
+        def deprecated_method(data)
+          method_call(data.class_constant, data.deprecated_method)
+        end
+
+        def replacement_method(data)
+          method_call(data.class_constant, data.replacement_method)
+        end
+
+        def method_call(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
+  end
+end