rubocop 1.44.1 → 1.78.0

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

@@ -6,12 +6,13 @@ module RuboCop
       # Checks for trailing comma in array literals.
       # The configuration options are:
       #
-      # * `consistent_comma`: Requires a comma after the
-      # last item of all non-empty, multiline array literals.
-      # * `comma`: Requires a comma after last item in an array,
-      # but only when each item is on its own line.
-      # * `no_comma`: Does not require a comma after the
-      # last item in an array
+      # * `consistent_comma`: Requires a comma after the last item of all non-empty, multiline array
+      # literals.
+      # * `comma`: Requires a comma after the last item in an array, but only when each item is on
+      # its own line.
+      # * `diff_comma`: Requires a comma after the last item in an array, but only when that item is
+      # followed by an immediate newline, even if there is an inline comment on the same line.
+      # * `no_comma`: Does not require a comma after the last item in an array
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
@@ -37,6 +38,14 @@ module RuboCop
       #     2,
       #   ]
       #
+      #   # bad
+      #   a = [1, 2,
+      #        3, 4]
+      #
+      #   # good
+      #   a = [1, 2,
+      #        3, 4,]
+      #
       # @example EnforcedStyleForMultiline: comma
       #   # bad
       #   a = [1, 2,]
@@ -72,6 +81,38 @@ module RuboCop
       #     2,
       #   ]
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #   # bad
+      #   a = [1, 2,]
+      #
+      #   # good
+      #   a = [1, 2]
+      #
+      #   # good
+      #   a = [
+      #     1, 2,
+      #     3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1, 2, 3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1,
+      #     2,
+      #   ]
+      #
+      #   # bad
+      #   a = [1, 2,
+      #        3, 4,]
+      #
+      #   # good
+      #   a = [1, 2,
+      #        3, 4]
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #   # bad
       #   a = [1, 2,]

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

@@ -97,7 +97,7 @@ module RuboCop
           pipes = tokens.select { |token| token.type == :tPIPE }
           begin_pos, end_pos = pipes.map { |pipe| tokens.index(pipe) }
 
-          tokens[begin_pos + 1..end_pos - 1]
+          tokens[(begin_pos + 1)..(end_pos - 1)]
         end
       end
     end

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

@@ -6,12 +6,13 @@ module RuboCop
       # Checks for trailing comma in hash literals.
       # The configuration options are:
       #
-      # * `consistent_comma`: Requires a comma after the
-      # last item of all non-empty, multiline hash literals.
-      # * `comma`: Requires a comma after the last item in a hash,
-      # but only when each item is on its own line.
-      # * `no_comma`: Does not require a comma after the
-      # last item in a hash
+      # * `consistent_comma`: Requires a comma after the last item of all non-empty, multiline hash
+      # literals.
+      # * `comma`: Requires a comma after the last item in a hash, but only when each item is on its
+      # own line.
+      # * `diff_comma`: Requires a comma after the last item in a hash, but only when that item is
+      # followed by an immediate newline, even if there is an inline comment on the same line.
+      # * `no_comma`: Does not require a comma after the last item in a hash
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #
@@ -38,6 +39,14 @@ module RuboCop
       #     bar: 2,
       #   }
       #
+      #   # bad
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4 }
+      #
+      #   # good
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4, }
+      #
       # @example EnforcedStyleForMultiline: comma
       #
       #   # bad
@@ -74,6 +83,39 @@ module RuboCop
       #     bar: 2,
       #   }
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #
+      #   # bad
+      #   a = { foo: 1, bar: 2, }
+      #
+      #   # good
+      #   a = { foo: 1, bar: 2 }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2,
+      #     qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2, qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1,
+      #     bar: 2,
+      #   }
+      #
+      #   # bad
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4, }
+      #
+      #   # good
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4 }
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #
       #   # bad

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

@@ -94,7 +94,7 @@ module RuboCop
         end
 
         def unneeded_ranges(node)
-          node.masgn_type? ? (mlhs_node, = *node) : mlhs_node = node
+          mlhs_node = node.masgn_type? ? node.lhs : node
           variables = *mlhs_node
 
           main_offense = main_node_offense(node)
@@ -106,15 +106,15 @@ module RuboCop
         end
 
         def main_node_offense(node)
-          node.masgn_type? ? (mlhs_node, right = *node) : mlhs_node = node
-
+          mlhs_node = node.masgn_type? ? node.lhs : node
           variables = *mlhs_node
+
           first_offense = find_first_offense(variables)
 
           return unless first_offense
 
           if unused_variables_only?(first_offense, variables)
-            return unused_range(node.type, mlhs_node, right)
+            return unused_range(node.type, mlhs_node, node.rhs)
           end
 
           return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)
@@ -144,7 +144,7 @@ module RuboCop
         end
 
         def range_for_parentheses(offense, left)
-          range_between(offense.source_range.begin_pos - 1, left.loc.expression.end_pos - 1)
+          range_between(offense.source_range.begin_pos - 1, left.source_range.end_pos - 1)
         end
       end
     end

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

@@ -113,7 +113,7 @@ module RuboCop
         private
 
         def in_module_or_instance_eval?(node)
