rubocop 0.78.0

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for ambiguous block association with method
+      # when param passed without parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #   some_method a { |val| puts val }
+      #
+      # @example
+      #
+      #   # good
+      #   # With parentheses, there's no ambiguity.
+      #   some_method(a) { |val| puts val }
+      #
+      #   # good
+      #   # Operator methods require no disambiguation
+      #   foo == bar { |b| b.baz }
+      #
+      #   # good
+      #   # Lambda arguments require no disambiguation
+      #   foo = ->(bar) { bar.baz }
+      class AmbiguousBlockAssociation < Cop
+        MSG = 'Parenthesize the param `%<param>s` to make sure that the ' \
+              'block will be associated with the `%<method>s` method ' \
+              'call.'
+
+        def on_send(node)
+          return if !node.arguments? || node.parenthesized? ||
+                    node.last_argument.lambda? || allowed_method?(node)
+
+          return unless ambiguous_block_association?(node)
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def ambiguous_block_association?(send_node)
+          send_node.last_argument.block_type? &&
+            !send_node.last_argument.send_node.arguments?
+        end
+
+        def allowed_method?(node)
+          node.assignment? || node.operator_method? || node.method?(:[])
+        end
+
+        def message(send_node)
+          block_param = send_node.last_argument
+
+          format(MSG, param: block_param.source,
+                      method: block_param.send_node.source)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for ambiguous operators in the first argument of a
+      # method invocation without parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # The `*` is interpreted as a splat operator but it could possibly be
+      #   # a `*` method invocation (i.e. `do_something.*(some_array)`).
+      #   do_something *some_array
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # With parentheses, there's no ambiguity.
+      #   do_something(*some_array)
+      class AmbiguousOperator < Cop
+        include ParserDiagnostic
+
+        AMBIGUITIES = {
+          '+'  => { actual: 'positive number', possible: 'addition' },
+          '-'  => { actual: 'negative number', possible: 'subtraction' },
+          '*'  => { actual: 'splat',           possible: 'multiplication' },
+          '&'  => { actual: 'block',           possible: 'binary AND' },
+          '**' => { actual: 'keyword splat',   possible: 'exponent' }
+        }.each do |key, hash|
+          hash[:operator] = key
+        end
+
+        MSG_FORMAT = 'Ambiguous %<actual>s operator. Parenthesize the method ' \
+                     "arguments if it's surely a %<actual>s operator, or add " \
+                     'a whitespace to the right of the `%<operator>s` if it ' \
+                     'should be a %<possible>s.'
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :ambiguous_prefix
+        end
+
+        def alternative_message(diagnostic)
+          operator = diagnostic.location.source
+          hash = AMBIGUITIES[operator]
+          format(MSG_FORMAT, hash)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for ambiguous regexp literals in the first argument of
+      # a method invocation without parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # This is interpreted as a method invocation with a regexp literal,
+      #   # but it could possibly be `/` method invocations.
+      #   # (i.e. `do_something./(pattern)./(i)`)
+      #   do_something /pattern/i
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # With parentheses, there's no ambiguity.
+      #   do_something(/pattern/i)
+      class AmbiguousRegexpLiteral < Cop
+        include ParserDiagnostic
+
+        MSG = 'Ambiguous regexp literal. Parenthesize the method arguments ' \
+              "if it's surely a regexp literal, or add a whitespace to the " \
+              'right of the `/` if it should be a division.'
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :ambiguous_literal
+        end
+
+        def alternative_message(_diagnostic)
+          MSG
+        end
+      end
+    end
+  end
+end

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,38 @@
+# 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
+      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/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} ...)
+           (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)
+          target_ruby_version >= 2.4 && binding_irb_call?(node)
+        end
+      end
+    end
+  end
+end