rubocop 1.27.0 → 1.51.0

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Forbids Yoda expressions, i.e. binary operations (using `*`, `+`, `&`, `|`,
+      # and `^` operators) where the order of expression is reversed, eg. `1 + x`.
+      # This cop complements `Style/YodaCondition` cop, which has a similar purpose.
+      #
+      # This cop is disabled by default to respect user intentions such as:
+      #
+      # [source,ruby]
+      # ----
+      # config.server_port = 9000 + ENV["TEST_ENV_NUMBER"].to_i
+      # ----
+      #
+      # @safety
+      #   This cop is unsafe because binary operators can be defined
+      #   differently on different classes, and are not guaranteed to
+      #   have the same result if reversed.
+      #
+      # @example SupportedOperators: ['*', '+', '&'']
+      #   # bad
+      #   1 + x
+      #   10 * y
+      #   1 & z
+      #   1 + CONST
+      #
+      #   # good
+      #   60 * 24
+      #   x + 1
+      #   y * 10
+      #   z & 1
+      #   CONST + 1
+      #
+      #   # good
+      #   1 | x
+      #
+      class YodaExpression < Base
+        extend AutoCorrector
+
+        MSG = 'Non-literal operand (`%<source>s`) should be first.'
+
+        RESTRICT_ON_SEND = %i[* + & | ^].freeze
+
+        def on_new_investigation
+          @offended_nodes = nil
+        end
+
+        def on_send(node)
+          return unless supported_operators.include?(node.method_name.to_s)
+
+          lhs = node.receiver
+          rhs = node.first_argument
+          return unless yoda_expression_constant?(lhs, rhs)
+          return if offended_ancestor?(node)
+
+          message = format(MSG, source: rhs.source)
+          add_offense(node, message: message) do |corrector|
+            corrector.swap(lhs, rhs)
+          end
+
+          offended_nodes.add(node)
+        end
+
+        private
+
+        def yoda_expression_constant?(lhs, rhs)
+          constant_portion?(lhs) && !constant_portion?(rhs)
+        end
+
+        def constant_portion?(node)
+          node.numeric_type? || node.const_type?
+        end
+
+        def supported_operators
+          Array(cop_config['SupportedOperators'])
+        end
+
+        def offended_ancestor?(node)
+          node.each_ancestor(:send).any? { |ancestor| @offended_nodes&.include?(ancestor) }
+        end
+
+        def offended_nodes
+          @offended_nodes ||= Set.new.compare_by_identity
+        end
+      end
+    end
+  end
+end

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

@@ -3,11 +3,14 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for numeric comparisons that can be replaced
-      # by a predicate method, such as receiver.length == 0,
-      # receiver.length > 0, receiver.length != 0,
-      # receiver.length < 1 and receiver.size == 0 that can be
-      # replaced by receiver.empty? and !receiver.empty?.
+      # Checks for numeric comparisons that can be replaced
+      # by a predicate method, such as `receiver.length == 0`,
+      # `receiver.length > 0`, and `receiver.length != 0`,
+      # `receiver.length < 1` and `receiver.size == 0` that can be
+      # replaced by `receiver.empty?` and `!receiver.empty?`.
+      #
+      # NOTE: `File`, `Tempfile`, and `StringIO` do not have `empty?`
+      # so allow `size == 0` and `size.zero?`.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -34,43 +37,56 @@ module RuboCop
       class ZeroLengthPredicate < Base
         extend AutoCorrector
 
-        ZERO_MSG = 'Use `empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
-        NONZERO_MSG = 'Use `!empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
+        ZERO_MSG = 'Use `empty?` instead of `%<current>s`.'
+        NONZERO_MSG = 'Use `!empty?` instead of `%<current>s`.'
 
         RESTRICT_ON_SEND = %i[size length].freeze
 
         def on_send(node)
           check_zero_length_predicate(node)
-          check_nonzero_length_predicate(node)
+          check_zero_length_comparison(node)
+          check_nonzero_length_comparison(node)
         end
 
         private
 
         def check_zero_length_predicate(node)
-          zero_length_predicate = zero_length_predicate(node.parent)
-          return unless zero_length_predicate
+          return unless (length_method = zero_length_predicate(node.parent))
+          return if non_polymorphic_collection?(node.parent)
+
+          offense = node.loc.selector.join(node.parent.source_range.end)
+          message = format(ZERO_MSG, current: "#{length_method}.zero?")
 
-          lhs, opr, rhs = zero_length_predicate
+          add_offense(offense, message: message) do |corrector|
+            corrector.replace(offense, 'empty?')
+          end
+        end
+
+        def check_zero_length_comparison(node)
+          zero_length_comparison = zero_length_comparison(node.parent)
+          return unless zero_length_comparison
+
+          lhs, opr, rhs = zero_length_comparison
 
           return if non_polymorphic_collection?(node.parent)
 
           add_offense(
-            node.parent, message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+            node.parent, message: format(ZERO_MSG, current: "#{lhs} #{opr} #{rhs}")
           ) do |corrector|
             corrector.replace(node.parent, replacement(node.parent))
           end
         end
 
-        def check_nonzero_length_predicate(node)
-          nonzero_length_predicate = nonzero_length_predicate(node.parent)
-          return unless nonzero_length_predicate
+        def check_nonzero_length_comparison(node)
+          nonzero_length_comparison = nonzero_length_comparison(node.parent)
+          return unless nonzero_length_comparison
 
-          lhs, opr, rhs = nonzero_length_predicate
+          lhs, opr, rhs = nonzero_length_comparison
 
           return if non_polymorphic_collection?(node.parent)
 
           add_offense(
-            node.parent, message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+            node.parent, message: format(NONZERO_MSG, current: "#{lhs} #{opr} #{rhs}")
           ) do |corrector|
             corrector.replace(node.parent, replacement(node.parent))
           end
@@ -78,14 +94,19 @@ module RuboCop
 
         # @!method zero_length_predicate(node)
         def_node_matcher :zero_length_predicate, <<~PATTERN
+          (send (send (...) ${:length :size}) :zero?)
+        PATTERN
+
+        # @!method zero_length_comparison(node)
+        def_node_matcher :zero_length_comparison, <<~PATTERN
           {(send (send (...) ${:length :size}) $:== (int $0))
            (send (int $0) $:== (send (...) ${:length :size}))
            (send (send (...) ${:length :size}) $:<  (int $1))
            (send (int $1) $:> (send (...) ${:length :size}))}
         PATTERN
 
-        # @!method nonzero_length_predicate(node)
-        def_node_matcher :nonzero_length_predicate, <<~PATTERN
+        # @!method nonzero_length_comparison(node)
+        def_node_matcher :nonzero_length_comparison, <<~PATTERN
           {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
            (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
         PATTERN
@@ -117,7 +138,7 @@ module RuboCop
         # @!method non_polymorphic_collection?(node)
         def_node_matcher :non_polymorphic_collection?, <<~PATTERN
           {(send (send (send (const {nil? cbase} :File) :stat _) ...) ...)
-           (send (send (send (const {nil? cbase} {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
+           (send (send (send (const {nil? cbase} {:File :Tempfile :StringIO}) {:new :open} ...) ...) ...)}
         PATTERN
       end
     end

data/lib/rubocop/cop/team.rb

@@ -10,20 +10,6 @@ module RuboCop
     # first the ones needed for autocorrection (if any), then the rest
     # (unless autocorrections happened).
     class Team
-      attr_reader :errors, :warnings, :updated_source_file, :cops
-
-      alias updated_source_file? updated_source_file
-
-      def initialize(cops, config = nil, options = {})
-        @cops = cops
-        @config = config
-        @options = options
-        reset
-        @ready = true
-
-        validate_config
-      end
-
       # @return [Team]
       def self.new(cop_or_classes, config, options = {})
         # Support v0 api:
@@ -38,18 +24,47 @@ module RuboCop
         new(cops, config, options)
       end
 
-      # @return [Array<Cop::Cop>]
+      # @return [Array<Cop::Base>]
       def self.mobilize_cops(cop_classes, config, options = {})
-        cop_classes = Registry.new(cop_classes.to_a) unless cop_classes.is_a?(Registry)
-        only = options.fetch(:only, [])
-        safe = options.fetch(:safe, false)
-        cop_classes.enabled(config, only, only_safe: safe).map do |cop_class|
+        cop_classes = Registry.new(cop_classes.to_a, options) unless cop_classes.is_a?(Registry)
+
+        cop_classes.map do |cop_class|
           cop_class.new(config, options)
         end
       end
 
+      # @return [Array<Force>] needed for the given cops
+      def self.forces_for(cops)
+        needed = Hash.new { |h, k| h[k] = [] }
+        cops.each do |cop|
+          forces = cop.class.joining_forces
+          if forces.is_a?(Array)
+            forces.each { |force| needed[force] << cop }
+          elsif forces
+            needed[forces] << cop
+          end
+        end
+
+        needed.map { |force_class, joining_cops| force_class.new(joining_cops) }
+      end
+
+      attr_reader :errors, :warnings, :updated_source_file, :cops
+
+      alias updated_source_file? updated_source_file
+
+      def initialize(cops, config = nil, options = {})
+        @cops = cops
+        @config = config
+        @options = options
+        reset
+        @ready = true
+        @registry = Registry.new(cops, options.dup)
+
+        validate_config
+      end
+
       def autocorrect?
-        @options[:auto_correct]
+        @options[:autocorrect]
       end
 
       def debug?
@@ -63,24 +78,25 @@ module RuboCop
       end
 
       # @return [Commissioner::InvestigationReport]
-      def investigate(processed_source)
+      def investigate(processed_source, offset: 0, original: processed_source)
         be_ready
 
         # The autocorrection process may have to be repeated multiple times
         # until there are no corrections left to perform
-        # To speed things up, run auto-correcting cops by themselves, and only
+        # To speed things up, run autocorrecting cops by themselves, and only
         # run the other cops when no corrections are left
-        on_duty = roundup_relevant_cops(processed_source.file_path)
+        on_duty = roundup_relevant_cops(processed_source)
 
         autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
+        report = investigate_partial(autocorrect_cops, processed_source,
+                                     offset: offset, original: original)
 
-        report = investigate_partial(autocorrect_cops, processed_source)
-
-        unless autocorrect(processed_source, report)
+        unless autocorrect(processed_source, report, offset: offset, original: original)
           # If we corrected some errors, another round of inspection will be
           # done, and any other offenses will be caught then, so only need
           # to check other_cops if no correction was done
-          report = report.merge(investigate_partial(other_cops, processed_source))
+          report = report.merge(investigate_partial(other_cops, processed_source,
+                                                    offset: offset, original: original))
         end
 
         process_errors(processed_source.path, report.errors)
@@ -95,34 +111,19 @@ module RuboCop
         @forces ||= self.class.forces_for(cops)
       end
 
-      # @return [Array<Force>] needed for the given cops
-      def self.forces_for(cops)
-        needed = Hash.new { |h, k| h[k] = [] }
-        cops.each do |cop|
-          forces = cop.class.joining_forces
-          if forces.is_a?(Array)
-            forces.each { |force| needed[force] << cop }
-          elsif forces
-            needed[forces] << cop
-          end
-        end
-
-        needed.map { |force_class, joining_cops| force_class.new(joining_cops) }
-      end
-
       def external_dependency_checksum
-        keys = cops.map(&:external_dependency_checksum).compact
+        keys = cops.filter_map(&:external_dependency_checksum)
         Digest::SHA1.hexdigest(keys.join)
       end
 
       private
 
-      def autocorrect(processed_source, report)
+      def autocorrect(processed_source, report, original:, offset:)
         @updated_source_file = false
         return unless autocorrect?
         return if report.processed_source.parser_error
 
-        new_source = autocorrect_report(report)
+        new_source = autocorrect_report(report, original: original, offset: offset)
 
         return unless new_source
 
@@ -130,7 +131,7 @@ module RuboCop
           # holds source read in from stdin, when --stdin option is used
           @options[:stdin] = new_source
         else
-          filename = processed_source.buffer.name
+          filename = processed_source.file_path
           File.write(filename, new_source)
         end
         @updated_source_file = true
@@ -150,17 +151,19 @@ module RuboCop
       end
 
       # @return [Commissioner::InvestigationReport]
-      def investigate_partial(cops, processed_source)
+      def investigate_partial(cops, processed_source, offset:, original:)
         commissioner = Commissioner.new(cops, self.class.forces_for(cops), @options)
-        commissioner.investigate(processed_source)
+        commissioner.investigate(processed_source, offset: offset, original: original)
       end
 
       # @return [Array<cop>]
-      def roundup_relevant_cops(filename)
-        cops.reject do |cop|
-          cop.excluded_file?(filename) ||
-            !support_target_ruby_version?(cop) ||
-            !support_target_rails_version?(cop)
+      def roundup_relevant_cops(processed_source)
+        cops.select do |cop|
+          next true if processed_source.comment_config.cop_opted_in?(cop)
+          next false if cop.excluded_file?(processed_source.file_path)
+          next false unless @registry.enabled?(cop, @config)
+
+          support_target_ruby_version?(cop) && support_target_rails_version?(cop)
         end
       end
 
@@ -176,18 +179,22 @@ module RuboCop
         cop.class.support_target_rails_version?(cop.target_rails_version)
       end
 
-      def autocorrect_report(report)
-        corrector = collate_corrections(report)
+      def autocorrect_report(report, offset:, original:)
+        corrector = collate_corrections(report, offset: offset, original: original)
 
         corrector.rewrite unless corrector.empty?
       end
 
-      def collate_corrections(report)
-        corrector = Corrector.new(report.processed_source)
+      def collate_corrections(report, offset:, original:)
+        corrector = Corrector.new(original)
 
         each_corrector(report) do |to_merge|
           suppress_clobbering do
-            corrector.merge!(to_merge)
+            if offset.positive?
+              corrector.import!(to_merge, offset: offset)
+            else
+              corrector.merge!(to_merge)
+            end
           end
         end
 

data/lib/rubocop/cop/util.rb

@@ -3,6 +3,7 @@
 module RuboCop
   module Cop
     # This module contains a collection of useful utility methods.
+    # rubocop:disable Metrics/ModuleLength
     module Util
       include PathUtil
 
@@ -34,7 +35,7 @@ module RuboCop
       def add_parentheses(node, corrector)
         if node.args_type?
           arguments_range = node.source_range
-          args_with_space = range_with_surrounding_space(range: arguments_range, side: :left)
+          args_with_space = range_with_surrounding_space(arguments_range, side: :left)
           leading_space = range_between(args_with_space.begin_pos, arguments_range.begin_pos)
           corrector.replace(leading_space, '(')
           corrector.insert_after(arguments_range, ')')
@@ -52,6 +53,21 @@ module RuboCop
       end
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
+      def any_descendant?(node, *types)
+        if block_given?
+          node.each_descendant(*types) do |descendant|
+            return true if yield(descendant)
+          end
+        else
+          # Use a block version to avoid allocating enumerators.
+          node.each_descendant do # rubocop:disable Lint/UnreachableLoop
+            return true
+          end
+        end
+
+        false
+      end
+
       def args_begin(node)
         loc = node.loc
         selector = if node.super_type? || node.yield_type?
@@ -65,20 +81,32 @@ module RuboCop
       end
 
       def args_end(node)
-        node.loc.expression.end
+        node.source_range.end
       end
 
       def on_node(syms, sexp, excludes = [], &block)
         return to_enum(:on_node, syms, sexp, excludes) unless block
 
-        yield sexp if Array(syms).include?(sexp.type)
-        return if Array(excludes).include?(sexp.type)
+        yield sexp if include_or_equal?(syms, sexp.type)
+        return if include_or_equal?(excludes, sexp.type)
 
         sexp.each_child_node { |elem| on_node(syms, elem, excludes, &block) }
       end
 
+      # Arbitrarily chosen value, should be enough to cover
+      # the most nested source code in real world projects.
+      MAX_LINE_BEGINS_REGEX_INDEX = 50
+      LINE_BEGINS_REGEX_CACHE = Hash.new do |hash, index|
+        hash[index] = /^\s{#{index}}\S/ if index <= MAX_LINE_BEGINS_REGEX_INDEX
+      end
+      private_constant :MAX_LINE_BEGINS_REGEX_INDEX, :LINE_BEGINS_REGEX_CACHE
+
       def begins_its_line?(range)
-        range.source_line.index(/\S/) == range.column
+        if (regex = LINE_BEGINS_REGEX_CACHE[range.column])
+          range.source_line.match?(regex)
+        else
+          range.source_line.index(/\S/) == range.column
+        end
       end
 
       # Returns, for example, a bare `if` node if the given node is an `if`
@@ -122,11 +150,11 @@ module RuboCop
           string.inspect
         else
           # In a single-quoted strings, double quotes don't need to be escaped
-          "'#{string.gsub('\"', '"').gsub('\\') { '\\\\' }}'"
+          "'#{string.gsub('\\') { '\\\\' }.gsub('\"', '"')}'"
         end
       end
 
-      def trim_string_interporation_escape_character(str)
+      def trim_string_interpolation_escape_character(str)
         str.gsub(/\\\#\{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
       end
 
@@ -152,8 +180,11 @@ module RuboCop
         ' ' * (node.loc.column + offset)
       end
 
+      @to_supported_styles_cache = {}
+
       def to_supported_styles(enforced_style)
-        enforced_style.sub(/^Enforced/, 'Supported').sub('Style', 'Styles')
+        @to_supported_styles_cache[enforced_style] ||=
+          enforced_style.sub(/^Enforced/, 'Supported').sub('Style', 'Styles')
       end
 
       private
@@ -162,6 +193,11 @@ module RuboCop
         src = src.dup if RUBY_ENGINE == 'jruby'
         src.force_encoding(Encoding.default_external).valid_encoding?
       end
+
+      def include_or_equal?(source, target)
+        source == target || (source.is_a?(Array) && source.include?(target))
+      end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -47,6 +47,10 @@ module RuboCop
           @node.type == REGEXP_NAMED_CAPTURE_TYPE
         end
 
+        def exception_assignment?
+          node.parent&.resbody_type? && node.parent.exception_variable == node
+        end
+
         def operator_assignment?
           return false unless meta_assignment_node
 
@@ -83,7 +87,7 @@ module RuboCop
         end
 
         def multiple_assignment_node
-          grandparent_node = node.parent ? node.parent.parent : nil
+          grandparent_node = node.parent&.parent
           return nil unless grandparent_node
           return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
           return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE

data/lib/rubocop/cop/variable_force/branch.rb

@@ -127,7 +127,7 @@ module RuboCop
           alias_method :eql?, :==
 
           def hash
-            control_node.object_id.hash ^ child_node.object_id.hash
+            [control_node.object_id, control_node.object_id].hash
           end
 
           private

data/lib/rubocop/cop/variable_force/scope.rb

@@ -45,9 +45,9 @@ module RuboCop
             node
           else
             child_index = case node.type
-                          when :module, :sclass     then 1
-                          when :def, :class, :block then 2
-                          when :defs                then 3
+                          when :module, :sclass then 1
+                          when :def, :class, :block, :numblock then 2
+                          when :defs then 3
                           end
 
             node.children[child_index]

data/lib/rubocop/cop/variable_force/variable.rb

@@ -52,7 +52,7 @@ module RuboCop
             # if/unless keyword. A preceding assignment is needed to put the
             # variable in scope. For this reason we skip to the next assignment
             # here.
-            next if in_modifier_if?(assignment)
+            next if in_modifier_conditional?(assignment)
 
             break if !assignment.branch || assignment.branch == reference.branch
 
@@ -63,10 +63,12 @@ module RuboCop
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        def in_modifier_if?(assignment)
+        def in_modifier_conditional?(assignment)
           parent = assignment.node.parent
           parent = parent.parent if parent&.begin_type?
-          parent&.if_type? && parent&.modifier_form?
+          return false if parent.nil?
+
+          (parent.if_type? || parent.while_type? || parent.until_type?) && parent.modifier_form?
         end
 
         def capture_with_block!

data/lib/rubocop/cop/variable_force/variable_table.rb

@@ -97,8 +97,10 @@ module RuboCop
           scope_stack.reverse_each do |scope|
             variable = scope.variables[name]
             return variable if variable
+
             # Only block scope allows referencing outer scope variables.
-            return nil unless scope.node.block_type?
+            node = scope.node
+            return nil unless node.block_type? || node.numblock_type?
           end
 
           nil
@@ -109,16 +111,16 @@ module RuboCop
         end
 
         def accessible_variables
-          scope_stack.reverse_each.each_with_object([]) do |scope, variables|
+          scope_stack.reverse_each.with_object([]) do |scope, variables|
             variables.concat(scope.variables.values)
-            break variables unless scope.node.block_type?
+            break variables unless scope.node.block_type? || scope.node.numblock_type?
           end
         end
 
         private
 
         def mark_variable_as_captured_by_block_if_so(variable)
-          return unless current_scope.node.block_type?
+          return unless current_scope.node.block_type? || current_scope.node.numblock_type?
           return if variable.scope == current_scope
 
           variable.capture_with_block!