rubocop 1.19.0 → 1.33.0

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

@@ -3,30 +3,32 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for identical expressions at the beginning or end of
+      # Checks for identical expressions at the beginning or end of
       # each branch of a conditional expression. Such expressions should normally
       # be placed outside the conditional expression - before or after it.
       #
-      # This cop is marked unsafe auto-correction as the order of method invocations
-      # must be guaranteed in the following case:
-      #
-      # [source,ruby]
-      # ----
-      # if method_that_modifies_global_state # 1
-      #   method_that_relies_on_global_state # 2
-      #   foo                                # 3
-      # else
-      #   method_that_relies_on_global_state # 2
-      #   bar                                # 3
-      # end
-      # ----
-      #
-      # In such a case, auto-correction may change the invocation order.
-      #
       # NOTE: The cop is poorly named and some people might think that it actually
       # checks for duplicated conditional branches. The name will probably be changed
       # in a future major RuboCop release.
       #
+      # @safety
+      #   Autocorrection is unsafe because changing the order of method invocations
+      #   may change the behavior of the code. For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   if method_that_modifies_global_state # 1
+      #     method_that_relies_on_global_state # 2
+      #     foo                                # 3
+      #   else
+      #     method_that_relies_on_global_state # 2
+      #     bar                                # 3
+      #   end
+      #   ----
+      #
+      #   In this example, `method_that_relies_on_global_state` will be moved before
+      #   `method_that_modifies_global_state`, which changes the behavior of the program.
+      #
       # @example
       #   # bad
       #   if condition

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

@@ -80,11 +80,19 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
+          if then?(node)
+            # If the nested `if` is a then node, correct it first,
+            # then the next pass will use `correct_to_elsif_from_if_inside_else_form`
+            IfThenCorrector.new(node, indentation: 0).call(corrector)
+            return
+          end
+
           if node.modifier_form?
             correct_to_elsif_from_modifier_form(corrector, node)
           else
             correct_to_elsif_from_if_inside_else_form(corrector, node, node.condition)
           end
+
           corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
           return unless (if_branch = node.if_branch)
 
@@ -102,15 +110,22 @@ module RuboCop
 
         def correct_to_elsif_from_if_inside_else_form(corrector, node, condition)
           corrector.replace(node.parent.loc.else, "elsif #{condition.source}")
+
           if_condition_range = if_condition_range(node, condition)
+
           if (if_branch = node.if_branch)
             corrector.replace(if_condition_range, if_branch.source)
           else
             corrector.remove(range_by_whole_lines(if_condition_range, include_final_newline: true))
           end
+
           corrector.remove(condition)
         end
 
+        def then?(node)
+          node.loc.begin&.source == 'then'
+        end
+
         def find_end_range(node)
           end_range = node.loc.end
           return end_range if end_range

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/if_with_boolean_literal_branches.rb

@@ -3,11 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for redundant `if` with boolean literal branches.
+      # Checks for redundant `if` with boolean literal branches.
       # It checks only conditions to return boolean value (`true` or `false`) for safe detection.
       # The conditions to be checked are comparison methods, predicate methods, and double negative.
-      # However, auto-correction is unsafe because there is no guarantee that all predicate methods
-      # will return boolean value. Those methods can be allowed with `AllowedMethods` config.
+      # `nonzero?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
+      #
+      # @safety
+      #   Autocorrection is unsafe because there is no guarantee that all predicate methods
+      #   will return a boolean value. Those methods can be allowed with `AllowedMethods` config.
       #
       # @example
       #   # bad
@@ -23,7 +27,18 @@ module RuboCop
       #   # good
       #   foo == bar
       #
-      # @example AllowedMethods: ['nonzero?']
+      # @example
+      #   # bad
+      #   if foo.do_something?
+      #     true
+      #   else
+      #     false
+      #   end
+      #
+      #   # good (but potentially an unsafe correction)
+      #   foo.do_something?
+      #
+      # @example AllowedMethods: ['nonzero?'] (default)
       #   # good
       #   num.nonzero? ? true : false
       #
@@ -109,12 +124,13 @@ module RuboCop
         end
 
         def opposite_condition?(node)
-          !node.unless? && node.if_branch.false_type? || node.unless? && node.if_branch.true_type?
+          (!node.unless? && node.if_branch.false_type?) ||
+            (node.unless? && node.if_branch.true_type?)
         end
 
         def require_parentheses?(condition)
           condition.and_type? || condition.or_type? ||
-            condition.send_type? && condition.comparison_method?
+            (condition.send_type? && condition.comparison_method?)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for `raise` or `fail` statements which do not specify an
+      # Checks for `raise` or `fail` statements which do not specify an
       # explicit exception class. (This raises a `RuntimeError`. Some projects
       # might prefer to use exception classes which more precisely identify the
       # nature of the error.)
@@ -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/in_pattern_then.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for `in;` uses in `case` expressions.
+      # Checks for `in;` uses in `case` expressions.
       #
       # @example
       #   # bad

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

@@ -5,9 +5,10 @@ module RuboCop
     module Style
       # Use `Kernel#loop` for infinite loops.
       #
