rubocop 1.29.1 → 1.46.0

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

@@ -3,7 +3,7 @@
 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.
       #
@@ -12,7 +12,7 @@ module RuboCop
       # in a future major RuboCop release.
       #
       # @safety
-      #   Auto-correction is unsafe because changing the order of method invocations
+      #   Autocorrection is unsafe because changing the order of method invocations
       #   may change the behavior of the code. For example:
       #
       #   [source,ruby]
@@ -136,6 +136,7 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_branches(node, branches)
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else` or a branch that contains only comments.
@@ -144,9 +145,13 @@ module RuboCop
           tails = branches.map { |branch| tail(branch) }
           check_expressions(node, tails, :after_condition) if duplicated_expressions?(node, tails)
 
+          return if last_child_of_parent?(node) &&
+                    branches.any? { |branch| single_child_branch?(branch) }
+
           heads = branches.map { |branch| head(branch) }
           check_expressions(node, heads, :before_condition) if duplicated_expressions?(node, heads)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def duplicated_expressions?(node, expressions)
           unique_expressions = expressions.uniq
@@ -180,6 +185,16 @@ module RuboCop
           end
         end
 
+        def last_child_of_parent?(node)
+          return true unless (parent = node.parent)
+
+          parent.child_nodes.last == node
+        end
+
+        def single_child_branch?(branch_node)
+          !branch_node.begin_type? || branch_node.children.size == 1
+        end
+
         def message(node)
           format(MSG, source: node.source)
         end

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

@@ -96,7 +96,7 @@ module RuboCop
           return false unless max_line_length
 
           range = node.source_range
-          return false unless range.first_line == range.last_line
+          return false unless range.single_line?
           return false unless line_length_enabled_at_line?(range.first_line)
 
           line = range.source_line

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

@@ -3,12 +3,31 @@
 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.
+      # The conditions to be checked are comparison methods, predicate methods, and
+      # double negation (!!).
+      # `nonzero?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
+      #
+      # This cop targets only `if`s with a single `elsif` or `else` branch. The following
+      # code will be allowed, because it has two `elsif` branches:
+      #
+      # [source,ruby]
+      # ----
+      # if foo
+      #   true
+      # elsif bar > baz
+      #   true
+      # elsif qux > quux # Single `elsif` is warned, but two or more `elsif`s are not.
+      #   true
+      # else
+      #   false
+      # end
+      # ----
       #
       # @safety
-      #   Auto-correction is unsafe because there is no guarantee that all predicate methods
+      #   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
@@ -55,7 +74,7 @@ module RuboCop
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
         def on_if(node)
-          return unless if_with_boolean_literal_branches?(node)
+          return if !if_with_boolean_literal_branches?(node) || multiple_elsif?(node)
 
           condition = node.condition
           range, keyword = offense_range_with_keyword(node, condition)
@@ -74,6 +93,12 @@ module RuboCop
 
         private
 
+        def multiple_elsif?(node)
+          return false unless (parent = node.parent)
+
+          parent.if_type? && parent.elsif?
+        end
+
         def offense_range_with_keyword(node, condition)
           if node.ternary?
             range = condition.source_range.end.join(node.source_range.end)

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

@@ -21,13 +21,12 @@ module RuboCop
         MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
 
         def on_normal_if_unless(node)
-          return unless node.else_branch
           return if node.parent&.if_type?
 
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
-          message = node.else_branch.if_type? ? MSG_IF_ELSE : MSG_TERNARY
+          message = node.else_branch&.if_type? ? MSG_IF_ELSE : MSG_TERNARY
 
           add_offense(node, message: format(message, expr: node.condition.source)) do |corrector|
             corrector.replace(node, autocorrect(node))
@@ -37,11 +36,12 @@ module RuboCop
         private
 
         def autocorrect(node)
-          return correct_elsif(node) if node.else_branch.if_type?
+          return correct_elsif(node) if node.else_branch&.if_type?
 
+          then_code = node.if_branch ? node.if_branch.source : 'nil'
           else_code = node.else_branch ? node.else_branch.source : 'nil'
 
-          "#{node.condition.source} ? #{node.if_branch.source} : #{else_code}"
+          "#{node.condition.source} ? #{then_code} : #{else_code}"
         end
 
         def correct_elsif(node)

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

@@ -21,6 +21,7 @@ module RuboCop
       #     work
       #   end
       class InfiniteLoop < Base
+        include Alignment
         extend AutoCorrector
 
         LEADING_SPACE = /\A(\s*)/.freeze
@@ -106,7 +107,7 @@ module RuboCop
           else
             indentation = body.source_range.source_line[LEADING_SPACE]
 
-            ['loop do', body.source.gsub(/^/, configured_indent), 'end'].join("\n#{indentation}")
+            ['loop do', body.source.gsub(/^/, indentation(node)), 'end'].join("\n#{indentation}")
           end
         end
 
