rubocop 1.19.0 → 1.23.0

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

@@ -14,8 +14,25 @@ module RuboCop
       # positives. Luckily, there is no harm in freezing an already
       # frozen object.
       #
+      # From Ruby 3.0, this cop honours the magic comment
+      # 'shareable_constant_value'. When this magic comment is set to any
+      # acceptable value other than none, it will suppress the offenses
+      # raised by this cop. It enforces frozen state.
+      #
       # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
       #
+      # NOTE: From Ruby 3.0, interpolated strings are not frozen when
+      # `# frozen-string-literal: true` is used, so this cop enforces explicit
+      # freezing for such strings.
+      #
+      # NOTE: From Ruby 3.0, this cop allows explicit freezing of constants when
+      # the `shareable_constant_value` directive is used.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe since any mutations on objects that
+      #   are made frozen will change from being accepted to raising `FrozenError`,
+      #   and will need to be manually refactored.
+      #
       # @example EnforcedStyle: literals (default)
       #   # bad
       #   CONST = [1, 2, 3]
@@ -52,7 +69,55 @@ module RuboCop
       #       puts 1
       #     end
       #   end.freeze
+      #
+      # @example
+      #   # Magic comment - shareable_constant_value: literal
+      #
+      #   # bad
+      #   CONST = [1, 2, 3]
+      #
+      #   # good
+      #   # shareable_constant_value: literal
+      #   CONST = [1, 2, 3]
+      #
       class MutableConstant < Base
+        # Handles magic comment shareable_constant_value with O(n ^ 2) complexity
+        # n - number of lines in the source
+        # Iterates over all lines before a CONSTANT
+        # until it reaches shareable_constant_value
+        module ShareableConstantValue
+          module_function
+
+          def recent_shareable_value?(node)
+            shareable_constant_comment = magic_comment_in_scope node
+            return false if shareable_constant_comment.nil?
+
+            shareable_constant_value = MagicComment.parse(shareable_constant_comment)
+                                                   .shareable_constant_value
+            shareable_constant_value_enabled? shareable_constant_value
+          end
+
+          # Identifies the most recent magic comment with valid shareable constant values
+          # that's in scope for this node
+          def magic_comment_in_scope(node)
+            processed_source_till_node(node).reverse_each.find do |line|
+              MagicComment.parse(line).valid_shareable_constant_value?
+            end
+          end
+
+          private
+
+          def processed_source_till_node(node)
+            processed_source.lines[0..(node.last_line - 1)]
+          end
+
+          def shareable_constant_value_enabled?(value)
+            %w[literal experimental_everything experimental_copy].include? value
+          end
+        end
+        private_constant :ShareableConstantValue
+
+        include ShareableConstantValue
         include FrozenStringLiteral
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -85,18 +150,18 @@ module RuboCop
           return if immutable_literal?(value)
           return if operation_produces_immutable_object?(value)
           return if frozen_string_literal?(value)
+          return if shareable_constant_value?(value)
 
           add_offense(value) { |corrector| autocorrect(corrector, value) }
         end
 
         def check(value)
           range_enclosed_in_parentheses = range_enclosed_in_parentheses?(value)
-
           return unless mutable_literal?(value) ||
-                        target_ruby_version <= 2.7 && range_enclosed_in_parentheses
+                        (target_ruby_version <= 2.7 && range_enclosed_in_parentheses)
 
-          return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
-                    frozen_string_literals_enabled?
+          return if frozen_string_literal?(value)
+          return if shareable_constant_value?(value)
 
           add_offense(value) { |corrector| autocorrect(corrector, value) }
         end
@@ -126,8 +191,10 @@ module RuboCop
           frozen_regexp_or_range_literals?(node) || node.immutable_literal?
         end
 
-        def frozen_string_literal?(node)
-          FROZEN_STRING_LITERAL_TYPES.include?(node.type) && frozen_string_literals_enabled?
+        def shareable_constant_value?(node)
+          return false if target_ruby_version < 3.0
+
+          recent_shareable_value? node
         end
 
         def frozen_regexp_or_range_literals?(node)

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

