rubocop 1.41.1 → 1.45.1

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

@@ -81,17 +81,16 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.arguments?
+          return unless node.parent && node.arguments?
           return if not_modifier_form?(node.parent)
 
           previous_older_sibling = find_previous_older_sibling(node)
           return unless previous_older_sibling
 
           add_offense(node, message: format(MSG, name: node.method_name)) do |corrector|
-            swap(
+            corrector.swap(
               range_with_comments_and_lines(previous_older_sibling),
-              range_with_comments_and_lines(node.parent.if_type? ? node.parent : node),
-              corrector: corrector
+              range_with_comments_and_lines(node.parent.if_type? ? node.parent : node)
             )
           end
         end
@@ -102,8 +101,10 @@ module RuboCop
           node.if_type? && !node.modifier_form?
         end
 
-        def find_previous_older_sibling(node) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+        def find_previous_older_sibling(node) # rubocop:disable Metrics
           search_node(node).left_siblings.reverse.find do |sibling|
+            next unless sibling.is_a?(AST::Node)
+
             sibling = sibling_node(sibling)
             break unless sibling&.send_type? && sibling&.method?(node.method_name)
             break unless sibling.arguments? && !sibling.receiver
@@ -128,12 +129,6 @@ module RuboCop
             end_pos: node2.location.expression.end_pos
           ).source.include?("\n\n")
         end
-
-        def swap(range1, range2, corrector:)
-          inserted = range2.source
-          corrector.insert_before(range1, inserted)
-          corrector.remove(range2)
-        end
       end
     end
   end

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

@@ -86,12 +86,12 @@ module RuboCop
 
         def on_send(node)
           return unless (block_node = node.block_node)
-          return if block_node.body.begin_type?
+          return if block_node.body&.begin_type?
           return if receiver_allowed?(block_node.receiver)
           return unless (regexp_method_send_node = extract_send_node(block_node))
           return if match_predicate_without_receiver?(regexp_method_send_node)
 
-          opposite = regexp_method_send_node.send_type? && regexp_method_send_node.method?(:!~)
+          opposite = opposite?(regexp_method_send_node)
           regexp = find_regexp(regexp_method_send_node, block_node)
 
           register_offense(node, block_node, regexp, opposite)
@@ -128,6 +128,10 @@ module RuboCop
           regexp_method_send_node
         end
 
+        def opposite?(regexp_method_send_node)
+          regexp_method_send_node.send_type? && regexp_method_send_node.method?(:!~)
+        end
+
         def find_regexp(node, block)
           return node.child_nodes.first if node.match_with_lvasgn_type?
 

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

@@ -42,7 +42,7 @@ module RuboCop
 
           if rhs.send_type?
             check_send_node(node, rhs, var_name, var_type)
-          elsif %i[and or].include?(rhs.type)
+          elsif rhs.operator_keyword?
             check_boolean_node(node, rhs, var_name, var_type)
           end
         end
@@ -76,7 +76,7 @@ module RuboCop
 
           if rhs.send_type?
             autocorrect_send_node(corrector, node, rhs)
-          elsif %i[and or].include?(rhs.type)
+          elsif rhs.operator_keyword?
             autocorrect_boolean_node(corrector, node, rhs)
           end
         end

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

@@ -72,8 +72,10 @@ module RuboCop
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            yield line, tokens.last.column, tokens[-2] if tokens.last.semicolon?
-            yield line, tokens.first.column if tokens.first.semicolon?
+            semicolon_pos = semicolon_position(tokens)
+            after_expr_pos = semicolon_pos == -1 ? -2 : semicolon_pos
+
+            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos] if semicolon_pos
           end
         end
 
