rubocop 0.93.1 → 1.79.2

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

@@ -3,17 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of `_.each_with_object({}) {...}`,
-      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # Looks for uses of `+_.each_with_object({}) {...}+`,
+      # `+_.map {...}.to_h+`, and `+Hash[_.map {...}]+` that are actually just
       # transforming the values of a hash, and tries to use a simpler & faster
       # call to `transform_values` instead.
       #
-      # This can produce false positives if we are transforming an enumerable
-      # of key-value-like pairs that isn't actually a hash, e.g.:
-      # `[[k1, v1], [k2, v2], ...]`
-      #
-      # This cop should only be enabled on Ruby version 2.4 or newer
-      # (`transform_values` was added in Ruby 2.4.)
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if we are
+      #   transforming an enumerable of key-value-like pairs that isn't actually
+      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
       #
       # @example
       #   # bad
@@ -28,34 +26,40 @@ module RuboCop
       class HashTransformValues < Base
         include HashTransformMethod
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
 
+        # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend} !#array_receiver? :each_with_object (hash))
+            (call !#array_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg _key)
                 (arg $_))
               (arg _memo))
-            ({send csend} (lvar _memo) :[]= $(lvar _key) $!`_memo))
+            (call (lvar _memo) :[]= $(lvar _key) $!`_memo))
         PATTERN
 
