rubocop 0.90.0 → 0.93.1

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -7,15 +7,9 @@ module RuboCop
       include VisibilityHelp
 
       def source_range_with_comment(node)
-        begin_pos, end_pos =
-          if node.def_type?
-            start_node = find_visibility_start(node) || node
-            end_node = find_visibility_end(node) || node
-            [begin_pos_with_comment(start_node),
-             end_position_for(end_node) + 1]
-          else
-            [begin_pos_with_comment(node), end_position_for(node)]
-          end
+        begin_pos = begin_pos_with_comment(node)
+        end_pos = end_position_for(node)
+        end_pos += 1 if node.def_type?
 
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end

data/lib/rubocop/cop/mixin/configurable_naming.rb

@@ -8,8 +8,8 @@ module RuboCop
       include ConfigurableFormatting
 
       FORMATS = {
-        snake_case: /^@{0,2}[\da-z_]+[!?=]?$/,
-        camelCase:  /^@{0,2}(?:_|_?[a-z][\da-zA-Z]*)[!?=]?$/
+        snake_case: /^@{0,2}[\d[[:lower:]]_]+[!?=]?$/,
+        camelCase:  /^@{0,2}(?:_|_?[[[:lower:]]][\d[[:lower:]][[:upper:]]]*)[!?=]?$/
       }.freeze
     end
   end

data/lib/rubocop/cop/mixin/configurable_numbering.rb

@@ -8,9 +8,9 @@ module RuboCop
       include ConfigurableFormatting
 
       FORMATS = {
-        snake_case:  /(?:[a-z_]|_\d+)$/,
-        normalcase:  /(?:_\D*|[A-Za-z]\d*)$/,
-        non_integer: /[A-Za-z_]$/
+        snake_case:  /(?:[[[:lower:]]_]|_\d+)$/,
+        normalcase:  /(?:_\D*|[[[:upper:]][[:lower:]]]\d*)$/,
+        non_integer: /[[[:upper:]][[:lower:]]_]$/
       }.freeze
     end
   end

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -39,6 +39,15 @@ module RuboCop
         end
       end
 
+      def start_line_range(node)
+        expr   = node.source_range
+        buffer = expr.source_buffer
+        source = buffer.source_line(expr.line)
+        range  = buffer.line_range(expr.line)
+
+        range_between(range.begin_pos + (source =~ /\S/), range.begin_pos + (source =~ /\s*\z/))
+      end
+
       def add_offense_for_misalignment(node, align_with)
         end_loc = node.loc.end
         msg = format(MSG, end_line: end_loc.line,

data/lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -4,7 +4,15 @@ module RuboCop
   module Cop
     # Common functionality for Style/HashTransformKeys and
     # Style/HashTransformValues
-    module HashTransformMethod
+    module HashTransformMethod # rubocop:disable Metrics/ModuleLength
+      extend NodePattern::Macros
+
+      RESTRICT_ON_SEND = %i[[] to_h].freeze
+
+      def_node_matcher :array_receiver?, <<~PATTERN
+        {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
+      PATTERN
+
       def on_block(node)
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
@@ -129,7 +137,7 @@ module RuboCop
       end
 
       # Internal helper class to hold autocorrect data
-      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do # rubocop:disable Metrics/BlockLength
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
         def self.from_each_with_object(node, match)
           new(match, node, 0, 0)
         end

data/lib/rubocop/cop/mixin/rescue_node.rb

@@ -18,6 +18,7 @@ module RuboCop
           @modifier_locations.include?(node.loc.keyword)
       end
 
+      # @deprecated Use ResbodyNode#exceptions instead
       def rescued_exceptions(resbody)
         rescue_group, = *resbody
         if rescue_group

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -57,10 +57,11 @@ module RuboCop
       end
 
       def first_line_comment(node)
-        comment =
-          processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        comment = processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        return unless comment
 
-        comment ? comment.loc.expression.source : nil
+        comment_source = comment.loc.expression.source
+        comment_source unless comment_disables_cop?(comment_source)
       end
 
       def parenthesize?(node)
@@ -80,6 +81,11 @@ module RuboCop
 
         config.for_cop('Layout/LineLength')['Max']
       end
+
+      def comment_disables_cop?(comment)
+        regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
+        Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/visibility_help.rb

@@ -16,32 +16,20 @@ module RuboCop
       end
 
       def find_visibility_start(node)
-        left_siblings_of(node)
-          .reverse
-          .find(&method(:visibility_block?))
+        node.left_siblings
+            .reverse
+            .find(&method(:visibility_block?))
       end
 
       # Navigate to find the last protected method
       def find_visibility_end(node)
         possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
-        right = right_siblings_of(node)
+        right = node.right_siblings
         right.find do |child_node|
           possible_visibilities.include?(node_visibility(child_node))
         end || right.last
       end
 
-      def left_siblings_of(node)
-        siblings_of(node)[0, node.sibling_index]
-      end
-
-      def right_siblings_of(node)
-        siblings_of(node)[node.sibling_index..-1]
-      end
-
-      def siblings_of(node)
-        node.parent.children
-      end
-
       def_node_matcher :visibility_block?, <<~PATTERN
         (send nil? { :private :protected :public })
       PATTERN

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,10 +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
+
+        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, 1).freeze
+      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/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

@@ -33,11 +33,14 @@ module RuboCop
         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

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
@@ -230,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