@@ -90,7 +90,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :prefix && node.modifier_form? || style == :postfix && !node.modifier_form?
+          (style == :prefix && node.modifier_form?) || (style == :postfix && !node.modifier_form?)
         end
       end
     end

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

@@ -80,7 +80,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :prefix && node.modifier_form? || style == :postfix && !node.modifier_form?
+          (style == :prefix && node.modifier_form?) || (style == :postfix && !node.modifier_form?)
         end
       end
     end

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

@@ -63,7 +63,7 @@ module RuboCop
 
         def on_send(node)
           return if ignored_node?(node) ||
-                    !include_semantic_changes? && nil_comparison_style == 'comparison'
+                    (!include_semantic_changes? && nil_comparison_style == 'comparison')
           return unless register_offense?(node)
 
           message = message(node)
@@ -87,7 +87,7 @@ module RuboCop
 
         def register_offense?(node)
           not_equal_to_nil?(node) ||
-            include_semantic_changes? && (not_and_nil_check?(node) || unless_and_nil_check?(node))
+            (include_semantic_changes? && (not_and_nil_check?(node) || unless_and_nil_check?(node)))
         end
 
         def autocorrect(corrector, node)

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

@@ -53,8 +53,8 @@ module RuboCop
 
         def requires_parens?(child)
           child.and_type? || child.or_type? ||
-            child.send_type? && child.binary_operation? ||
-            child.if_type? && child.ternary?
+            (child.send_type? && child.binary_operation?) ||
+            (child.if_type? && child.ternary?)
         end
 
         def correct_opposite_method(corrector, range, child)

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for numbered parameters.
+      #
+      # It can either restrict the use of numbered parameters to
+      # single-lined blocks, or disallow completely numbered parameters.
+      #
+      # @example EnforcedStyle: allow_single_line (default)
+      #   # bad
+      #   collection.each do
+      #     puts _1
+      #   end
+      #
+      #   # good
+      #   collection.each { puts _1 }
+      #
+      # @example EnforcedStyle: disallow
+      #   # bad
+      #   collection.each { puts _1 }
+      #
+      #   # good
+      #   collection.each { |item| puts item }
+      #
+      class NumberedParameters < Base
+        include ConfigurableEnforcedStyle
+        extend TargetRubyVersion
+
+        MSG_DISALLOW = 'Avoid using numbered parameters.'
+        MSG_MULTI_LINE = 'Avoid using numbered parameters for multi-line blocks.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_numblock(node)
+          if style == :disallow
+            add_offense(node, message: MSG_DISALLOW)
+          elsif node.multiline?
+            add_offense(node, message: MSG_MULTI_LINE)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop detects use of an excessive amount of numbered parameters in a
+      # single block. Having too many numbered parameters can make code too
+      # cryptic and hard to read.
+      #
+      # The cop defaults to registering an offense if there is more than 1 numbered
+      # parameter but this maximum can be configured by setting `Max`.
+      #
+      # @example Max: 1 (default)
+      #   # bad
+      #   foo { _1.call(_2, _3, _4) }
+      #
+      #   # good
+      #   foo { do_something(_1) }
+      class NumberedParametersLimit < Base
+        extend TargetRubyVersion
+        extend ExcludeLimit
+
+        DEFAULT_MAX_VALUE = 1
+
+        minimum_target_ruby_version 2.7
+        exclude_limit 'Max'
+
+        MSG = 'Avoid using more than %<max>i numbered %<parameter>s; %<count>i detected.'
+
+        def on_numblock(node)
+          _send_node, param_count, * = *node
+          return if param_count <= max_count
+
+          parameter = max_count > 1 ? 'parameters' : 'parameter'
+          message = format(MSG, max: max_count, parameter: parameter, count: param_count)
+          add_offense(node, message: message) { self.max = param_count }
+        end
+
+        private
+
+        def max_count
+          max = cop_config.fetch('Max', DEFAULT_MAX_VALUE)
+
+          # Ruby does not allow more than 9 numbered parameters
+          [max, 9].min
+        end
+      end
+    end
+  end
+end

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

@@ -58,18 +58,17 @@ module RuboCop
 
           case int
           when /^\d+$/