@@ -81,6 +83,26 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
+        def semicolon_position(tokens)
+          if tokens.last.semicolon?
+            -1
+          elsif tokens.first.semicolon?
+            0
+          elsif exist_semicolon_before_right_curly_brace?(tokens)
+            -3
+          elsif exist_semicolon_after_left_curly_brace?(tokens)
+            2
+          end
+        end
+
+        def exist_semicolon_before_right_curly_brace?(tokens)
+          tokens[-2]&.right_curly_brace? && tokens[-3]&.semicolon?
+        end
+
+        def exist_semicolon_after_left_curly_brace?(tokens)
+          tokens[1]&.left_curly_brace? && tokens[2]&.semicolon?
+        end
+
         def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 

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

@@ -119,11 +119,6 @@ module RuboCop
         # @!method custom_fail_methods(node)
         def_node_search :custom_fail_methods, '{(def :fail ...) (defs _ :fail ...)}'
 
-        def on_new_investigation
-          ast = processed_source.ast
-          @custom_fail_defined = ast && custom_fail_methods(ast).any?
-        end
-
         def on_rescue(node)
           return unless style == :semantic
 
@@ -141,7 +136,7 @@ module RuboCop
           when :semantic
             check_send(:raise, node) unless ignored_node?(node)
           when :only_raise
-            return if @custom_fail_defined
+            return if custom_fail_defined?
 
             check_send(:fail, node)
           when :only_fail
@@ -151,6 +146,13 @@ module RuboCop
 
         private
 
+        def custom_fail_defined?
+          return @custom_fail_defined if defined?(@custom_fail_defined)
+
+          ast = processed_source.ast
+          @custom_fail_defined = ast && custom_fail_methods(ast).any?
+        end
+
         def message(method_name)
           case style
           when :semantic

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

@@ -41,10 +41,13 @@ module RuboCop
 
         def on_pair(node)
           return unless string_hash_key?(node)
+
+          key_content = node.key.str_content
+          return unless key_content.valid_encoding?
           return if receive_environments_method?(node)
 
           add_offense(node.key) do |corrector|
-            symbol_content = node.key.str_content.to_sym.inspect
+            symbol_content = key_content.to_sym.inspect
 
             corrector.replace(node.key, symbol_content)
           end

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

@@ -60,7 +60,7 @@ module RuboCop
         def symbols_contain_spaces?(node)
           node.children.any? do |sym|
             content, = *sym
-            / /.match?(content)
+            content.to_s.include?(' ')
           end
         end
 

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

@@ -88,6 +88,10 @@ module RuboCop
         include TrailingComma
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Layout::HeredocArgumentClosingParenthesis]
+        end
+
         def on_send(node)
           return unless node.arguments? && node.parenthesized?
 
@@ -96,10 +100,6 @@ module RuboCop
                 node.source_range.end_pos)
         end
         alias on_csend on_send
-
-        def self.autocorrect_incompatible_with
-          [Layout::HeredocArgumentClosingParenthesis]
-        end
       end
     end
   end

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

@@ -27,6 +27,25 @@ module RuboCop
       #   # bad (contains spaces)
       #   %w[foo\ bar baz\ quux]
       #
+      #   # bad
+      #   [
+      #     ['one', 'One'],
+      #     ['two', 'Two']
+      #   ]
+      #
+      #   # good
+      #   [
+      #     %w[one One],
+      #     %w[two Two]
+      #   ]
+      #
+      #   # good (2d array containing spaces)
+      #   [
+      #     ['one', 'One'],
+      #     ['two', 'Two'],
+      #     ['forty two', 'Forty Two']
+      #   ]
+      #
       # @example EnforcedStyle: brackets
       #   # good
       #   ['foo', 'bar', 'baz']
@@ -36,6 +55,19 @@ module RuboCop
       #
       #   # good (contains spaces)
       #   ['foo bar', 'baz quux']
+      #
+      #   # good
+      #   [
+      #     ['one', 'One'],
+      #     ['two', 'Two']
+      #   ]
+      #
+      #   # bad
+      #   [
+      #     %w[one One],
+      #     %w[two Two]
+      #   ]
+      #
       class WordArray < Base
         include ArrayMinSize
         include ArraySyntax