-      # This cop is marked as unsafe as the rule does not necessarily
-      # apply if the body might raise a `StopIteration` exception; contrary to
-      # other infinite loops, `Kernel#loop` silently rescues that and returns `nil`.
+      # @safety
+      #   This cop is unsafe as the rule should not necessarily apply if the loop
+      #   body might raise a `StopIteration` exception; contrary to other infinite
+      #   loops, `Kernel#loop` silently rescues that and returns `nil`.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for trailing inline comments.
+      # Checks for trailing inline comments.
       #
       # @example
       #

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

@@ -3,13 +3,20 @@
 module RuboCop
   module Cop
     module Style
-      # This cop check for usages of not (`not` or `!`) called on a method
+      # Check for usages of not (`not` or `!`) called on a method
       # when an inverse of that method can be used instead.
+      #
       # Methods that can be inverted by a not (`not` or `!`) should be defined
-      # in `InverseMethods`
+      # in `InverseMethods`.
+      #
       # Methods that are inverted by inverting the return
       # of the block that is passed to the method should be defined in
-      # `InverseBlocks`
+      # `InverseBlocks`.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the method
+      #   and its inverse method are both defined on receiver, and also are
+      #   actually inverse of each other.
       #
       # @example
       #   # bad
@@ -87,7 +94,7 @@ module RuboCop
 
             # Inverse method offenses inside of the block of an inverse method
             # offense, such as `y.reject { |key, _value| !(key =~ /c\d/) }`,
-            # can cause auto-correction to apply improper corrections.
+            # can cause autocorrection to apply improper corrections.
             ignore_node(block)
             add_offense(node, message: message(method, inverse_blocks[method])) do |corrector|
               correct_inverse_block(corrector, node)

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

@@ -5,7 +5,7 @@ require 'resolv'
 module RuboCop
   module Cop
     module Style
-      # This cop checks for hardcoded IP addresses, which can make code
+      # Checks for hardcoded IP addresses, which can make code
       # brittle. IP addresses are likely to need to be changed when code
       # is deployed to a different server or environment, which may break
       # a deployment if forgotten. Prefer setting IP addresses in ENV or

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces that optional keyword parameters are placed at the
+      # Enforces that optional keyword parameters are placed at the
       # end of the parameters list.
       #
       # This improves readability, because when looking through the source,
@@ -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/lambda.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop (by default) checks for uses of the lambda literal syntax for
+      # (by default) checks for uses of the lambda literal syntax for
       # single line lambdas, and the method call syntax for multiline lambdas.
       # It is configurable to enforce one of the styles for both single line
       # and multiline lambdas as well.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for use of the lambda.(args) syntax.
+      # Checks for use of the lambda.(args) syntax.
       #
       # @example EnforcedStyle: call (default)
       #  # bad
@@ -22,45 +22,37 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
+        MSG = 'Prefer the use of `%<prefer>s` over `%<current>s`.'
         RESTRICT_ON_SEND = %i[call].freeze
 
         def on_send(node)
           return unless node.receiver
 
           if offense?(node)
-            add_offense(node) do |corrector|
+            prefer = prefer(node)
+            current = node.source
+
+            add_offense(node, message: format(MSG, prefer: prefer, current: current)) do |corrector|
               opposite_style_detected
-              autocorrect(corrector, node)
+              corrector.replace(node, prefer)
             end
           else
             correct_style_detected
           end
         end
 
-        def autocorrect(corrector, node)
-          if explicit_style?
-            receiver = node.receiver.source
-            replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
-
-            corrector.replace(node, replacement)
-          else
-            add_parentheses(node, corrector) unless node.parenthesized?
-            corrector.remove(node.loc.selector)
-          end
-        end
-
         private
 
         def offense?(node)
