rubocop 0.93.1 → 1.79.2

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for accessing the first element of `String#unpack`
+      # Checks for accessing the first element of `String#unpack`
       # which can be replaced with the shorter method `unpack1`.
       #
       # @example
@@ -19,38 +19,39 @@ module RuboCop
       #
       class UnpackFirst < Base
         extend AutoCorrector
+        extend TargetRubyVersion
 
-        MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
-          '`%<receiver>s.unpack(%<format>s)%<method>s`.'
+        minimum_target_ruby_version 2.4
+
+        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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for variable interpolation (like "#@ivar").
+      # Checks for variable interpolation (like "#@ivar").
       #
       # @example
       #   # bad
@@ -19,8 +19,7 @@ module RuboCop
         include Interpolation
         extend AutoCorrector
 
-        MSG = 'Replace interpolated variable `%<variable>s` ' \
-              'with expression `#{%<variable>s}`.'
+        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/when_then.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for `when;` uses in `case` expressions.
+      # Checks for `when;` uses in `case` expressions.
       #
       # @example
       #   # bad
@@ -20,12 +20,14 @@ module RuboCop
       class WhenThen < Base
         extend AutoCorrector
 
-        MSG = 'Do not use `when x;`. Use `when x then` instead.'
+        MSG = 'Do not use `when %<expression>s;`. Use `when %<expression>s then` instead.'
 
         def on_when(node)
           return if node.multiline? || node.then? || !node.body
 
-          add_offense(node.loc.begin) do |corrector|
+          message = format(MSG, expression: node.conditions.map(&:source).join(', '))
+
+          add_offense(node.loc.begin, message: message) do |corrector|
             corrector.replace(node.loc.begin, ' then')
           end
         end

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
@@ -24,20 +23,25 @@ module RuboCop
       #
       #   # good
       #   x += 1 until x > 10
+      #
+      #   # bad
+      #   x += 100 while x < 500 # a long comment that makes code too long if it were a single line
+      #
+      #   # good
+      #   while x < 500 # a long comment that makes code too long if it were a single line
+      #     x += 100
+      #   end
       class WhileUntilModifier < Base
         include StatementModifier
         extend AutoCorrector
 
-        MSG = 'Favor modifier `%<keyword>s` usage when ' \
-              'having a single-line body.'
+        MSG = 'Favor modifier `%<keyword>s` usage when having a single-line body.'
 
         def on_while(node)
-          return unless node.multiline? && single_line_as_modifier?(node)
+          return unless single_line_as_modifier?(node)
 
           add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
-            oneline = "#{node.body.source} #{node.keyword} #{node.condition.source}"
-
-            corrector.replace(node, oneline)
+            corrector.replace(node, to_modifier_form(node))
           end
         end
         alias on_until on_while

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,30 +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)
+              (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,30 +80,30 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Reverse the order of the operands `%<source>s`.'
-
-        REVERSE_COMPARISON = {
-          '<' => '>',
-          '<=' => '>=',
-          '>' => '<',
-          '>=' => '<='
-        }.freeze
-
+        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
+        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
           (send #source_file_path_constant? {:== :!=} (gvar #program_name?))
         PATTERN
 
         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
@@ -89,30 +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)
+          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)
@@ -125,10 +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

@@ -0,0 +1,92 @@
+# 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: ['*', '+', '&', '|', '^'] (default)
+      #   # bad
+      #   10 * y
+      #   1 + x
+      #   1 & z
+      #   1 | x
+      #   1 ^ x
+      #   1 + CONST
+      #
+      #   # good
+      #   y * 10
+      #   x + 1
+      #   z & 1
+      #   x | 1
+      #   x ^ 1
+      #   CONST + 1
+      #   60 * 24
+      #
+      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)
+          return unless node.arguments?
+
+          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.type?(:numeric, :const)
+        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