@@ -120,10 +121,6 @@ module RuboCop
 
           start_range.join(end_range)
         end
-
-        def configured_indent
-          ' ' * config.for_cop('Layout/IndentationWidth')['Width']
-        end
       end
     end
   end

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,7 +3,7 @@
 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
@@ -51,6 +51,8 @@ module RuboCop
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
 
+        RESTRICT_ON_SEND = [:!].freeze
+
         def self.autocorrect_incompatible_with
           [Style::Not, Style::SymbolProc]
         end
@@ -59,18 +61,18 @@ module RuboCop
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
             (send $(send $(...) $_ $...) :!)
-            (send (block $(send $(...) $_) $...) :!)
+            (send ({block numblock} $(send $(...) $_) $...) :!)
             (send (begin $(send $(...) $_ $...)) :!)
           }
         PATTERN
 
         # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
-          (block $(send (...) $_) ... { $(send ... :!)
-                                        $(send (...) {:!= :!~} ...)
-                                        (begin ... $(send ... :!))
-                                        (begin ... $(send (...) {:!= :!~} ...))
-                                      })
+          ({block numblock} $(send (...) $_) ... { $(send ... :!)
+                                                   $(send (...) {:!= :!~} ...)
+                                                   (begin ... $(send ... :!))
+                                                   (begin ... $(send (...) {:!= :!~} ...))
+                                                 })
         PATTERN
 
         def on_send(node)
@@ -94,7 +96,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)
@@ -102,6 +104,8 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
         def correct_inverse_method(corrector, node)

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usages of `unless` which can be replaced by `if` with inverted condition.
+      # Code without `unless` is easier to read, but that is subjective, so this cop
+      # is disabled by default.
+      #
+      # Methods that can be inverted should be defined in `InverseMethods`. Note that
+      # the relationship of inverse methods needs to be defined in both directions.
+      # For example,
+      #   InverseMethods:
+      #     :!=: :==
+      #     :even?: :odd?
+      #     :odd?: :even?
+      #
+      #  will suggest both `even?` and `odd?` to be inverted, but only `!=` (and not `==`).
+      #
+      # @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 (simple condition)
+      #   foo unless !bar
+      #   foo unless x != y
+      #   foo unless x >= 10
+      #   foo unless x.even?
+      #
+      #   # good
+      #   foo if bar
+      #   foo if x == y
+      #   foo if x < 10
+      #   foo if x.odd?
+      #
+      #   # bad (complex condition)
+      #   foo unless x != y || x.even?
+      #
+      #   # good
+      #   foo if x == y && x.odd?
+      #
+      #   # good (if)
+      #   foo if !condition
+      #
+      class InvertibleUnlessCondition < Base
+        extend AutoCorrector
+
+        MSG = 'Favor `if` with inverted condition over `unless`.'
+
+        def on_if(node)
+          return unless node.unless?
+
+          condition = node.condition
+          return unless invertible?(condition)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node.loc.keyword, node.inverse_keyword)
+            autocorrect(corrector, condition)
+          end
+        end
+
+        private
+
+        def invertible?(node)
+          case node.type
+          when :begin
+            invertible?(node.children.first)
+          when :send
+            return if inheritance_check?(node)
+
+            node.method?(:!) || inverse_methods.key?(node.method_name)
+          when :or, :and
+            invertible?(node.lhs) && invertible?(node.rhs)
+          else
+            false
+          end
+        end
+
+        def inheritance_check?(node)
+          argument = node.first_argument
+          node.method?(:<) &&
+            (argument.const_type? && argument.short_name.to_s.upcase != argument.short_name.to_s)
+        end
+
+        def autocorrect(corrector, node)
+          case node.type
+          when :begin
+            autocorrect(corrector, node.children.first)
+          when :send
+            autocorrect_send_node(corrector, node)
+          when :or, :and
+            corrector.replace(node.loc.operator, node.inverse_operator)
+            autocorrect(corrector, node.lhs)
+            autocorrect(corrector, node.rhs)
+          end
+        end
+
+        def autocorrect_send_node(corrector, node)
+          if node.method?(:!)
+            corrector.remove(node.loc.selector)
+          else
+            corrector.replace(node.loc.selector, inverse_methods[node.method_name])
+          end
+        end
+
+        def inverse_methods
+          @inverse_methods ||= cop_config['InverseMethods']
+        end
+      end
+    end
+  end
+end

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

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

@@ -3,7 +3,7 @@
 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
@@ -55,7 +55,10 @@ module RuboCop
         private
 
         def check_token_set(index)
-          predecessor, operator, successor = processed_source.tokens[index, 3]
+          tokens = processed_source.tokens
+          predecessor = tokens[index]
+          operator = tokens[index + 1]
+          successor = tokens[index + 2]
 
           return unless eligible_token_set?(predecessor, operator, successor)
 
@@ -70,7 +73,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)