@@ -53,6 +85,7 @@ module RuboCop
         def on_array(node)
           if bracketed_array_of?(:str, node)
             return if complex_content?(node.values)
+            return if within_2d_array_of_complex_content?(node)
 
             check_bracketed_array(node, 'w')
           elsif node.percent_literal?(:string)
@@ -62,6 +95,14 @@ module RuboCop
 
         private
 
+        def within_2d_array_of_complex_content?(node)
+          return false unless (parent = node.parent)
+
+          parent.array_type? &&
+            parent.values.all?(&:array_type?) &&
+            parent.values.any? { |subarray| complex_content?(subarray.values) }
+        end
+
         def complex_content?(strings, complex_regex: word_regex)
           strings.any? do |s|
             next unless s.str_content
@@ -69,7 +110,7 @@ module RuboCop
             string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
             !string.valid_encoding? ||
               (complex_regex && !complex_regex.match?(string)) ||
-              / /.match?(string)
+              string.include?(' ')
           end
         end
 

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

@@ -33,12 +33,14 @@ module RuboCop
       #   "bar" != foo
       #   42 >= foo
       #   10 < bar
+      #   99 == CONST
       #
       #   # good
       #   foo == 99
       #   foo == "bar"
       #   foo <= 42
       #   bar > 10
+      #   CONST == 99
       #   "#{interpolation}" == foo
       #   /#{interpolation}/ == foo
       #
@@ -92,9 +94,10 @@ module RuboCop
         def on_send(node)
           return unless yoda_compatible_condition?(node)
           return if (equality_only? && non_equality_operator?(node)) ||
-                    file_constant_equal_program_name?(node)
+                    file_constant_equal_program_name?(node) ||
+                    valid_yoda?(node)
 
-          valid_yoda?(node) || add_offense(node) do |corrector|
+          add_offense(node) do |corrector|
             corrector.replace(actual_code_range(node), corrected_code(node))
           end
         end
@@ -119,11 +122,11 @@ module RuboCop
           lhs = node.receiver
           rhs = node.first_argument
 
-          return true if (lhs.literal? && rhs.literal?) ||
-                         (!lhs.literal? && !rhs.literal?) ||
+          return true if (constant_portion?(lhs) && constant_portion?(rhs)) ||
+                         (!constant_portion?(lhs) && !constant_portion?(rhs)) ||
                          interpolation?(lhs)
 
-          enforce_yoda? ? lhs.literal? : rhs.literal?
+          enforce_yoda? ? constant_portion?(lhs) : constant_portion?(rhs)
         end
 
         def message(node)
@@ -137,6 +140,10 @@ module RuboCop
           "#{rhs.source} #{reverse_comparison(node.method_name)} #{lhs.source}"
         end
 
+        def constant_portion?(node)
+          node.literal? || node.const_type?
+        end
+
         def actual_code_range(node)
           range_between(node.loc.expression.begin_pos, node.loc.expression.end_pos)
         end

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

@@ -34,43 +34,55 @@ 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))
 
-          lhs, opr, rhs = zero_length_predicate
+          offense = node.loc.selector.join(node.parent.source_range.end)
+          message = format(ZERO_MSG, current: "#{length_method}.zero?")
+
+          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 +90,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

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:
@@ -47,6 +33,35 @@ module RuboCop
         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
+
+        validate_config
+      end
+
       def autocorrect?
         @options[:autocorrect]
       end
@@ -62,7 +77,7 @@ 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
@@ -72,14 +87,15 @@ module RuboCop
         on_duty = roundup_relevant_cops(processed_source.file_path)
 
         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)
@@ -94,21 +110,6 @@ 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
         Digest::SHA1.hexdigest(keys.join)
@@ -116,12 +117,12 @@ module RuboCop
 
       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
 
@@ -149,9 +150,9 @@ 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>]
@@ -175,18 +176,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