rubocop 1.30.0 → 1.31.0

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

@@ -184,6 +184,8 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
         def autocorrect(corrector, node)
@@ -281,7 +283,7 @@ module RuboCop
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
           comment_range = range_between(range.end_pos, comment.loc.expression.end_pos)
-          corrector.remove(range_with_surrounding_space(range: comment_range, side: :right))
+          corrector.remove(range_with_surrounding_space(comment_range, side: :right))
           corrector.insert_after(range, "\n")
 
           corrector.insert_before(block_node, "#{comment.text}\n")
@@ -300,7 +302,7 @@ module RuboCop
 
         def get_blocks(node, &block)
           case node.type
-          when :block
+          when :block, :numblock
             yield node
           when :send
             get_blocks(node.receiver, &block) if node.receiver

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

@@ -66,7 +66,7 @@ module RuboCop
 
         def register_offense(comment, matched_keyword)
           add_offense(comment, message: format(MSG, keyword: matched_keyword)) do |corrector|
-            range = range_with_surrounding_space(range: comment.loc.expression, newlines: false)
+            range = range_with_surrounding_space(comment.loc.expression, newlines: false)
             corrector.remove(range)
 
             unless matched_keyword == 'end'

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

@@ -237,6 +237,7 @@ module RuboCop
         ASSIGNMENT_TYPES.each do |type|
           define_method "on_#{type}" do |node|
             return if part_of_ignored_node?(node)
+            return if node.parent&.shorthand_asgn?
 
             check_assignment_to_condition(node)
           end

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

@@ -6,20 +6,20 @@ module RuboCop
       # Checks for empty else-clauses, possibly including comments and/or an
       # explicit `nil` depending on the EnforcedStyle.
       #
-      # @example EnforcedStyle: empty
-      #   # warn only on empty else
+      # @example EnforcedStyle: both (default)
+      #   # warn on empty else and else with nil in it
       #
       #   # bad
       #   if condition
       #     statement
       #   else
+      #     nil
       #   end
       #
-      #   # good
+      #   # bad
       #   if condition
       #     statement
       #   else
-      #     nil
       #   end
       #
       #   # good
@@ -34,20 +34,20 @@ module RuboCop
       #     statement
       #   end
       #
-      # @example EnforcedStyle: nil
-      #   # warn on else with nil in it
+      # @example EnforcedStyle: empty
+      #   # warn only on empty else
       #
       #   # bad
       #   if condition
       #     statement
       #   else
-      #     nil
       #   end
       #
       #   # good
       #   if condition
       #     statement
       #   else
+      #     nil
       #   end
       #
       #   # good
@@ -62,8 +62,8 @@ module RuboCop
       #     statement
       #   end
       #
-      # @example EnforcedStyle: both (default)
-      #   # warn on empty else and else with nil in it
+      # @example EnforcedStyle: nil
+      #   # warn on else with nil in it
       #
       #   # bad
       #   if condition
@@ -72,7 +72,7 @@ module RuboCop
       #     nil
       #   end
       #
-      #   # bad
+      #   # good
       #   if condition
       #     statement
       #   else

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

@@ -11,6 +11,10 @@ module RuboCop
       # NOTE: A method definition is not considered empty if it contains
       # comments.
       #
+      # NOTE: Autocorrection will not be applied for the `compact` style
+      # if the resulting code is longer than the `Max` configuration for
+      # `Layout/LineLength`, but an offense will still be registered.
+      #
       # @example EnforcedStyle: compact (default)
       #   # bad
       #   def foo(bar)
@@ -51,7 +55,12 @@ module RuboCop
           return if node.body || comment_lines?(node)
           return if correct_style?(node)
 
-          add_offense(node) { |corrector| corrector.replace(node, corrected(node)) }
+          add_offense(node) do |corrector|
+            correction = corrected(node)
+            next if compact_style? && max_line_length && correction.size > max_line_length
+
+            corrector.replace(node, correction)
+          end
         end
         alias on_defs on_def
 
@@ -98,6 +107,12 @@ module RuboCop
         def expanded_style?
           style == :expanded
         end
+
+        def max_line_length
+          return unless config.for_cop('Layout/LineLength')['Enabled']
+
+          config.for_cop('Layout/LineLength')['Max']
+        end
       end
     end
   end

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

@@ -51,7 +51,7 @@ module RuboCop
             text = comment.without(:encoding)
 
             if text.blank?
-              corrector.remove(range_with_surrounding_space(range: range, side: :right))
+              corrector.remove(range_with_surrounding_space(range, side: :right))
             else
               corrector.replace(range, text)
             end

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