-            return unless (self.min_digits = int.size + 1)
-
-            register_offense(node)
+            register_offense(node) { self.min_digits = int.size + 1 }
           when /\d{4}/, short_group_regex
-            return unless (self.config_to_allow_offenses = { 'Enabled' => false })
-
-            register_offense(node)
+            register_offense(node) { self.config_to_allow_offenses = { 'Enabled' => false } }
           end
         end
 
-        def register_offense(node)
-          add_offense(node) { |corrector| corrector.replace(node, format_number(node)) }
+        def register_offense(node, &_block)
+          add_offense(node) do |corrector|
+            yield
+            corrector.replace(node, format_number(node))
+          end
         end
 
         def short_group_regex

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

@@ -16,6 +16,11 @@ module RuboCop
       # populated with objects which can be compared with integers, but are
       # not themselves `Integer` polymorphic.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   defines the predicates or can be compared to a number, which may lead
+      #   to a false positive for non-standard classes.
+      #
       # @example EnforcedStyle: predicate (default)
       #   # bad
       #

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop flags uses of OpenStruct, as it is now officially discouraged
+      # to be used for performance, version compatibility, and potential security issues.
+      #
+      # @safety
+      #
+      #   Note that this cop may flag false positives; for instance, the following legal
+      #   use of a hand-rolled `OpenStruct` type would be considered an offense:
+      #
+      #   ```
+      #   module MyNamespace
+      #     class OpenStruct # not the OpenStruct we're looking for
+      #     end
+      #
+      #     def new_struct
+      #       OpenStruct.new # resolves to MyNamespace::OpenStruct
+      #     end
+      #   end
+      #   ```
+      #
+      # @example
+      #
+      #   # bad
+      #   point = OpenStruct.new(x: 0, y: 1)
+      #
+      #   # good
+      #   Point = Struct.new(:x, :y)
+      #   point = Point.new(0, 1)
+      #
+      #   # also good
+      #   point = { x: 0, y: 1 }
+      #
+      #   # bad
+      #   test_double = OpenStruct.new(a: 'b')
+      #
+      #   # good (assumes test using rspec-mocks)
+      #   test_double = double
+      #   allow(test_double).to receive(:a).and_return('b')
+      #
+      class OpenStructUse < Base
+        MSG = 'Avoid using `OpenStruct`; use `Struct`, `Hash`, a class or test doubles instead.'
+
+        # @!method uses_open_struct?(node)
+        def_node_matcher :uses_open_struct?, <<-PATTERN
+          (const {nil? (cbase)} :OpenStruct)
+        PATTERN
+
+        def on_const(node)
+          return unless uses_open_struct?(node)
+          return if custom_class_or_module_definition?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def custom_class_or_module_definition?(node)
+          parent = node.parent
+
+          (parent.class_type? || parent.module_type?) && node.left_siblings.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,10 @@ module RuboCop
       # This cop checks for optional arguments to methods
       # that do not come at the end of the argument list.
       #
+      # @safety
+      #   This cop is unsafe because changing a method signature will
+      #   implicitly change behaviour.
+      #
       # @example
       #   # bad
       #   def foo(a = 1, b, c)

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

@@ -7,6 +7,10 @@ module RuboCop
       # boolean arguments when defining methods. `respond_to_missing?` method is allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
+      # @safety
+      #   This cop is unsafe because changing a method signature will
+      #   implicitly change behaviour.
+      #
       # @example
       #   # bad
       #   def some_method(bar = false)
@@ -33,8 +37,8 @@ module RuboCop
       class OptionalBooleanParameter < Base
         include AllowedMethods
 
-        MSG = 'Use keyword arguments when defining method with boolean argument.'
-        BOOLEAN_TYPES = %i[true false].freeze
+        MSG = 'Prefer keyword arguments for arguments with a boolean default value; ' \
+              'use `%<replacement>s` instead of `%<original>s`.'
 
         def on_def(node)
           return if allowed_method?(node.method_name)
@@ -42,11 +46,17 @@ module RuboCop
           node.arguments.each do |arg|
             next unless arg.optarg_type?
 
-            _name, value = *arg
-            add_offense(arg) if BOOLEAN_TYPES.include?(value.type)
+            add_offense(arg, message: format_message(arg)) if arg.default_value.boolean_type?
           end
         end
         alias on_defs on_def