-          node.each_ancestor(:block, :class, :sclass, :module).each do |pnode|
+          node.each_ancestor(:any_block, :class, :sclass, :module).each do |pnode|
             case pnode.type
             when :class, :sclass
               return false
@@ -179,7 +179,7 @@ module RuboCop
         end
 
         def looks_like_trivial_reader?(node)
-          !node.arguments? && node.body && node.body.ivar_type?
+          !node.arguments? && node.body&.ivar_type?
         end
 
         def trivial_writer?(node)
@@ -238,7 +238,7 @@ module RuboCop
 
           indent = ' ' * node.loc.column
           corrector.replace(
-            node.source_range,
+            node,
             ['class << self',
              "#{indent}  #{accessor(kind, node.method_name)}",
              "#{indent}end"].join("\n")

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

@@ -8,6 +8,7 @@ module RuboCop
       # to read and understand.
       #
       # This cop supports two styles:
+      #
       # - `forbid_mixed_logical_operators` (default)
       # - `forbid_logical_operators`
       #

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

@@ -23,38 +23,35 @@ module RuboCop
 
         minimum_target_ruby_version 2.4
 
-        MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of ' \
-              '`%<receiver>s.unpack(%<format>s)%<method>s`.'
+        MSG = 'Use `unpack1(%<format>s)` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[first [] slice at].freeze
 
         # @!method unpack_and_first_element?(node)
         def_node_matcher :unpack_and_first_element?, <<~PATTERN
           {
-            (send $(send (...) :unpack $(...)) :first)
-            (send $(send (...) :unpack $(...)) {:[] :slice :at} (int 0))
+            (call $(call (...) :unpack $(...)) :first)
+            (call $(call (...) :unpack $(...)) {:[] :slice :at} (int 0))
           }
         PATTERN
 
         def on_send(node)
           unpack_and_first_element?(node) do |unpack_call, unpack_arg|
-            range = first_element_range(node, unpack_call)
-            message = format(MSG,
-                             receiver: unpack_call.receiver.source,
-                             format: unpack_arg.source,
-                             method: range.source)
-            add_offense(node, message: message) do |corrector|
-              corrector.remove(first_element_range(node, unpack_call))
+            first_element_range = first_element_range(node, unpack_call)
+            offense_range = unpack_call.loc.selector.join(node.source_range.end)
+            message = format(MSG, format: unpack_arg.source, current: offense_range.source)
+
+            add_offense(offense_range, message: message) do |corrector|
+              corrector.remove(first_element_range)
               corrector.replace(unpack_call.loc.selector, 'unpack1')
             end
           end
         end
+        alias on_csend on_send
 
         private
 
         def first_element_range(node, unpack_call)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    unpack_call.loc.expression.end_pos,
-                                    node.loc.expression.end_pos)
+          unpack_call.source_range.end.join(node.source_range.end)
         end
       end
     end

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

@@ -19,8 +19,7 @@ module RuboCop
         include Interpolation
         extend AutoCorrector
 
-        MSG = 'Replace interpolated variable `%<variable>s` ' \
-              'with expression `#{%<variable>s}`.' # rubocop:disable Lint/InterpolationCheck
+        MSG = 'Replace interpolated variable `%<variable>s` with expression `#{%<variable>s}`.'
 
         def on_node_with_interpolations(node)
           var_nodes(node.children).each do |var_node|

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

@@ -17,8 +17,6 @@ module RuboCop
       #     do_something(x.pop)
       #   end
       #
-      # @example
-      #
       #   # bad
       #   until x.empty? do
       #     do_something(x.pop)

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

@@ -16,7 +16,6 @@ module RuboCop
       #   # good
       #   x += 1 while x < 10
       #
-      # @example
       #   # bad
       #   until x > 10
       #     x += 1
@@ -25,7 +24,6 @@ module RuboCop
       #   # good
       #   x += 1 until x > 10
       #
-      # @example
       #   # bad
       #   x += 100 while x < 500 # a long comment that makes code too long if it were a single line
       #

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

@@ -82,10 +82,19 @@ module RuboCop
           attr_accessor :largest_brackets
         end
 
+        def on_new_investigation
+          super
+
+          # Prevent O(n2) checks (checking the entire matrix once for each child array) by caching
+          @matrix_of_complex_content_cache = Hash.new do |cache, node|
+            cache[node] = matrix_of_complex_content?(node)
+          end
+        end
+
         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)
+            return if within_matrix_of_complex_content?(node)
 
             check_bracketed_array(node, 'w')
           elsif node.percent_literal?(:string)
@@ -95,12 +104,15 @@ module RuboCop
 
         private
 
-        def within_2d_array_of_complex_content?(node)
+        def within_matrix_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) }
+          parent.array_type? && @matrix_of_complex_content_cache[parent]
+        end
+
+        def matrix_of_complex_content?(array)
+          array.values.all?(&:array_type?) &&
+            array.values.any? { |subarray| complex_content?(subarray.values) }
         end
 
         def complex_content?(strings, complex_regex: word_regex)