@@ -42,7 +42,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Consider using explicit block argument in the '\
+        MSG = 'Consider using explicit block argument in the ' \
               "surrounding method's signature over `yield`."
 
         # @!method yielding_block?(node)

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

@@ -112,13 +112,20 @@ module RuboCop
         end
 
         def used_in_condition?(node, condition)
-          if condition.send_type? && (!condition.comparison_method? && !condition.predicate_method?)
-            return false
+          if condition.send_type?
+            return true if condition.assignment_method? && partial_matched?(node, condition)
+            return false if !condition.comparison_method? && !condition.predicate_method?
           end
 
           condition.child_nodes.any?(node)
         end
 
+        # Avoid offending in the following cases:
+        # `ENV['key'] if ENV['key'] = x`
+        def partial_matched?(node, condition)
+          node.child_nodes == node.child_nodes & condition.child_nodes
+        end
+
         def offensive?(node)
           !(allowed_var?(node) || allowable_use?(node))
         end

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

@@ -69,6 +69,7 @@ module RuboCop
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
+        extend AutoCorrector
 
         def on_str(node)
           return if format_string_token?(node) || use_ignored_method?(node)
@@ -77,13 +78,8 @@ module RuboCop
           return if detections.empty?
           return if allowed_unannotated?(detections)
 
-          detections.each do |detected_style, token_range|
-            if detected_style == style
-              correct_style_detected
-            else
-              style_detected(detected_style)
-              add_offense(token_range, message: message(detected_style))
-            end
+          detections.each do |detected_sequence, token_range|
+            check_sequence(detected_sequence, token_range)
           end
         end
 
@@ -106,6 +102,38 @@ module RuboCop
           send_parent && ignored_method?(send_parent.method_name)
         end
 
+        def check_sequence(detected_sequence, token_range)
+          if detected_sequence.style == style
+            correct_style_detected
+          elsif correctable_sequence?(detected_sequence.type)
+            style_detected(detected_sequence.style)
+            add_offense(token_range, message: message(detected_sequence.style)) do |corrector|
+              autocorrect_sequence(corrector, detected_sequence, token_range)
+            end
+          end
+        end
+
+        def correctable_sequence?(detected_type)
+          detected_type == 's' || style == :annotated || style == :unannotated
+        end
+
+        def autocorrect_sequence(corrector, detected_sequence, token_range)
+          return if style == :unannotated
+
+          name = detected_sequence.name
+          return if name.nil?
+
+          flags = detected_sequence.flags
+          width = detected_sequence.width
+          precision = detected_sequence.precision
+          type = detected_sequence.style == :template ? 's' : detected_sequence.type
+          correction = case style
+                       when :annotated then "%<#{name}>#{flags}#{width}#{precision}#{type}"
+                       when :template then "%#{flags}#{width}#{precision}{#{name}}"
+                       end
+          corrector.replace(token_range, correction)
+        end
+
         def unannotated_format?(node, detected_style)
           detected_style == :unannotated && !format_string_in_typical_context?(node)
         end
@@ -143,30 +171,33 @@ module RuboCop
         def token_ranges(contents)
           format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
 
-          format_string.format_sequences.each do |seq|
-            next if seq.percent?
+          format_string.format_sequences.each do |detected_sequence|
+            next if detected_sequence.percent?
 
-            detected_style = seq.style
-            token = contents.begin.adjust(begin_pos: seq.begin_pos, end_pos: seq.end_pos)
+            token = contents.begin.adjust(begin_pos: detected_sequence.begin_pos,
+                                          end_pos: detected_sequence.end_pos)
 
-            yield(detected_style, token)
+            yield(detected_sequence, token)
           end
         end
 
         def collect_detections(node)
           detections = []
-          tokens(node) do |detected_style, token_range|
-            unless unannotated_format?(node, detected_style)
-              detections << [detected_style, token_range]
+          tokens(node) do |detected_sequence, token_range|
+            unless unannotated_format?(node, detected_sequence.style)
+              detections << [detected_sequence, token_range]
             end
           end
           detections
         end
 
         def allowed_unannotated?(detections)
-          return false if detections.size > max_unannotated_placeholders_allowed
+          return false unless detections.all? do |detected_sequence,|
+                                detected_sequence.style == :unannotated
+                              end
+          return true if detections.size <= max_unannotated_placeholders_allowed
 
-          detections.all? { |detected_style,| detected_style == :unannotated }
+          detections.any? { |detected_sequence,| !correctable_sequence?(detected_sequence.type) }
         end
 
         def max_unannotated_placeholders_allowed

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