+
+        private
+
+        def format_message(argument)
+          source = argument.source
+          format(MSG, original: source, replacement: source.sub(/\s+=/, ':'))
+        end
       end
     end
   end

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

@@ -153,7 +153,7 @@ module RuboCop
 
           def dependency?(lhs, rhs)
             uses_var?(rhs, var_name(lhs)) ||
-              lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs)
+              (lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs))
           end
 
           # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`.

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

@@ -56,6 +56,7 @@ module RuboCop
       class ParenthesesAroundCondition < Base
         include SafeAssignment
         include Parentheses
+        include RangeHelp
         extend AutoCorrector
 
         def on_if(node)
@@ -73,13 +74,14 @@ module RuboCop
 
         # @!method control_op_condition(node)
         def_node_matcher :control_op_condition, <<~PATTERN
-          (begin $_ ...)
+          (begin $_ $...)
         PATTERN
 
         def process_control_op(node)
           cond = node.condition
 
-          control_op_condition(cond) do |first_child|
+          control_op_condition(cond) do |first_child, rest_children|
+            return if semicolon_separated_expressions?(first_child, rest_children)
             return if modifier_op?(first_child)
             return if parens_allowed?(cond)
 
@@ -90,6 +92,14 @@ module RuboCop
           end
         end
 
+        def semicolon_separated_expressions?(first_exp, rest_exps)
+          return false unless (second_exp = rest_exps.first)
+
+          range = range_between(first_exp.source_range.end_pos, second_exp.source_range.begin_pos)
+
+          range.source.include?(';')
+        end
+
         def modifier_op?(node)
           return false if node.if_type? && node.ternary?
           return true if node.rescue_type?

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

@@ -53,8 +53,8 @@ module RuboCop
         end
 
         def correct_literal_style?(node)
-          style == :lower_case_q && type(node) == '%q' ||
-            style == :upper_case_q && type(node) == '%Q'
+          (style == :lower_case_q && type(node) == '%q') ||
+            (style == :upper_case_q && type(node) == '%Q')
         end
 
         def message(_range)

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

@@ -3,10 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # This cop (by default) checks for uses of methods Hash#has_key? and
-      # Hash#has_value? where it enforces Hash#key? and Hash#value?
-      # It is configurable to enforce the inverse, using `verbose` method
-      # names also.
+      # This cop checks for uses of methods `Hash#has_key?` and
+      # `Hash#has_value?`, and suggests using `Hash#key?` and `Hash#value?` instead.
+      #
+      # It is configurable to enforce the verbose method names, by using the
+      # `EnforcedStyle: verbose` configuration.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or responds to the replacement methods.
       #
       # @example EnforcedStyle: short (default)
       #  # bad

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks if the quotes used for quoted symbols match the configured defaults.
-      # By default uses the same configuration as `Style/StringLiterals`.
+      # By default uses the same configuration as `Style/StringLiterals`; if that
+      # cop is not enabled, the default `EnforcedStyle` is `single_quotes`.
       #
       # String interpolation is always kept in double quotes.
       #
@@ -45,7 +46,7 @@ module RuboCop
 
           message = style == :single_quotes ? MSG_SINGLE : MSG_DOUBLE
 
-          if wrong_quotes?(node)
+          if wrong_quotes?(node) || invalid_double_quotes?(node.source)
             add_offense(node, message: message) do |corrector|
               opposite_style_detected
               autocorrect(corrector, node)
@@ -57,6 +58,16 @@ module RuboCop
 
         private
 
+        def invalid_double_quotes?(source)
+          return false unless style == :double_quotes
+
+          # The string needs single quotes if:
+          # 1. It contains a double quote
+          # 2. It contains text that would become an escape sequence with double quotes
+          # 3. It contains text that would become an interpolation with double quotes
+          !/" | (?<!\\)\\[aAbcdefkMnprsStuUxzZ0-7] | \#[@{$]/x.match?(source)
+        end
+
         def autocorrect(corrector, node)
           str = if hash_colon_key?(node)
                   # strip quotes