@@ -110,7 +122,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/yaml_file_read.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the use of `YAML.load`, `YAML.safe_load`, and `YAML.parse` with
+      # `File.read` argument.
+      #
+      # NOTE: `YAML.safe_load_file` was introduced in Ruby 3.0.
+      #
+      # @example
+      #
+      #   # bad
+      #   YAML.load(File.read(path))
+      #   YAML.parse(File.read(path))
+      #
+      #   # good
+      #   YAML.load_file(path)
+      #   YAML.parse_file(path)
+      #
+      #   # bad
+      #   YAML.safe_load(File.read(path)) # Ruby 3.0 and newer
+      #
+      #   # good
+      #   YAML.safe_load_file(path)       # Ruby 3.0 and newer
+      #
+      class YAMLFileRead < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead.'
+        RESTRICT_ON_SEND = %i[load safe_load parse].freeze
+
+        # @!method yaml_file_read?(node)
+        def_node_matcher :yaml_file_read?, <<~PATTERN
+          (send
+            (const {cbase nil?} :YAML) _
+            (send
+              (const {cbase nil?} :File) :read $_) $...)
+        PATTERN
+
+        def on_send(node)
+          return if node.method?(:safe_load) && target_ruby_version <= 2.7
+          return unless (file_path, rest_arguments = yaml_file_read?(node))
+
+          range = offense_range(node)
+          rest_arguments = if rest_arguments.empty?
+                             ''
+                           else
+                             ", #{rest_arguments.map(&:source).join(', ')}"
+                           end
+          prefer = "#{node.method_name}_file(#{file_path.source}#{rest_arguments})"
+
+          add_offense(range, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(range, prefer)
+          end
+        end
+
+        private
+
+        def offense_range(node)
+          node.loc.selector.join(node.source_range.end)
+        end
+      end
+    end
+  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
       #
@@ -83,6 +85,12 @@ module RuboCop
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
         PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
         RESTRICT_ON_SEND = RuboCop::AST::Node::COMPARISON_OPERATORS
+        ENFORCE_YODA_STYLES = %i[
+          require_for_all_comparison_operators require_for_equality_operators_only
+        ].freeze
+        EQUALITY_ONLY_STYLES = %i[
+          forbid_for_equality_operators_only require_for_equality_operators_only
+        ].freeze
 
         # @!method file_constant_equal_program_name?(node)
         def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
@@ -92,9 +100,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
@@ -102,29 +111,29 @@ module RuboCop
         private
 
         def enforce_yoda?
-          style == :require_for_all_comparison_operators ||
-            style == :require_for_equality_operators_only
+          ENFORCE_YODA_STYLES.include?(style)
         end
 
         def equality_only?
-          style == :forbid_for_equality_operators_only ||
-            style == :require_for_equality_operators_only
+          EQUALITY_ONLY_STYLES.include?(style)
         end
 
         def yoda_compatible_condition?(node)
           node.comparison_method? && !noncommutative_operator?(node)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def valid_yoda?(node)
-          lhs = node.receiver
-          rhs = node.first_argument
+          return true unless (rhs = node.first_argument)
 
-          return true if (lhs.literal? && rhs.literal?) ||
-                         (!lhs.literal? && !rhs.literal?) ||
+          lhs = node.receiver
+          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
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def message(node)
           format(MSG, source: node.source)
@@ -137,8 +146,12 @@ 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)
+          range_between(node.source_range.begin_pos, node.source_range.end_pos)
         end
 
         def reverse_comparison(operator)

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

@@ -19,20 +19,23 @@ module RuboCop
       #   differently on different classes, and are not guaranteed to
       #   have the same result if reversed.
       #
-      # @example SupportedOperators: ['*', '+', '&'']
+      # @example SupportedOperators: ['*', '+', '&', '|', '^'] (default)
       #   # bad
-      #   1 + x
       #   10 * y
+      #   1 + x
       #   1 & z
+      #   1 | x
+      #   1 ^ x
+      #   1 + CONST
       #
       #   # good
-      #   60 * 24
-      #   x + 1
       #   y * 10
+      #   x + 1
       #   z & 1
-      #
-      #   # good
-      #   1 | x
+      #   x | 1
+      #   x ^ 1
+      #   CONST + 1
+      #   60 * 24
       #
       class YodaExpression < Base
         extend AutoCorrector
@@ -47,11 +50,11 @@ module RuboCop
 
         def on_send(node)
           return unless supported_operators.include?(node.method_name.to_s)
+          return unless node.arguments?
 
           lhs = node.receiver
           rhs = node.first_argument
-          return if !lhs.numeric_type? || rhs.numeric_type?
-
+          return unless yoda_expression_constant?(lhs, rhs)
           return if offended_ancestor?(node)
 
           message = format(MSG, source: rhs.source)
@@ -64,6 +67,14 @@ module RuboCop
 
         private
 
+        def yoda_expression_constant?(lhs, rhs)
+          constant_portion?(lhs) && !constant_portion?(rhs)
+        end
+
+        def constant_portion?(node)
+          node.type?(:numeric, :const)
+        end
+
         def supported_operators
           Array(cop_config['SupportedOperators'])
         end