-          explicit_style? && node.implicit_call? || implicit_style? && !node.implicit_call?
+          (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end
 
-        def message(_node)
-          if explicit_style?
-            'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'
-          else
-            'Prefer the use of `lambda.(...)` over `lambda.call(...)`.'
-          end
+        def prefer(node)
+          receiver = node.receiver.source
+          arguments = node.arguments.map(&:source).join(', ')
+          method = explicit_style? ? "call(#{arguments})" : "(#{arguments})"
+
+          "#{receiver}.#{method}"
         end
 
         def implicit_style?

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

@@ -3,9 +3,22 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for string literal concatenation at
+      # Checks for string literal concatenation at
       # the end of a line.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the
+      #   receiver is a string, in which case replacing `<<` with `\`
+      #   would result in a syntax error.
+      #
+      #   For example, this would be a false positive:
+      #   [source,ruby]
+      #   ----
+      #   array << 'foo' <<
+      #            'bar' <<
+      #            'baz'
+      #   ----
+      #
       # @example
       #
       #   # bad
@@ -46,7 +59,7 @@ module RuboCop
 
           return unless eligible_token_set?(predecessor, operator, successor)
 
-          return if operator.line == successor.line
+          return if same_line?(operator, successor)
 
           next_successor = token_after_last_string(successor, index)
 
@@ -57,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_compact_with_conditional_block.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer `select` or `reject` over `map { ... }.compact`.
+      #
+      # @example
+      #
+      #   # bad
+      #   array.map { |e| some_condition? ? e : next }.compact
+      #
+      #   # bad
+      #   array.map do |e|
+      #     if some_condition?
+      #       e
+      #     else
+      #       next
+      #     end
+      #   end.compact
+      #
+      #   # bad
+      #   array.map do |e|
+      #     next if some_condition?
+      #
+      #     e
+      #   end.compact
+      #
+      #   # bad
+      #   array.map do |e|
+      #     e if some_condition?
+      #   end.compact
+      #
+      #   # good
+      #   array.select { |e| some_condition? }
+      #
+      #   # good
+      #   array.reject { |e| some_condition? }
+      #
+      class MapCompactWithConditionalBlock < Base
+        extend AutoCorrector
+
+        MSG = 'Replace `map { ... }.compact` with `%<method>s`.'
+
+        # @!method map_and_compact?(node)
+        def_node_matcher :map_and_compact?, <<~RUBY
+          (send
+            (block
+              (send _ :map)
+              (args
+                $(arg _))
+              {
+                (if $_ $(lvar _) {next nil?})
+                (if $_ {next nil?} $(lvar _))
+                (if $_ (next $(lvar _)) {next nil nil?})
+                (if $_ {next nil nil?} (next $(lvar _)))
+                (begin
+                  {
+                    (if $_ next nil?)
+                    (if $_ nil? next)
+                  }
+                  $(lvar _))
+                (begin
+                  {
+                    (if $_ (next $(lvar _)) nil?)
+                    (if $_ nil? (next $(lvar _)))
+                  }
+                  (nil))
+              }) :compact)
+        RUBY
+
+        def on_send(node)
+          map_and_compact?(node) do |block_argument_node, condition_node, return_value_node|
+            return unless returns_block_argument?(block_argument_node, return_value_node)
+            return if condition_node.parent.elsif?
+
+            method = truthy_branch?(return_value_node) ? 'select' : 'reject'
+            range = range(node)
+
+            add_offense(range, message: format(MSG, method: method)) do |corrector|
+              corrector.replace(
+                range,
+                "#{method} { |#{block_argument_node.source}| #{condition_node.source} }"
+              )
+            end
+          end
+        end
+
+        private
+
+        def returns_block_argument?(block_argument_node, return_value_node)
+          block_argument_node.name == return_value_node.children.first
+        end
+
+        def truthy_branch?(node)
+          if node.parent.begin_type?
+            truthy_branch_for_guard?(node)
+          elsif node.parent.next_type?
+            truthy_branch_for_if?(node.parent)
+          else
+            truthy_branch_for_if?(node)
+          end
+        end
+
+        def truthy_branch_for_if?(node)
+          if_node = node.parent
+
+          if if_node.if? || if_node.ternary?
+            if_node.if_branch == node
+          elsif if_node.unless?
+            if_node.else_branch == node
+          end
+        end
+
+        def truthy_branch_for_guard?(node)
+          if_node = node.left_sibling
+
+          if if_node.if? || if_node.ternary?
+            if_node.else_branch.nil?
+          elsif if_node.unless?
+            if_node.if_branch.nil?
+          end
+        end
+
+        def range(node)
+          buffer = node.loc.expression.source_buffer
+          map_node = node.receiver.send_node
+          begin_pos = map_node.loc.selector.begin_pos
+          end_pos = node.loc.expression.end_pos
+
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for uses of `map.to_h` or `collect.to_h` that could be
+      # written with just `to_h` in Ruby >= 2.6.
+      #
+      # NOTE: `Style/HashTransformKeys` and `Style/HashTransformValues` will
+      # also change this pattern if only hash keys or hash values are being
+      # transformed.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Enumerable`.
+      #
+      # @example
+      #   # bad
+      #   something.map { |v| [v, v * 2] }.to_h
+      #
+      #   # good
+      #   something.to_h { |v| [v, v * 2] }
+      #
+      #   # bad
+      #   {foo: bar}.collect { |k, v| [k.to_s, v.do_something] }.to_h
+      #
+      #   # good
+      #   {foo: bar}.to_h { |k, v| [k.to_s, v.do_something] }
+      #
+      class MapToHash < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Pass a block to `to_h` instead of calling `%<method>s.to_h`.'
+        RESTRICT_ON_SEND = %i[to_h].freeze
+
+        # @!method map_to_h?(node)
+        def_node_matcher :map_to_h?, <<~PATTERN
+          $(send (block $(send _ {:map :collect}) ...) :to_h)
+        PATTERN
+
+        def on_send(node)
+          return unless (to_h_node, map_node = map_to_h?(node))
+
+          message = format(MSG, method: map_node.loc.selector.source)
+          add_offense(map_node.loc.selector, message: message) do |corrector|
+            # If the `to_h` call already has a block, do not autocorrect.
+            next if to_h_node.block_node
+
+            autocorrect(corrector, to_h_node, map_node)
+          end
+        end
+
+        private
+
+        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(removal_range, side: :left))
+          corrector.replace(map.loc.selector, 'to_h')
+        end
+      end
+    end
+  end
+end