@@ -75,11 +86,14 @@ module RuboCop
         end
 
         def correct_quotes(str)
-          if style == :single_quotes
-            to_string_literal(str)
-          else
-            str.inspect
-          end
+          correction = if style == :single_quotes
+                         to_string_literal(str)
+                       else
+                         str.gsub("\\'", "'").inspect
+                       end
+
+          # The conversion process doubles escaped slashes, so they have to be reverted
+          correction.gsub('\\\\', '\\')
         end
 
         def style

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

@@ -141,7 +141,7 @@ module RuboCop
         end
 
         def requires_parens?(parent)
-          parent.and_type? || parent.or_type? || parent.if_type? && parent.ternary?
+          parent.and_type? || parent.or_type? || (parent.if_type? && parent.ternary?)
         end
       end
     end

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

@@ -5,22 +5,29 @@ module RuboCop
     module Style
       # This cop checks for a redundant argument passed to certain methods.
       #
-      # Limitations:
-      #
-      # 1. This cop matches for method names only and hence cannot tell apart
-      #    methods with same name in different classes.
-      # 2. This cop is limited to methods with single parameter.
-      # 3. This cop is unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
-      #    That depends on the nature of the target methods, of course.
+      # NOTE: This cop is limited to methods with single parameter.
       #
       # Method names and their redundant arguments can be configured like this:
       #
+      # [source,yaml]
+      # ----
       # Methods:
       #   join: ''
       #   split: ' '
       #   chomp: "\n"
       #   chomp!: "\n"
       #   foo: 2
+      # ----
+      #
+      # @safety
+      #   This cop is unsafe because of the following limitations:
+      #
+      #   1. This cop matches by method names only and hence cannot tell apart
+      #      methods with same name in different classes.
+      #   2. This cop may be unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
+      #      That depends on the nature of the target methods, of course. For example, the default
+      #      argument to join is `$OUTPUT_FIELD_SEPARATOR` (or `$,`) rather than `''`, and if that
+      #      global is changed, `''` is no longer a redundant argument.
       #
       # @example
       #   # bad
@@ -51,8 +58,11 @@ module RuboCop
           return if node.arguments.count != 1
           return unless redundant_argument?(node)
 
-          add_offense(node, message: format(MSG, arg: node.arguments.first.source)) do |corrector|
-            corrector.remove(argument_range(node))
+          offense_range = argument_range(node)
+          message = format(MSG, arg: node.arguments.first.source)
+
+          add_offense(offense_range, message: message) do |corrector|
+            corrector.remove(offense_range)
           end
         end
 

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

@@ -84,6 +84,7 @@ module RuboCop
 
         def on_kwbegin(node)
           return if empty_begin?(node) ||
+                    begin_block_has_multiline_statements?(node) ||
                     contain_rescue_or_ensure?(node) ||
                     valid_context_using_only_begin?(node)
 
@@ -102,6 +103,9 @@ module RuboCop
               corrector.remove(offense_range)
             end
 
+            if use_modifier_form_after_multiline_begin_block?(node)
+              correct_modifier_form_after_multiline_begin_block(corrector, node)
+            end
             corrector.remove(node.loc.end)
           end
         end
@@ -127,10 +131,31 @@ module RuboCop
           corrector.insert_before(node.parent, comments) unless comments.blank?
         end
 
+        def use_modifier_form_after_multiline_begin_block?(node)
+          return unless (parent = node.parent)
+
+          node.multiline? && parent.if_type? && parent.modifier_form?
+        end
+
+        def correct_modifier_form_after_multiline_begin_block(corrector, node)
+          condition_range = condition_range(node.parent)
+
+          corrector.insert_after(node.children.first, " #{condition_range.source}")
+          corrector.remove(range_by_whole_lines(condition_range, include_final_newline: true))
+        end
+
+        def condition_range(node)
+          range_between(node.loc.keyword.begin_pos, node.condition.source_range.end_pos)
+        end
+
         def empty_begin?(node)
           node.children.empty?
         end
 
+        def begin_block_has_multiline_statements?(node)
+          node.children.count >= 2
+        end
+
         def contain_rescue_or_ensure?(node)
           first_child = node.children.first