rubocop 1.27.0 → 1.28.0

data/lib/rubocop/cop/security/compound_hash.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # This cop checks for implementations of the `hash` method which combine
+      # values using custom logic instead of delegating to `Array#hash`.
+      #
+      # Manually combining hashes is error prone and hard to follow, especially
+      # when there are many values. Poor implementations may also introduce
+      # performance or security concerns if they are prone to collisions.
+      # Delegating to `Array#hash` is clearer, faster, and safer.
+      #
+      # @safety
+      #   This cop may be unsafe if the application logic depends on the hash
+      #   value, however this is inadvisable anyway.
+      #
+      # @example
+      #
+      #   # bad
+      #   def hash
+      #     @foo ^ @bar
+      #   end
+      #
+      #   # good
+      #   def hash
+      #     [@foo, @bar].hash
+      #   end
+      class CompoundHash < Base
+        COMBINATOR_IN_HASH_MSG = 'Use `[...].hash` instead of combining hash values manually.'
+        MONUPLE_HASH_MSG =
+          'Delegate hash directly without wrapping in an array when only using a single value'
+        REDUNDANT_HASH_MSG = 'Calling .hash on elements of a hashed array is redundant'
+
+        # @!method hash_method_definition?(node)
+        def_node_matcher :hash_method_definition?, <<~PATTERN
+          {#static_hash_method_definition? | #dynamic_hash_method_definition?}
+        PATTERN
+
+        # @!method dynamic_hash_method_definition?(node)
+        def_node_matcher :dynamic_hash_method_definition?, <<~PATTERN
+          (block
+            (send _ {:define_method | :define_singleton_method}
+              (sym :hash))
+            (args)
+            _)
+        PATTERN
+
+        # @!method static_hash_method_definition?(node)
+        def_node_matcher :static_hash_method_definition?, <<~PATTERN
+          ({def | defs _} :hash
+            (args)
+            _)
+        PATTERN
+
+        # @!method bad_hash_combinator?(node)
+        def_node_matcher :bad_hash_combinator?, <<~PATTERN
+          ({send | op-asgn} _ {:^ | :+ | :* | :|} _)
+        PATTERN
+
+        # @!method monuple_hash?(node)
+        def_node_matcher :monuple_hash?, <<~PATTERN
+          (send (array _) :hash)
+        PATTERN
+
+        # @!method redundant_hash?(node)
+        def_node_matcher :redundant_hash?, <<~PATTERN
+          (
+            ^^(send array ... :hash)
+            _ :hash
+          )
+        PATTERN
+
+        def contained_in_hash_method?(node, &block)
+          node.each_ancestor.any? do |ancestor|
+            hash_method_definition?(ancestor, &block)
+          end
+        end
+
+        def outer_bad_hash_combinator?(node)
+          bad_hash_combinator?(node) do
+            yield true if node.each_ancestor.none? { |ancestor| bad_hash_combinator?(ancestor) }
+          end
+        end
+
+        def on_send(node)
+          outer_bad_hash_combinator?(node) do
+            contained_in_hash_method?(node) do
+              add_offense(node, message: COMBINATOR_IN_HASH_MSG)
+            end
+          end
+
+          monuple_hash?(node) do
+            add_offense(node, message: MONUPLE_HASH_MSG)
+          end
+
+          redundant_hash?(node) do
+            add_offense(node, message: REDUNDANT_HASH_MSG)
+          end
+        end
+        alias on_op_asgn on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop suggests `ENV.fetch` for the replacement of `ENV[]`.
+      # `ENV[]` silently fails and returns `nil` when the environment variable is unset,
+      # which may cause unexpected behaviors when the developer forgets to set it.
+      # On the other hand, `ENV.fetch` raises KeyError or returns the explicitly
+      # specified default value.
+      #
+      # @example
+      #   # bad
+      #   ENV['X']
+      #   ENV['X'] || z
+      #   x = ENV['X']
+      #
+      #   # good
+      #   ENV.fetch('X')
+      #   ENV.fetch('X', nil) || z
+      #   x = ENV.fetch('X')
+      #
+      #   # also good
+      #   !ENV['X']
+      #   ENV['X'].some_method # (e.g. `.nil?`)
+      #
+      class FetchEnvVar < Base
+        extend AutoCorrector
+
+        MSG = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
+
+        # @!method env_with_bracket?(node)
+        def_node_matcher :env_with_bracket?, <<~PATTERN
+          (send (const nil? :ENV) :[] $_)
+        PATTERN
+
+        def on_send(node)
+          env_with_bracket?(node) do |expression|
+            break if allowed_var?(expression)
+            break if allowable_use?(node)
+
+            add_offense(node, message: format(MSG, key: expression.source)) do |corrector|
+              corrector.replace(node, "ENV.fetch(#{expression.source}, nil)")
+            end
+          end
+        end
+
+        private
+
+        def allowed_var?(expression)
+          expression.str_type? && cop_config['AllowedVars'].include?(expression.value)
+        end
+
+        def used_as_flag?(node)
+          return false if node.root?
+
+          node.parent.if_type? || (node.parent.send_type? && node.parent.prefix_bang?)
+        end
+
+        # Check if the node is a receiver and receives a message with dot syntax.
+        def message_chained_with_dot?(node)
+          return false if node.root?
+
+          node.parent.send_type? && node.parent.children.first == node && node.parent.dot?
+        end
+
+        # Allow if used as a flag (e.g., `if ENV['X']` or `!ENV['X']`) because
+        # it simply checks whether the variable is set.
+        # Also allow if receiving a message with dot syntax, e.g. `ENV['X'].nil?`.
+        def allowable_use?(node)
+          used_as_flag?(node) || message_chained_with_dot?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -47,6 +47,37 @@ module RuboCop
       #   # good
       #   foo || raise('exception') if something
       #   ok
+      #
+      # @example AllowConsecutiveConditionals: false (default)
+      #   # bad
+      #   if foo?
+      #     work
+      #   end
+      #
+      #   if bar?  # <- reports an offense
+      #     work
+      #   end
+      #
+      # @example AllowConsecutiveConditionals: true
+      #   # good
+      #   if foo?
+      #     work
+      #   end
+      #
+      #   if bar?
+      #     work
+      #   end
+      #
+      #   # bad
+      #   if foo?
+      #     work
+      #   end
+      #
+      #   do_someting
+      #
+      #   if bar?  # <- reports an offense
+      #     work
+      #   end
       class GuardClause < Base
         include MinBodyLength
         include StatementModifier
@@ -89,10 +120,20 @@ module RuboCop
 
         def check_ending_if(node)
           return if accepted_form?(node, ending: true) || !min_body_length?(node)
+          return if allowed_consecutive_conditionals? &&
+                    consecutive_conditionals?(node.parent, node)
 
           register_offense(node, 'return', opposite_keyword(node))
         end
 
+        def consecutive_conditionals?(parent, node)
+          parent.each_child_node.inject(false) do |if_type, child|
+            break if_type if node == child
+
+            child.if_type?
+          end
+        end
+
         def opposite_keyword(node)
           node.if? ? 'unless' : 'if'
         end
@@ -135,6 +176,10 @@ module RuboCop
             !node.else? || node.elsif?
           end
         end
+
+        def allowed_consecutive_conditionals?
+          cop_config.fetch('AllowConsecutiveConditionals', false)
+        end
       end
     end
   end

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

@@ -37,7 +37,7 @@ module RuboCop
       class IfUnlessModifier < Base
         include StatementModifier
         include LineLengthHelp
-        include IgnoredPattern
+        include AllowedPattern
         include RangeHelp
         extend AutoCorrector
 
@@ -87,8 +87,9 @@ module RuboCop
             !another_statement_on_same_line?(node)
         end
 
-        def ignored_patterns
-          config.for_cop('Layout/LineLength')['IgnoredPatterns'] || []
+        def allowed_patterns
+          line_length_config = config.for_cop('Layout/LineLength')
+          line_length_config['AllowedPatterns'] || line_length_config['IgnoredPatterns'] || []
         end
 
         def too_long_single_line?(node)
@@ -105,7 +106,7 @@ module RuboCop
         end
 
         def too_long_line_based_on_config?(range, line)
-          return false if matches_ignored_pattern?(line)
+          return false if matches_allowed_pattern?(line)
 
           too_long = too_long_line_based_on_ignore_cop_directives?(range, line)
           return too_long unless too_long == :undetermined

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -13,7 +13,7 @@ module RuboCop
 
           def require_parentheses(node)
             return if ignored_method?(node.method_name)
-            return if matches_ignored_pattern?(node.method_name)
+            return if matches_allowed_pattern?(node.method_name)
             return if eligible_for_parentheses_omission?(node)
             return unless node.arguments? && !node.parenthesized?
 

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

@@ -8,7 +8,7 @@ module RuboCop
       #
       # In the default style (require_parentheses), macro methods are ignored.
       # Additional methods can be added to the `IgnoredMethods`
-      # or `IgnoredPatterns` list. These options are
+      # or `AllowedPatterns` list. These options are
       # valid only in the default style. Macros can be included by
       # either setting `IgnoreMacros` to false or adding specific macros to
       # the `IncludedMacros` list.
@@ -16,7 +16,7 @@ module RuboCop
       # Precedence of options is all follows:
       #
       # 1. `IgnoredMethods`
-      # 2. `IgnoredPatterns`
+      # 2. `AllowedPatterns`
       # 3. `IncludedMacros`
       #
       # eg. If a method is listed in both
@@ -68,7 +68,7 @@ module RuboCop
       #   # okay with `puts` listed in `IgnoredMethods`
       #   puts 'test'
       #
-      #   # okay with `^assert` listed in `IgnoredPatterns`
+      #   # okay with `^assert` listed in `AllowedPatterns`
       #   assert_equal 'test', x
       #
       # @example EnforcedStyle: omit_parentheses
@@ -198,7 +198,7 @@ module RuboCop
 
         include ConfigurableEnforcedStyle
         include IgnoredMethods
-        include IgnoredPattern
+        include AllowedPattern
         include RequireParentheses
         include OmitParentheses
         extend AutoCorrector

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

@@ -6,7 +6,8 @@ module RuboCop
       # This cop checks for multi-line ternary op expressions.
       #
       # NOTE: `return if ... else ... end` is syntax error. If `return` is used before
-      # multiline ternary operator expression, it cannot be auto-corrected.
+      # multiline ternary operator expression, it will be auto-corrected to single-line
+      # ternary operator. The same is true for `break`, `next`, and method call.
       #
       # @example
       #   # bad
@@ -18,6 +19,10 @@ module RuboCop
       #       b :
       #       c
       #
+      #   return cond ?
+      #          b :
+      #          c
+      #
       #   # good
       #   a = cond ? b : c
       #   a = if cond
@@ -25,20 +30,39 @@ module RuboCop
       #   else
       #     c
       #   end
+      #
+      #   return cond ? b : c
+      #
       class MultilineTernaryOperator < Base
         extend AutoCorrector
 
-        MSG = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
+        MSG_IF = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
+        MSG_SINGLE_LINE = 'Avoid multi-line ternary operators, use single-line instead.'
+        SINGLE_LINE_TYPES = %i[return break next send].freeze
 
         def on_if(node)
           return unless offense?(node)
 
-          add_offense(node) do |corrector|
-            # `return if ... else ... end` is syntax error. If `return` is used before
-            # multiline ternary operator expression, it cannot be auto-corrected.
-            next unless offense?(node) && !node.parent.return_type?
+          message = enforce_single_line_ternary_operator?(node) ? MSG_SINGLE_LINE : MSG_IF
+
+          add_offense(node, message: message) do |corrector|
+            next unless offense?(node)
+
+            corrector.replace(node, replacement(node))
+          end
+        end
+
+        private
 
-            corrector.replace(node, <<~RUBY.chop)
+        def offense?(node)
+          node.ternary? && node.multiline?
+        end
+
+        def replacement(node)
+          if enforce_single_line_ternary_operator?(node)
+            "#{node.condition.source} ? #{node.if_branch.source} : #{node.else_branch.source}"
+          else
+            <<~RUBY.chop
               if #{node.condition.source}
                 #{node.if_branch.source}
               else
@@ -48,10 +72,8 @@ module RuboCop
           end
         end
 
-        private
-
-        def offense?(node)
-          node.ternary? && node.multiline?
+        def enforce_single_line_ternary_operator?(node)
+          SINGLE_LINE_TYPES.include?(node.parent.type)
         end
       end
     end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of consistent method names
+      # `Object#yield_self` or `Object#then`.
+      #
+      # @example EnforcedStyle: then (default)
+      #
+      #   # bad
+      #   obj.yield_self { |x| x.do_something }
+      #
+      #   # good
+      #   obj.then { |x| x.do_something }
+      #
+      # @example EnforcedStyle: yield_self
+      #
+      #   # bad
+      #   obj.then { |x| x.do_something }
+      #
+      #   # good
+      #   obj.yield_self { |x| x.do_something }
+      #
+      class ObjectThen < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+
+        def on_block(node)
+          check_method_node(node.send_node)
+        end
+
+        def on_send(node)
+          return unless node.arguments.one? && node.first_argument.block_pass_type?
+
+          check_method_node(node)
+        end
+
+        private
+
+        def check_method_node(node)
+          return unless preferred_method(node)
+
+          message = message(node)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, style.to_s)
+          end
+        end
+
+        def preferred_method(node)
+          case style
+          when :then
+            node.method?(:yield_self)
+          when :yield_self
+            node.method?(:then)
+          else
+            false
+          end
+        end
+
+        def message(node)
+          format(MSG, prefer: style.to_s, current: node.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -18,6 +18,10 @@ module RuboCop
       # to purposely create an empty `initialize` method to override a superclass's
       # initializer.
       #
+      # @safety
+      #   This cop is unsafe because if subclass overrides `initialize` method with
+      #   a different arity than superclass.
+      #
       # @example
       #   # bad
       #   def initialize
@@ -76,7 +80,25 @@ module RuboCop
       #   def initialize(...)
       #   end
       #
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   def initialize
+      #     # Overriding to negate superclass `initialize` method.
+      #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   def initialize
+      #     # Overriding to negate superclass `initialize` method.
+      #   end
+      #
       class RedundantInitialize < Base
+        include CommentsHelp
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Remove unnecessary `initialize` method.'
         MSG_EMPTY = 'Remove unnecessary empty `initialize` method.'
 
@@ -86,28 +108,41 @@ module RuboCop
         PATTERN
 
         def on_def(node)
-          return unless node.method?(:initialize)
-          return if forwards?(node)
+          return if acceptable?(node)
 
           if node.body.nil?
-            add_offense(node, message: MSG_EMPTY)
+            register_offense(node, MSG_EMPTY)
           else
             return if node.body.begin_type?
 
             if (args, super_node = initialize_forwards?(node))
               return unless same_args?(super_node, args)
 
-              add_offense(node)
+              register_offense(node, MSG)
             end
           end
         end
 
         private
 
+        def register_offense(node, message)
+          add_offense(node, message: message) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+          end
+        end
+
+        def acceptable?(node)
+          !node.method?(:initialize) || forwards?(node) || allow_comments?(node)
+        end
+
         def forwards?(node)
           node.arguments.each_child_node(:restarg, :kwrestarg, :forward_args, :forward_arg).any?
         end
 
+        def allow_comments?(node)
+          cop_config['AllowComments'] && contains_comments?(node)
+        end
+
         def same_args?(super_node, args)
           return true if super_node.zsuper_type?
 

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

@@ -63,6 +63,7 @@ module RuboCop
             next if expr.type != :set || expr.expressions.size != 1
             next if expr.negative?
             next if %i[set posixclass nonposixclass].include?(expr.expressions.first.type)
+            next if multiple_codepoins?(expr.expressions.first)
 
             yield expr
           end
@@ -79,6 +80,10 @@ module RuboCop
           !non_redundant
         end
 
+        def multiple_codepoins?(expression)
+          expression.respond_to?(:codepoints) && expression.codepoints.count >= 2
+        end
+
         def without_character_class(loc)
           without_character_class = loc.source[1..-2]
 

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

@@ -50,9 +50,13 @@ module RuboCop
 
           message = format(MSG, receiver: receiver, argument: argument, original: node.source)
           add_offense(node, message: message) do |corrector|
+            next if part_of_ignored_node?(node)
+
             correct_access = "#{receiver}[#{argument}]"
             corrector.replace(node, correct_access)
           end
+
+          ignore_node(node)
         end
       end
     end

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

@@ -110,9 +110,12 @@ module RuboCop
         def autocorrect_outer_condition_basic(corrector, node, if_branch)
           correct_from_unless_to_if(corrector, node) if node.unless?
 
+          outer_condition = node.condition
+          correct_outer_condition(corrector, outer_condition)
+
           and_operator = if_branch.unless? ? ' && !' : ' && '
           if if_branch.modifier_form?
-            correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
+            correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
           else
             correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
             correct_for_comment(corrector, node, if_branch)
@@ -136,10 +139,7 @@ module RuboCop
           end
         end
 
-        def correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
-          outer_condition = node.condition
-          correct_outer_condition(corrector, outer_condition)
-
+        def correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
           condition = if_branch.condition
           corrector.insert_after(outer_condition, "#{and_operator}#{replace_condition(condition)}")
 
@@ -177,7 +177,7 @@ module RuboCop
         end
 
         def correct_outer_condition(corrector, condition)
-          return unless requrie_parentheses?(condition)
+          return unless require_parentheses?(condition)
 
           end_pos = condition.loc.selector.end_pos
           begin_pos = condition.first_argument.source_range.begin_pos
@@ -187,7 +187,7 @@ module RuboCop
           corrector.insert_after(condition.last_argument.source_range, ')')
         end
 
-        def requrie_parentheses?(condition)
+        def require_parentheses?(condition)
           condition.send_type? && !condition.arguments.empty? && !condition.parenthesized? &&
             !condition.comparison_method?
         end