rubocop 1.18.0 → 1.56.0

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

@@ -3,12 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # This cop can check for array literals made up of word-like
+      # Checks for array literals made up of word-like
       # strings, that are not using the %w() syntax.
       #
       # Alternatively, it can check for uses of the %w() syntax, in projects
       # which do not want to include that syntax.
       #
+      # NOTE: When using the `percent` style, %w() arrays containing a space
+      # will be registered as offenses.
+      #
       # Configuration option: MinSize
       # If set, arrays with fewer elements than this value will not trigger the
       # cop. For example, a `MinSize` of `3` will not enforce a style on an
@@ -21,12 +24,50 @@ module RuboCop
       #   # bad
       #   ['foo', 'bar', 'baz']
       #
+      #   # 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']
       #
       #   # bad
       #   %w[foo bar baz]
+      #
+      #   # 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
@@ -35,15 +76,25 @@ module RuboCop
         extend AutoCorrector
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
-        ARRAY_MSG = 'Use `[]` for an array of words.'
+        ARRAY_MSG = 'Use %<prefer>s for an array of words.'
 
         class << self
           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_matrix_of_complex_content?(node)
 
             check_bracketed_array(node, 'w')
           elsif node.percent_literal?(:string)
@@ -53,29 +104,50 @@ module RuboCop
 
         private
 
-        def complex_content?(strings)
+        def within_matrix_of_complex_content?(node)
+          return false unless (parent = node.parent)
+
+          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)
           strings.any? do |s|
+            next unless s.str_content
+
             string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
-            !string.valid_encoding? || !word_regex.match?(string) || / /.match?(string)
+            !string.valid_encoding? ||
+              (complex_regex && !complex_regex.match?(string)) ||
+              string.include?(' ')
           end
         end
 
+        def invalid_percent_array_contents?(node)
+          # Disallow %w() arrays that contain invalid encoding or spaces
+          complex_content?(node.values, complex_regex: false)
+        end
+
         def word_regex
           Regexp.new(cop_config['WordRegex'])
         end
 
-        def correct_bracketed(corrector, node)
+        def build_bracketed_array(node)
+          return '[]' if node.children.empty?
+
           words = node.children.map do |word|
             if word.dstr_type?
               string_literal = to_string_literal(word.source)
 
-              trim_string_interporation_escape_character(string_literal)
+              trim_string_interpolation_escape_character(string_literal)
             else
               to_string_literal(word.children[0])
             end
           end
-
-          corrector.replace(node, "[#{words.join(', ')}]")
+          build_bracketed_array_with_appropriate_whitespace(elements: words, node: node)
         end
       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

@@ -3,22 +3,44 @@
 module RuboCop
   module Cop
     module Style
-      # This cop can either enforce or forbid Yoda conditions,
+      # Enforces or forbids Yoda conditions,
       # i.e. comparison operations where the order of expression is reversed.
       # eg. `5 == x`
       #
+      # @safety
+      #   This cop is unsafe because comparison operators can be defined
+      #   differently on different classes, and are not guaranteed to
+      #   have the same result if reversed.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class MyKlass
+      #     def ==(other)
+      #       true
+      #     end
+      #   end
+      #
+      #   obj = MyKlass.new
+      #   obj == 'string'   #=> true
+      #   'string' == obj   #=> false
+      #   ----
+      #
       # @example EnforcedStyle: forbid_for_all_comparison_operators (default)
       #   # bad
       #   99 == foo
       #   "bar" != foo
       #   42 >= foo
       #   10 < bar
+      #   99 == CONST
       #
       #   # good
       #   foo == 99
       #   foo == "bar"
       #   foo <= 42
       #   bar > 10
+      #   CONST == 99
       #   "#{interpolation}" == foo
       #   /#{interpolation}/ == foo
       #
@@ -58,14 +80,11 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Reverse the order of the operands `%<source>s`.'
-
         REVERSE_COMPARISON = { '<' => '>', '<=' => '>=', '>' => '<', '>=' => '<=' }.freeze
-
         EQUALITY_OPERATORS = %i[== !=].freeze
-
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
-
         PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
+        RESTRICT_ON_SEND = RuboCop::AST::Node::COMPARISON_OPERATORS
 
         # @!method file_constant_equal_program_name?(node)
         def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
@@ -74,10 +93,11 @@ 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)
+          return if (equality_only? && non_equality_operator?(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
@@ -98,16 +118,18 @@ module RuboCop
           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)
@@ -120,8 +142,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

@@ -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,20 @@
 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
+      #   has an `empty?` method that is defined in terms of `length`. If there
+      #   is a non-standard class that redefines `length` or `empty?`, the cop
+      #   may register a false positive.
       #
       # @example
       #   # bad
@@ -28,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?")
+
+          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_predicate
+          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
@@ -72,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
@@ -111,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