rubocop 0.89.1 → 0.93.0

data/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -35,7 +35,7 @@ module RuboCop
         def op_method?(name)
           return false if EXCLUDED.include?(name)
 
-          !/\A\w/.match?(name) || OP_LIKE_METHODS.include?(name)
+          !/\A[[:word:]]/.match?(name) || OP_LIKE_METHODS.include?(name)
         end
       end
     end

data/lib/rubocop/cop/naming/file_name.rb

@@ -33,7 +33,7 @@ module RuboCop
                             'called `%<namespace>s`.'
         MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'
 
-        SNAKE_CASE = /^[\da-z_.?!]+$/.freeze
+        SNAKE_CASE = /^[\d[[:lower:]]_.?!]+$/.freeze
 
         def on_new_investigation
           file_path = processed_source.file_path

data/lib/rubocop/cop/offense.rb

@@ -63,9 +63,23 @@ module RuboCop
       attr_reader :corrector
 
       PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
-                                     :end_pos)
+                                     :end_pos) do
+        alias_method :first_line, :line
+        alias_method :last_line, :line
+        alias_method :last_column, :column
 
-      NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 1).freeze
+        def column_range
+          column...last_column
+        end
+
+        def size
+          end_pos - begin_pos
+        end
+        alias_method :length, :size
+      end
+      private_constant :PseudoSourceRange
+
+      NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 0).freeze
 
       # @api private
       def initialize(severity, location, message, cop_name, # rubocop:disable Metrics/ParameterLists

data/lib/rubocop/cop/security/eval.rb

@@ -13,6 +13,7 @@ module RuboCop
       #   binding.eval(something)
       class Eval < Base
         MSG = 'The use of `eval` is a serious security risk.'
+        RESTRICT_ON_SEND = %i[eval].freeze
 
         def_node_matcher :eval?, <<~PATTERN
           (send {nil? (send nil? :binding)} :eval $!str ...)

data/lib/rubocop/cop/security/json_load.rb

@@ -26,6 +26,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'
+        RESTRICT_ON_SEND = %i[load restore].freeze
 
         def_node_matcher :json_load, <<~PATTERN
           (send (const {nil? cbase} :JSON) ${:load :restore} ...)

data/lib/rubocop/cop/security/marshal_load.rb

@@ -20,6 +20,7 @@ module RuboCop
       #
       class MarshalLoad < Base
         MSG = 'Avoid using `Marshal.%<method>s`.'
+        RESTRICT_ON_SEND = %i[load restore].freeze
 
         def_node_matcher :marshal_load, <<~PATTERN
           (send (const {nil? cbase} :Marshal) ${:load :restore}

data/lib/rubocop/cop/security/open.rb

@@ -21,6 +21,7 @@ module RuboCop
       #   URI.parse(something).open
       class Open < Base
         MSG = 'The use of `Kernel#open` is a serious security risk.'
+        RESTRICT_ON_SEND = %i[open].freeze
 
         def_node_matcher :open?, <<~PATTERN
           (send nil? :open $!str ...)

data/lib/rubocop/cop/security/yaml_load.rb

@@ -19,6 +19,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'
+        RESTRICT_ON_SEND = %i[load].freeze
 
         def_node_matcher :yaml_load, <<~PATTERN
           (send (const {nil? cbase} :YAML) :load ...)

data/lib/rubocop/cop/severity.rb

@@ -6,7 +6,6 @@ module RuboCop
     class Severity
       include Comparable
 
-      # @api private
       NAMES = %i[refactor convention warning error fatal].freeze
 
       # @api private
@@ -22,7 +21,6 @@ module RuboCop
       #   any of `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
       attr_reader :name
 
-      # @api private
       def self.name_from_code(code)
         name = code.to_sym
         CODE_TABLE[name] || name
@@ -37,22 +35,18 @@ module RuboCop
         freeze
       end
 
-      # @api private
       def to_s
         @name.to_s
       end
 
-      # @api private
       def code
         @name.to_s[0].upcase
       end
 
-      # @api private
       def level
         NAMES.index(name) + 1
       end
 
-      # @api private
       def ==(other)
         @name == if other.is_a?(Symbol)
                    other
@@ -61,12 +55,10 @@ module RuboCop
                  end
       end
 
-      # @api private
       def hash
         @name.hash
       end
 
-      # @api private
       def <=>(other)
         level <=> other.level
       end

data/lib/rubocop/cop/style/access_modifier_declarations.rb

@@ -65,8 +65,6 @@ module RuboCop
       class AccessModifierDeclarations < Base
         include ConfigurableEnforcedStyle
 
-        ACCESS_MODIFIERS = %i[private protected public module_function].to_set.freeze
-
         GROUP_STYLE_MESSAGE = [
           '`%<access_modifier>s` should not be',
           'inlined in method definitions.'
@@ -77,14 +75,16 @@ module RuboCop
           'inlined in method definitions.'
         ].join(' ')
 
+        RESTRICT_ON_SEND = %i[private protected public module_function].freeze
+
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
           (send nil? {:private :protected :public} (sym _))
         PATTERN
 
         def on_send(node)
-          return unless access_modifier?(node)
-          return if node.parent.pair_type?
-          return if cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
+          return unless node.access_modifier?
+          return if node.parent&.pair_type?
+          return if allow_modifiers_on_symbols?(node)
 
           if offense?(node)
             add_offense(node.loc.selector) if opposite_style_detected
@@ -95,12 +95,8 @@ module RuboCop
 
         private
 
-        def access_modifier?(node)
-          maybe_access_modifier?(node) && node.access_modifier?
-        end
-
-        def maybe_access_modifier?(node)
-          !node.receiver && ACCESS_MODIFIERS.include?(node.method_name)
+        def allow_modifiers_on_symbols?(node)
+          cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
         end
 
         def offense?(node)

data/lib/rubocop/cop/style/accessor_grouping.rb

@@ -7,6 +7,9 @@ module RuboCop
       # By default it enforces accessors to be placed in grouped declarations,
       # but it can be configured to enforce separating them in multiple declarations.
       #
+      # Note: `Sorbet` is not compatible with "grouped" style. Consider "separated" style
+      # or disabling this cop.
+      #
       # @example EnforcedStyle: grouped (default)
       #   # bad
       #   class Foo

data/lib/rubocop/cop/style/alias.rb

@@ -32,6 +32,8 @@ module RuboCop
         MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of ' \
                            '`alias %<current>s`.'
 
+        RESTRICT_ON_SEND = %i[alias_method].freeze
+
         def on_send(node)
           return unless node.command?(:alias_method)
           return unless style == :prefer_alias && alias_keyword_possible?(node)

data/lib/rubocop/cop/style/array_coercion.rb

@@ -5,6 +5,10 @@ module RuboCop
     module Style
       # This cop enforces the use of `Array()` instead of explicit `Array` check or `[*var]`.
       #
+      # This cop is disabled by default because false positive will occur if
+      # the argument of `Array()` is not an array (e.g. Hash, Set),
+      # an array will be returned as an incompatibility result.
+      #
       # @example
       #   # bad
       #   paths = [paths] unless paths.is_a?(Array)

data/lib/rubocop/cop/style/array_join.rb

@@ -21,6 +21,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Favor `Array#join` over `Array#*`.'
+        RESTRICT_ON_SEND = %i[*].freeze
 
         def_node_matcher :join_candidate?, '(send $array :* $str)'
 

data/lib/rubocop/cop/style/attr.rb

@@ -19,6 +19,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not use `attr`. Use `%<replacement>s` instead.'
+        RESTRICT_ON_SEND = %i[attr].freeze
 
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?

data/lib/rubocop/cop/style/auto_resource_cleanup.rb

@@ -23,6 +23,8 @@ module RuboCop
           File: :open
         }.freeze
 
+        RESTRICT_ON_SEND = TARGET_METHODS.values.freeze
+
         def on_send(node)
           TARGET_METHODS.each do |target_class, target_method|
             next if node.method_name != target_method

data/lib/rubocop/cop/style/case_equality.rb

@@ -14,7 +14,7 @@ module RuboCop
       #   # good
       #   something.is_a?(Array)
       #   (1..100).include?(7)
-      #   some_string =~ /something/
+      #   /something/.match?(some_string)
       #
       # @example AllowOnConstant
       #   # Style/CaseEquality:
@@ -27,17 +27,20 @@ module RuboCop
       #   # good
       #   Array === something
       #   (1..100).include?(7)
-      #   some_string =~ /something/
+      #   /something/.match?(some_string)
       #
       class CaseEquality < Base
         extend AutoCorrector
 
         MSG = 'Avoid the use of the case equality operator `===`.'
+        RESTRICT_ON_SEND = %i[===].freeze
 
         def_node_matcher :case_equality?, '(send $#const? :=== $_)'
 
         def on_send(node)
           case_equality?(node) do |lhs, rhs|
+            return if lhs.const_type? && !lhs.module_name?
+
             add_offense(node.loc.selector) do |corrector|
               replacement = replacement(lhs, rhs)
               corrector.replace(node, replacement) if replacement
@@ -58,7 +61,12 @@ module RuboCop
         def replacement(lhs, rhs)
           case lhs.type
           when :regexp
-            "#{rhs.source} =~ #{lhs.source}"
+            # The automatic correction from `a === b` to `a.match?(b)` needs to
+            # consider `Regexp.last_match?`, `$~`, `$1`, and etc.
+            # This correction is expected to be supported by `Performance/Regexp` cop.
+            # See: https://github.com/rubocop-hq/rubocop-performance/issues/152
+            #
+            # So here is noop.
           when :begin
             child = lhs.children.first
             "#{lhs.source}.include?(#{rhs.source})" if child&.range_type?

data/lib/rubocop/cop/style/case_like_if.rb

@@ -42,6 +42,8 @@ module RuboCop
           convertible = true
 
           branch_conditions(node).each do |branch_condition|
+            return false if regexp_with_working_captures?(branch_condition)
+
             conditions << []
             convertible = collect_conditions(branch_condition, target, conditions.last)
             break unless convertible
@@ -49,9 +51,7 @@ module RuboCop
 
           return unless convertible
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         private
@@ -107,7 +107,7 @@ module RuboCop
           when :include?, :cover?
             receiver = deparenthesize(node.receiver)
             node.arguments.first if receiver.range_type?
-          when :match, :match?
+          when :match, :match?, :=~
             find_target_in_match_node(node)
           end
         end
@@ -115,7 +115,7 @@ module RuboCop
         def find_target_in_equality_node(node)
           argument = node.arguments.first
           receiver = node.receiver
-          return unless receiver
+          return unless argument && receiver
 
           if argument.literal? || const_reference?(argument)
             receiver
@@ -159,9 +159,10 @@ module RuboCop
           case node.method_name
           when :is_a?
             node.arguments.first if node.receiver == target
-          when :==, :eql?, :equal?, :=~, :match, :match?
-            lhs, _method, rhs = *node
-            condition_from_binary_op(lhs, rhs, target)
+          when :==, :eql?, :equal?
+            condition_from_equality_node(node, target)
+          when :=~, :match, :match?
+            condition_from_match_node(node, target)
           when :===
             lhs, _method, rhs = *node
             lhs if rhs == target
@@ -172,6 +173,17 @@ module RuboCop
         end
         # rubocop:enable Metrics/CyclomaticComplexity
 
+        def condition_from_equality_node(node, target)
+          lhs, _method, rhs = *node
+          condition = condition_from_binary_op(lhs, rhs, target)
+          condition if condition && !class_reference?(condition)
+        end
+
+        def condition_from_match_node(node, target)
+          lhs, _method, rhs = *node
+          condition_from_binary_op(lhs, rhs, target)
+        end
+
         def condition_from_binary_op(lhs, rhs, target)
           lhs = deparenthesize(lhs)
           rhs = deparenthesize(rhs)
@@ -202,6 +214,10 @@ module RuboCop
             name == name.upcase
         end
 
+        def class_reference?(node)
+          node.const_type? && node.children[1].match?(/[[:lower:]]/)
+        end
+
         def deparenthesize(node)
           node = node.children.last while node.begin_type?
           node
@@ -214,6 +230,22 @@ module RuboCop
         def indent(node)
           ' ' * node.loc.column
         end
+
+        # Named captures work with `=~` (if regexp is on lhs) and with `match` (both sides)
+        def regexp_with_working_captures?(node)
+          case node.type
+          when :match_with_lvasgn
+            lhs, _rhs = *node
+            node.loc.selector.source == '=~' && regexp_with_named_captures?(lhs)
+          when :send
+            lhs, method, rhs = *node
+            method == :match && [lhs, rhs].any? { |n| regexp_with_named_captures?(n) }
+          end
+        end
+
+        def regexp_with_named_captures?(node)
+          node.regexp_type? && node.each_capture(named: true).count.positive?
+        end
       end
     end
   end

data/lib/rubocop/cop/style/class_and_module_children.rb

@@ -112,6 +112,8 @@ module RuboCop
         end
 
         def check_style(node, body)
+          return if node.identifier.children[0]&.cbase_type?
+
           if style == :nested
             check_nested_style(node)
           else

data/lib/rubocop/cop/style/class_check.rb

@@ -28,19 +28,16 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Prefer `Object#%<prefer>s` over `Object#%<current>s`.'
-
-        def_node_matcher :class_check?, '(send _ ${:is_a? :kind_of?} _)'
+        RESTRICT_ON_SEND = %i[is_a? kind_of?].freeze
 
         def on_send(node)
-          class_check?(node) do |method_name|
-            return if style == method_name
+          return if style == node.method_name
 
-            message = message(node)
-            add_offense(node.loc.selector, message: message) do |corrector|
-              replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
+          message = message(node)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
 
-              corrector.replace(node.loc.selector, replacement)
-            end
+            corrector.replace(node.loc.selector, replacement)
           end
         end
 

data/lib/rubocop/cop/style/class_equality_comparison.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of `Object#instance_of?` instead of class comparison
+      # for equality.
+      #
+      # @example
+      #   # bad
+      #   var.class == Date
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #   var.class.name == 'Date'
+      #
+      #   # good
+      #   var.instance_of?(Date)
+      #
+      class ClassEqualityComparison < Base
+        include RangeHelp
+        include IgnoredMethods
+        extend AutoCorrector
+
+        MSG = 'Use `Object.instance_of?` instead of comparing classes.'
+
+        RESTRICT_ON_SEND = %i[== equal? eql?].freeze
+
+        def_node_matcher :class_comparison_candidate?, <<~PATTERN
+          (send
+            {$(send _ :class) (send $(send _ :class) :name)}
+            {:== :equal? :eql?} $_)
+        PATTERN
+
+        def on_send(node)
+          def_node = node.each_ancestor(:def, :defs).first
+          return if def_node && ignored_method?(def_node.method_name)
+
+          class_comparison_candidate?(node) do |receiver_node, class_node|
+            range = range_between(receiver_node.loc.selector.begin_pos, node.source_range.end_pos)
+
+            add_offense(range) do |corrector|
+              corrector.replace(range, "instance_of?(#{class_node.source})")
+            end
+          end
+        end
+      end
+    end
+  end
+end