@@ -182,7 +182,7 @@ module RuboCop
         end
 
         def remove_comment(corrector, node)
-          corrector.remove(range_with_surrounding_space(range: node.pos, side: :right))
+          corrector.remove(range_with_surrounding_space(node.pos, side: :right))
         end
 
         def enable_comment(corrector)

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

@@ -110,7 +110,7 @@ module RuboCop
           kw = if guard_clause_in_if
                  node.loc.keyword.source
                else
-                 opposite_keyword(node)
+                 node.inverse_keyword
                end
 
           register_offense(node, guard_clause_source(guard_clause), kw)
@@ -123,7 +123,7 @@ module RuboCop
           return if allowed_consecutive_conditionals? &&
                     consecutive_conditionals?(node.parent, node)
 
-          register_offense(node, 'return', opposite_keyword(node))
+          register_offense(node, 'return', node.inverse_keyword)
         end
 
         def consecutive_conditionals?(parent, node)
@@ -134,14 +134,12 @@ module RuboCop
           end
         end
 
-        def opposite_keyword(node)
-          node.if? ? 'unless' : 'if'
-        end
-
         def register_offense(node, scope_exiting_keyword, conditional_keyword)
           condition, = node.node_parts
           example = [scope_exiting_keyword, conditional_keyword, condition.source].join(' ')
           if too_long_for_single_line?(node, example)
+            return if trivial?(node)
+
             example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
           end
 
@@ -167,6 +165,10 @@ module RuboCop
           accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
         end
 
+        def trivial?(node)
+          node.branches.one? && !node.if_branch.if_type? && !node.if_branch.begin_type?
+        end
+
         def accepted_if?(node, ending)
           return true if node.modifier_form? || node.ternary?
 

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

@@ -87,7 +87,7 @@ module RuboCop
 
         def remove_last_element_trailing_comma(corrector, node)
           range = range_with_surrounding_space(
-            range: node.children.last.source_range,
+            node.children.last.source_range,
             side: :right
           ).end.resize(1)
 

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

@@ -19,6 +19,9 @@ module RuboCop
       #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar }
       #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar }
       #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[foo bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[foo bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| !%i[foo bar].include?(k) }
       #
       #   # good
       #   {foo: 1, bar: 2, baz: 3}.except(:bar)
@@ -33,15 +36,36 @@ module RuboCop
         MSG = 'Use `%<prefer>s` instead.'
         RESTRICT_ON_SEND = %i[reject select filter].freeze
 
-        # @!method bad_method?(node)
-        def_node_matcher :bad_method?, <<~PATTERN
+        # @!method bad_method_with_poro?(node)
+        def_node_matcher :bad_method_with_poro?, <<~PATTERN
           (block
             (send _ _)
             (args
               (arg _)
               (arg _))
-            (send
-              _ {:== :!= :eql?} _))
+            {
+              (send
+                _ {:== :!= :eql? :include?} _)
+              (send
+                (send
+                  _ {:== :!= :eql? :include?} _) :!)
+              })
+        PATTERN
+
+        # @!method bad_method_with_active_support?(node)
+        def_node_matcher :bad_method_with_active_support?, <<~PATTERN
+          (block
+            (send _ _)
+            (args
+              (arg _)
+              (arg _))
+            {
+              (send
+                _ {:== :!= :eql? :in? :include? :exclude?} _)
+              (send
+                (send
+                  _ {:== :!= :eql? :in? :include? :exclude?} _) :!)
+              })
         PATTERN
 
         def on_send(node)
@@ -52,7 +76,7 @@ module RuboCop
           return if except_key.nil? || !safe_to_register_offense?(block, except_key)
 
           range = offense_range(node)
-          preferred_method = "except(#{except_key.source})"
+          preferred_method = "except(#{except_key_source(except_key)})"
 
           add_offense(range, message: format(MSG, prefer: preferred_method)) do |corrector|
             corrector.replace(range, preferred_method)
@@ -61,28 +85,84 @@ module RuboCop
 
         private
 
+        def bad_method?(block)
+          if active_support_extensions_enabled?
+            bad_method_with_active_support?(block)
+          else
+            bad_method_with_poro?(block)
+          end
+        end
+
         def semantically_except_method?(send, block)
           body = block.body
 
+          negated = body.method?('!')
+          body = body.receiver if negated
+
           case send.method_name
           when :reject
-            body.method?('==') || body.method?('eql?')
+            body.method?('==') || body.method?('eql?') || included?(negated, body)
           when :select, :filter
-            body.method?('!=')
+            body.method?('!=') || not_included?(negated, body)
           else
             false
           end
         end
 