+        # @!method on_bad_hash_brackets_map(node)
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
           (send
             (const _ :Hash)
             :[]
             (block
-              ({send csend} !#array_receiver? {:map :collect})
+              (call !#array_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
               (array $(lvar _key) $_)))
         PATTERN
 
+        # @!method on_bad_map_to_h(node)
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
-          ({send csend}
+          (call
             (block
-              ({send csend} !#array_receiver? {:map :collect})
+              (call !#array_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -63,9 +67,10 @@ module RuboCop
             :to_h)
         PATTERN
 
+        # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            ({send csend} !#array_receiver? :to_h)
+            (call !#array_receiver? :to_h)
             (args
               (arg _key)
               (arg $_))

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

@@ -3,8 +3,31 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for identical lines at the beginning or end of
-      # each branch of a conditional statement.
+      # 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.
+      #
+      # 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
@@ -62,44 +85,164 @@ module RuboCop
       #     do_x
       #     do_z
       #   end
+      #
+      #   # bad
+      #   case foo
+      #   in 1
+      #     do_x
+      #   in 2
+      #     do_x
+      #   else
+      #     do_x
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   in 1
+      #     do_x
+      #     do_y
+      #   in 2
+      #     # nothing
+      #   else
+      #     do_x
+      #     do_z
+      #   end
       class IdenticalConditionalBranches < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Move `%<source>s` out of the conditional.'
 
         def on_if(node)
           return if node.elsif?
 
           branches = expand_elses(node.else_branch).unshift(node.if_branch)
-          check_branches(branches)
+          check_branches(node, branches)
         end
 
         def on_case(node)
           return unless node.else? && node.else_branch
 
           branches = node.when_branches.map(&:body).push(node.else_branch)
-          check_branches(branches)
+          check_branches(node, branches)
+        end
+
+        def on_case_match(node)
+          return unless node.else? && node.else_branch
+
+          branches = node.in_pattern_branches.map(&:body).push(node.else_branch)
+          check_branches(node, branches)
         end
 
         private
 
-        def check_branches(branches) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, 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.
           return if branches.any?(&:nil?)
 
           tails = branches.map { |branch| tail(branch) }
-          check_expressions(tails) if tails.none?(&:nil?)
+          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(heads) if tails.none?(&:nil?)
+
+          return unless duplicated_expressions?(node, heads)
+
+          condition_variable = assignable_condition_value(node)
+
+          head = heads.first
+          if head.respond_to?(:assignment?) && head.assignment?
+            # The `send` node is used instead of the `indexasgn` node, so `name` cannot be used.
+            # https://github.com/rubocop/rubocop-ast/blob/v1.29.0/lib/rubocop/ast/node/indexasgn_node.rb
+            #
+            # FIXME: It would be better to update `RuboCop::AST::OpAsgnNode` or its subclasses to
+            # handle `self.foo ||= value` as a solution, instead of using `head.node_parts[0].to_s`.
+            assigned_value = head.send_type? ? head.receiver.source : head.node_parts[0].to_s
+
+            return if condition_variable == assigned_value
+          end
+
+          check_expressions(node, heads, :before_condition)
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        def check_expressions(expressions)
-          return unless expressions.size > 1 && expressions.uniq.one?
+        def duplicated_expressions?(node, expressions)
+          unique_expressions = expressions.uniq
+          return false unless expressions.size >= 1 && unique_expressions.one?
+
+          unique_expression = unique_expressions.first
+          return true unless unique_expression&.assignment?
+
+          lhs = unique_expression.child_nodes.first
+          node.condition.child_nodes.none? { |n| n.source == lhs.source if n.variable? }
+        end
+
+        def assignable_condition_value(node)
+          if node.condition.call_type?
+            (receiver = node.condition.receiver) ? receiver.source : node.condition.source
+          elsif node.condition.variable?
+            node.condition.source
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def check_expressions(node, expressions, insert_position)
+          return if expressions.any?(&:nil?)
+
+          inserted_expression = false
 
           expressions.each do |expression|
-            add_offense(expression)
+            add_offense(expression) do |corrector|
+              next if node.if_type? && (node.ternary? || node.then?)
+
+              range = range_by_whole_lines(expression.source_range, include_final_newline: true)
+              corrector.remove(range)
+              next if inserted_expression
+
+              if node.parent&.assignment?
+                correct_assignment(corrector, node, expression, insert_position)
+              else
+                correct_no_assignment(corrector, node, expression, insert_position)
+              end
+
+              inserted_expression = true
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        def correct_assignment(corrector, node, expression, insert_position)
+          if insert_position == :after_condition
+            assignment = node.parent.source_range.with(end_pos: node.source_range.begin_pos)
+            corrector.remove(assignment)
+            corrector.insert_after(node, "\n#{assignment.source}#{expression.source}")
+          else
+            corrector.insert_before(node.parent, "#{expression.source}\n")
           end
         end
 
+        def correct_no_assignment(corrector, node, expression, insert_position)
+          if insert_position == :after_condition
+            corrector.insert_after(node, "\n#{expression.source}")
+          else
+            corrector.insert_before(node, "#{expression.source}\n")
+          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_inside_else.rb

@@ -59,21 +59,86 @@ module RuboCop
       #   end
       #
       class IfInsideElse < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_if(node)
           return if node.ternary? || node.unless?
 
           else_branch = node.else_branch
 
-          return unless else_branch&.if_type? && else_branch&.if?
+          return unless else_branch&.if_type? && else_branch.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
 
-          add_offense(else_branch.loc.keyword)
+          add_offense(else_branch.loc.keyword) do |corrector|
+            next if part_of_ignored_node?(node)
+
+            autocorrect(corrector, else_branch)
+            ignore_node(node)
+          end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         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
+        end
+
+        def correct_to_elsif_from_modifier_form(corrector, node)
+          corrector.replace(node.parent.loc.else, "elsif #{node.condition.source}")
+
+          condition_range = range_between(
+            node.if_branch.source_range.end_pos, node.condition.source_range.end_pos
+          )
+          corrector.remove(condition_range)
+        end
+
+        def correct_to_elsif_from_if_inside_else_form(corrector, node, condition) # rubocop:disable Metrics/AbcSize
+          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, range_with_comments(if_branch).source)
+            corrector.remove(range_with_comments_and_lines(if_branch))
+          else
+            corrector.remove(range_by_whole_lines(if_condition_range, include_final_newline: true))
+          end
+
+          corrector.remove(condition)
+          corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
+        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
+
+          find_end_range(node.parent)
+        end
+
+        def if_condition_range(node, condition)
+          range_between(node.loc.keyword.begin_pos, condition.source_range.end_pos)
+        end
+
         def allow_if_modifier_in_else_branch?(else_branch)
           allow_if_modifier? && else_branch&.modifier_form?
         end

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

@@ -11,6 +11,43 @@ module RuboCop
       # cop. The tab size is configured in the `IndentationWidth` of the
       # `Layout/IndentationStyle` cop.
       #
+      # One-line pattern matching is always allowed. To ensure that there are few cases
+      # where the match variable is not used, and to prevent oversights. The variable `x`
+      # becomes undefined and raises `NameError` when the following example is changed to
+      # the modifier form:
+      #
+      # [source,ruby]
+      # ----
+      # if [42] in [x]
+      #   x # `x` is undefined when using modifier form.
+      # end
+      # ----
+      #
+      # The code `def method_name = body if condition` is considered a bad case by
+      # `Style/AmbiguousEndlessMethodDefinition` cop. So, to respect the user's intention to use
+      # an endless method definition in the `if` body, the following code is allowed:
+      #
+      # [source,ruby]
+      # ----
+      # if condition
+      #   def method_name = body
+      # end
+      # ----
+      #
+      # NOTE: It is allowed when `defined?` argument has an undefined value,
+      # because using the modifier form causes the following incompatibility:
+      #
+      # [source,ruby]
+      # ----
+      # unless defined?(undefined_foo)
+      #   undefined_foo = 'default_value'
+      # end
+      # undefined_foo # => 'default_value'
+      #
+      # undefined_bar = 'default_value' unless defined?(undefined_bar)
+      # undefined_bar # => nil
+      # ----
+      #
       # @example
       #   # bad
       #   if condition
@@ -21,65 +58,144 @@ module RuboCop
       #     Foo.do_something
       #   end
       #
-      #   do_something_in_a_method_with_a_long_name(arg) if long_condition
+      #   do_something_with_a_long_name(arg) if long_condition_that_prevents_code_fit_on_single_line
       #
       #   # good
       #   do_stuff(bar) if condition
       #   Foo.do_something unless qux.empty?
       #
-      #   if long_condition
-      #     do_something_in_a_method_with_a_long_name(arg)
+      #   if long_condition_that_prevents_code_fit_on_single_line
+      #     do_something_with_a_long_name(arg)
+      #   end
+      #
+      #   if short_condition # a long comment that makes it too long if it were just a single line
+      #     do_something
       #   end
       class IfUnlessModifier < Base
         include StatementModifier
         include LineLengthHelp
-        include IgnoredPattern
+        include AllowedPattern
+        include RangeHelp
+        include CommentsHelp
         extend AutoCorrector
 
         MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
                            'single-line body. Another good alternative is ' \
                            'the usage of control flow `&&`/`||`.'
-        MSG_USE_NORMAL =
-          'Modifier form of `%<keyword>s` makes the line too long.'
+        MSG_USE_NORMAL = 'Modifier form of `%<keyword>s` makes the line too long.'
 
+        def self.autocorrect_incompatible_with
+          [Style::SoleNestedConditional]
+        end
+
+        # rubocop:disable Metrics/AbcSize
         def on_if(node)
-          msg = if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
-                  MSG_USE_MODIFIER
-                elsif too_long_due_to_modifier?(node)
-                  MSG_USE_NORMAL
-                end
-          return unless msg
+          return if endless_method?(node.body)
+
+          condition = node.condition
+          return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
+                    pattern_matching_nodes(condition).any?
+
+          return unless (msg = message(node))
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, node)
+            ignore_node(node)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
+        def endless_method?(body)
+          body&.any_def_type? && body.endless?
+        end
+
+        def defined_nodes(condition)
+          if condition.defined_type?
+            [condition]
+          else
+            condition.each_descendant.select(&:defined_type?)
+          end
+        end
+
+        def defined_argument_is_undefined?(if_node, defined_node)
+          defined_argument = defined_node.first_argument
+          return false unless defined_argument.type?(:lvar, :send)
+
+          if_node.left_siblings.none? do |sibling|
+            sibling.respond_to?(:lvasgn_type?) && sibling.lvasgn_type? &&
+              sibling.name == defined_argument.node_parts[0]
+          end
+        end
+
+        def pattern_matching_nodes(condition)
+          if condition.any_match_pattern_type?
+            [condition]
+          else
+            condition.each_descendant.select(&:any_match_pattern_type?)
+          end
+        end
+
+        def message(node)
+          if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
+            MSG_USE_MODIFIER
+          elsif too_long_due_to_modifier?(node)
+            MSG_USE_NORMAL
+          end
+        end
+
         def autocorrect(corrector, node)
           replacement = if node.modifier_form?
-                          to_normal_form(node)
+                          replacement_for_modifier_form(corrector, node)
                         else
                           to_modifier_form(node)
                         end
           corrector.replace(node, replacement)
         end
 
+        def replacement_for_modifier_form(corrector, node) # rubocop:disable Metrics/AbcSize
+          comment = comment_on_node_line(node)
+          if comment && too_long_due_to_comment_after_modifier?(node, comment)
+            remove_comment(corrector, node, comment)
+
+            return to_modifier_form_with_move_comment(node, indent(node), comment)
+          end
+
+          last_argument = node.if_branch.last_argument if node.if_branch.send_type?
+          if last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
+            heredoc = extract_heredoc_from(last_argument)
+            remove_heredoc(corrector, heredoc)
+
+            return to_normal_form_with_heredoc(node, indent(node), heredoc)
+          end
+
+          to_normal_form(node, indent(node))
+        end
+
         def too_long_due_to_modifier?(node)
           node.modifier_form? && too_long_single_line?(node) &&
             !another_statement_on_same_line?(node)
         end
 
-        def ignored_patterns
-          config.for_cop('Layout/LineLength')['IgnoredPatterns'] || []
+        def too_long_due_to_comment_after_modifier?(node, comment)
+          source_length = processed_source.lines[node.first_line - 1].length
+
+          max_line_length.between?(source_length - comment.source_range.length, source_length)
+        end
+
+        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)
           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
@@ -89,7 +205,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
@@ -107,16 +223,24 @@ module RuboCop
 
         def too_long_line_based_on_allow_uri?(line)
           if allow_uri?
-            uri_range = find_excessive_uri_range(line)
-            return false if uri_range && allowed_uri_position?(line, uri_range)
+            uri_range = find_excessive_range(line, :uri)
+            return false if uri_range && allowed_position?(line, uri_range)
+          end
+
+          true
+        end
+
+        def too_long_line_based_on_allow_qualified_name?(line)
+          if allow_qualified_name?
+            namespace_range = find_excessive_range(line, :namespace)
+            return false if namespace_range && allowed_position?(line, namespace_range)
           end
 
           true
         end
 
         def line_length_enabled_at_line?(line)
-          processed_source.comment_config
-                          .cop_enabled_at_line?('Layout/LineLength', line)
+          processed_source.comment_config.cop_enabled_at_line?('Layout/LineLength', line)
         end
 
         def named_capture_in_condition?(node)
@@ -124,10 +248,7 @@ module RuboCop
         end
 
         def non_eligible_node?(node)
-          non_simple_if_unless?(node) ||
-            node.chained? ||
-            node.nested_conditional? ||
-            super
+          non_simple_if_unless?(node) || node.chained? || node.nested_conditional? || super
         end
 
         def non_simple_if_unless?(node)
@@ -145,18 +266,56 @@ module RuboCop
             node  = node.parent
           end
 
-          node && (sibling = node.children[index + 1]) &&
-            sibling.source_range.first_line == line_no
+          node && (sibling = node.children[index + 1]) && sibling.source_range.first_line == line_no
         end
 
-        def to_normal_form(node)
-          indentation = ' ' * node.source_range.column
+        def to_normal_form(node, indentation)
           <<~RUBY.chomp
             #{node.keyword} #{node.condition.source}
             #{indentation}  #{node.body.source}
             #{indentation}end
           RUBY
         end
+
+        def to_normal_form_with_heredoc(node, indentation, heredoc)
+          heredoc_body, heredoc_end = heredoc
+
+          <<~RUBY.chomp
+            #{node.keyword} #{node.condition.source}
+            #{indentation}  #{node.body.source}
+            #{indentation}  #{heredoc_body.source.chomp}
+            #{indentation}  #{heredoc_end.source.chomp}
+            #{indentation}end
+          RUBY
+        end
+
+        def to_modifier_form_with_move_comment(node, indentation, comment)
+          <<~RUBY.chomp
+            #{comment.source}
+            #{indentation}#{node.body.source} #{node.keyword} #{node.condition.source}
+          RUBY
+        end
+
+        def extract_heredoc_from(last_argument)
+          heredoc_body = last_argument.loc.heredoc_body
+          heredoc_end = last_argument.loc.heredoc_end
+
+          [heredoc_body, heredoc_end]
+        end
+
+        def remove_heredoc(corrector, heredoc)
+          heredoc.each do |range|
+            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+          end
+        end
+
+        def comment_on_node_line(node)
+          processed_source.comments.find { |c| same_line?(c, node) }
+        end
+
+        def remove_comment(corrector, _node, comment)
+          corrector.remove(range_with_surrounding_space(range: comment.source_range, side: :left))
+        end
       end
     end
   end