+        def included?(negated, body)
+          body.method?('include?') || body.method?('in?') || (negated && body.method?('exclude?'))
+        end
+
+        def not_included?(negated, body)
+          body.method?('exclude?') || (negated && (body.method?('include?') || body.method?('in?')))
+        end
+
         def safe_to_register_offense?(block, except_key)
+          extracted = extract_body_if_nagated(block.body)
+          if extracted.method?('in?') || extracted.method?('include?') || \
+             extracted.method?('exclude?')
+            return true
+          end
           return true if block.body.method?('eql?')
 
           except_key.sym_type? || except_key.str_type?
         end
 
+        def extract_body_if_nagated(body)
+          return body unless body.method?('!')
+
+          body.receiver
+        end
+
+        def except_key_source(key)
+          if key.array_type?
+            key = if key.percent_literal?
+                    key.each_value.map { |v| decorate_source(v) }
+                  else
+                    key.each_value.map(&:source)
+                  end
+            return key.join(', ')
+          end
+
+          key.source
+        end
+
+        def decorate_source(value)
+          return ":\"#{value.source}\"" if value.dsym_type?
+          return "\"#{value.source}\"" if value.dstr_type?
+          return ":#{value.source}" if value.sym_type?
+
+          "'#{value.source}'"
+        end
+
         def except_key(node)
           key_argument = node.argument_list.first.source
-          lhs, _method_name, rhs = *node.body
+          body = extract_body_if_nagated(node.body)
+          lhs, _method_name, rhs = *body
+
+          return lhs if body.method?('include?')
+          return lhs if body.method?('exclude?')
+          return rhs if body.method?('in?')
           return if [lhs, rhs].map(&:source).none?(key_argument)
 
           [lhs, rhs].find { |operand| operand.source != key_argument }

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

@@ -223,7 +223,7 @@ module RuboCop
           operator = pair_node.loc.operator
 
           range = key.join(operator)
-          range_with_surrounding_space(range: range, side: :right)
+          range_with_surrounding_space(range, side: :right)
         end
 
         def argument_without_space?(node)
@@ -235,7 +235,7 @@ module RuboCop
 
           key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
           corrector.replace(pair_node.key, key_with_hash_rocket)
-          corrector.remove(range_with_surrounding_space(range: op))
+          corrector.remove(range_with_surrounding_space(op))
         end
 
         def autocorrect_no_mixed_keys(corrector, pair_node)

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

@@ -15,8 +15,8 @@ module RuboCop
       #   # good
       #   raise ArgumentError, 'Error message here'
       class ImplicitRuntimeError < Base
-        MSG = 'Use `%<method>s` with an explicit exception class and message,' \
-              ' rather than just a message.'
+        MSG = 'Use `%<method>s` with an explicit exception class and message, ' \
+              'rather than just a message.'
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
         # @!method implicit_runtime_error_raise_or_fail(node)

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

@@ -65,7 +65,7 @@ module RuboCop
 
         def remove_kwargs(kwarg_nodes, corrector)
           kwarg_nodes.each do |kwarg|
-            with_space = range_with_surrounding_space(range: kwarg.source_range)
+            with_space = range_with_surrounding_space(kwarg.source_range)
             corrector.remove(range_with_surrounding_comma(with_space, :left))
           end
         end

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

@@ -70,7 +70,7 @@ module RuboCop
 
         def autocorrect(corrector, operator_range)
           # Include any trailing whitespace so we don't create a syntax error.
-          operator_range = range_with_surrounding_space(range: operator_range,
+          operator_range = range_with_surrounding_space(operator_range,
                                                         side: :right,
                                                         newlines: false)
           one_more_char = operator_range.resize(operator_range.size + 1)

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

@@ -59,7 +59,7 @@ module RuboCop
         def autocorrect(corrector, to_h, map)
           removal_range = range_between(to_h.loc.dot.begin_pos, to_h.loc.selector.end_pos)
 
-          corrector.remove(range_with_surrounding_space(range: removal_range, side: :left))
+          corrector.remove(range_with_surrounding_space(removal_range, side: :left))
           corrector.replace(map.loc.selector, 'to_h')
         end
       end

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

@@ -25,12 +25,12 @@ module RuboCop
             return if allowed_string_interpolation_method_call?(node)
 
             add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
-              auto_correct(corrector, node)
+              autocorrect(corrector, node)
             end
           end
           # rubocop:enable Metrics/PerceivedComplexity
 
-          def auto_correct(corrector, node)
+          def autocorrect(corrector, node)
             if parentheses_at_the_end_of_multiline_call?(node)
               corrector.replace(args_begin(node), ' \\')
             else