rubocop 0.82.0 → 1.18.4

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
     module Style
@@ -133,14 +132,15 @@ module RuboCop
       #     puts foo
       #   end
       #
-      class BlockDelimiters < Cop
+      class BlockDelimiters < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
+        include RangeHelp
+        extend AutoCorrector
 
         ALWAYS_BRACES_MESSAGE = 'Prefer `{...}` over `do...end` for blocks.'
 
-        BRACES_REQUIRED_MESSAGE = 'Brace delimiters `{...}` required for ' \
-          "'%<method_name>s' method."
+        BRACES_REQUIRED_MESSAGE = "Brace delimiters `{...}` required for '%<method_name>s' method."
 
         def on_send(node)
           return unless node.arguments?
@@ -159,22 +159,26 @@ module RuboCop
 
         def on_block(node)
           return if ignored_node?(node)
+          return if proper_block_style?(node)
 
-          add_offense(node, location: :begin) unless proper_block_style?(node)
+          message = message(node)
+          add_offense(node.loc.begin, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           return if correction_would_break_code?(node)
 
           if node.braces?
-            replace_braces_with_do_end(node.loc)
+            replace_braces_with_do_end(corrector, node.loc)
           else
-            replace_do_end_with_braces(node.loc)
+            replace_do_end_with_braces(corrector, node.loc)
           end
         end
 
-        private
-
         def line_count_based_message(node)
           if node.multiline?
             'Avoid using `{...}` for multi-line blocks.'
@@ -210,9 +214,7 @@ module RuboCop
         end
 
         def message(node)
-          if braces_required_method?(node.method_name)
-            return braces_required_message(node)
-          end
+          return braces_required_message(node) if braces_required_method?(node.method_name)
 
           case style
           when :line_count_based    then line_count_based_message(node)
@@ -222,40 +224,49 @@ module RuboCop
           end
         end
 
-        def replace_braces_with_do_end(loc)
+        def replace_braces_with_do_end(corrector, loc)
           b = loc.begin
           e = loc.end
 
-          lambda do |corrector|
-            corrector.insert_before(b, ' ') unless whitespace_before?(b)
-            corrector.insert_before(e, ' ') unless whitespace_before?(e)
-            corrector.insert_after(b, ' ') unless whitespace_after?(b)
-            corrector.replace(b, 'do')
-            corrector.replace(e, 'end')
+          corrector.insert_before(b, ' ') unless whitespace_before?(b)
+          corrector.insert_before(e, ' ') unless whitespace_before?(e)
+          corrector.insert_after(b, ' ') unless whitespace_after?(b)
+          corrector.replace(b, 'do')
+
+          if (comment = processed_source.comment_at_line(e.line))
+            move_comment_before_block(corrector, comment, loc.node, e)
           end
+
+          corrector.replace(e, 'end')
         end
 
-        def replace_do_end_with_braces(loc)
+        def replace_do_end_with_braces(corrector, loc)
           b = loc.begin
           e = loc.end
 
-          lambda do |corrector|
-            corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
+          corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
 
-            corrector.replace(b, '{')
-            corrector.replace(e, '}')
-          end
+          corrector.replace(b, '{')
+          corrector.replace(e, '}')
         end
 
         def whitespace_before?(range)
-          range.source_buffer.source[range.begin_pos - 1, 1] =~ /\s/
+          /\s/.match?(range.source_buffer.source[range.begin_pos - 1, 1])
         end
 
         def whitespace_after?(range, length = 1)
-          range.source_buffer.source[range.begin_pos + length, 1] =~ /\s/
+          /\s/.match?(range.source_buffer.source[range.begin_pos + length, 1])
+        end
+
+        def move_comment_before_block(corrector, comment, block_node, closing_brace)
+          range = range_between(closing_brace.end_pos, comment.loc.expression.end_pos)
+
+          corrector.remove(range_with_surrounding_space(range: range, side: :right))
+          corrector.insert_after(closing_brace, "\n")
+
+          corrector.insert_before(block_node, "#{comment.text}\n")
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def get_blocks(node, &block)
           case node.type
           when :block
@@ -273,12 +284,9 @@ module RuboCop
             node.each_child_node { |child| get_blocks(child, &block) }
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def proper_block_style?(node)
-          if special_method?(node.method_name)
-            return special_method_proper_block_style?(node)
-          end
+          return special_method_proper_block_style?(node) if special_method?(node.method_name)
 
           case style
           when :line_count_based    then line_count_based_block_style?(node)
@@ -387,4 +395,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Metrics/ClassLength

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

@@ -14,7 +14,7 @@ module RuboCop
       #   # good
       #   something.is_a?(Array)
       #   (1..100).include?(7)
-      #   some_string =~ /something/
+      #   /something/.match?(some_string)
       #
       # @example AllowOnConstant
       #   # Style/CaseEquality:
@@ -27,26 +27,54 @@ module RuboCop
       #   # good
       #   Array === something
       #   (1..100).include?(7)
-      #   some_string =~ /something/
+      #   /something/.match?(some_string)
       #
-      class CaseEquality < Cop
+      class CaseEquality < Base
+        extend AutoCorrector
+
         MSG = 'Avoid the use of the case equality operator `===`.'
+        RESTRICT_ON_SEND = %i[===].freeze
 
-        def_node_matcher :case_equality?, '(send #const? :=== _)'
+        # @!method case_equality?(node)
+        def_node_matcher :case_equality?, '(send $#const? :=== $_)'
 
         def on_send(node)
-          case_equality?(node) { add_offense(node, location: :selector) }
+          case_equality?(node) do |lhs, rhs|
+            return if lhs.const_type? && !lhs.module_name?
+
+            add_offense(node.loc.selector) do |corrector|
+              replacement = replacement(lhs, rhs)
+              corrector.replace(node, replacement) if replacement
+            end
+          end
         end
 
         private
 
         def const?(node)
           if cop_config.fetch('AllowOnConstant', false)
-            !node.const_type?
+            !node&.const_type?
           else
             true
           end
         end
+
+        def replacement(lhs, rhs)
+          case lhs.type
+          when :regexp
+            # The automatic correction from `a === b` to `a.match?(b)` needs to
+            # consider `Regexp.last_match?`, `$~`, `$1`, and etc.
+            # This correction is expected to be supported by `Performance/Regexp` cop.
+            # See: https://github.com/rubocop/rubocop-performance/issues/152
+            #
+            # So here is noop.
+          when :begin
+            child = lhs.children.first
+            "#{lhs.source}.include?(#{rhs.source})" if child&.range_type?
+          when :const
+            "#{rhs.source}.is_a?(#{lhs.source})"
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop identifies places where `if-elsif` constructions
+      # can be replaced with `case-when`.
+      #
+      # @example
+      #   # bad
+      #   if status == :active
+      #     perform_action
+      #   elsif status == :inactive || status == :hibernating
+      #     check_timeout
+      #   else
+      #     final_action
+      #   end
+      #
+      #   # good
+      #   case status
+      #   when :active
+      #     perform_action
+      #   when :inactive, :hibernating
+      #     check_timeout
+      #   else
+      #     final_action
+      #   end
+      #
+      class CaseLikeIf < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Convert `if-elsif` to `case-when`.'
+
+        def on_if(node)
+          return unless should_check?(node)
+
+          target = find_target(node.condition)
+          return unless target
+
+          conditions = []
+          convertible = true
+
+          branch_conditions(node).each do |branch_condition|
+            return false if regexp_with_working_captures?(branch_condition)
+
+            conditions << []
+            convertible = collect_conditions(branch_condition, target, conditions.last)
+            break unless convertible
+          end
+
+          return unless convertible
+
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          target = find_target(node.condition)
+
+          corrector.insert_before(node, "case #{target.source}\n#{indent(node)}")
+
+          branch_conditions(node).each do |branch_condition|
+            conditions = []
+            collect_conditions(branch_condition, target, conditions)
+
+            range = correction_range(branch_condition)
+            branch_replacement = "when #{conditions.map(&:source).join(', ')}"
+            corrector.replace(range, branch_replacement)
+          end
+        end
+
+        def should_check?(node)
+          !node.unless? && !node.elsif? && !node.modifier_form? && !node.ternary? &&
+            node.elsif_conditional?
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def find_target(node)
+          case node.type
+          when :begin
+            find_target(node.children.first)
+          when :or
+            find_target(node.lhs)
+          when :match_with_lvasgn
+            lhs, rhs = *node
+            if lhs.regexp_type?
+              rhs
+            elsif rhs.regexp_type?
+              lhs
+            end
+          when :send
+            find_target_in_send_node(node)
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def find_target_in_send_node(node)
+          case node.method_name
+          when :is_a?
+            node.receiver
+          when :==, :eql?, :equal?
+            find_target_in_equality_node(node)
+          when :===
+            node.arguments.first
+          when :include?, :cover?
+            find_target_in_include_or_cover_node(node)
+          when :match, :match?, :=~
+            find_target_in_match_node(node)
+          end
+        end
+
+        def find_target_in_equality_node(node)
+          argument = node.arguments.first
+          receiver = node.receiver
+          return unless argument && receiver
+
+          if argument.literal? || const_reference?(argument)
+            receiver
+          elsif receiver.literal? || const_reference?(receiver)
+            argument
+          end
+        end
+
+        def find_target_in_include_or_cover_node(node)
+          return unless (receiver = node.receiver)
+
+          node.first_argument if deparenthesize(receiver).range_type?
+        end
+
+        def find_target_in_match_node(node)
+          argument = node.arguments.first
+          receiver = node.receiver
+          return unless receiver
+
+          if receiver.regexp_type?
+            argument
+          elsif argument.regexp_type?
+            receiver
+          end
+        end
+
+        def collect_conditions(node, target, conditions)
+          condition =
+            case node.type
+            when :begin
+              return collect_conditions(node.children.first, target, conditions)
+            when :or
+              return collect_conditions(node.lhs, target, conditions) &&
+                     collect_conditions(node.rhs, target, conditions)
+            when :match_with_lvasgn
+              lhs, rhs = *node
+              condition_from_binary_op(lhs, rhs, target)
+            when :send
+              condition_from_send_node(node, target)
+            end
+
+          conditions << condition if condition
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def condition_from_send_node(node, target)
+          case node.method_name
+          when :is_a?
+            node.arguments.first if node.receiver == target
+          when :==, :eql?, :equal?
+            condition_from_equality_node(node, target)
+          when :=~, :match, :match?
+            condition_from_match_node(node, target)
+          when :===
+            lhs, _method, rhs = *node
+            lhs if rhs == target
+          when :include?, :cover?
+            condition_from_include_or_cover_node(node, target)
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def condition_from_equality_node(node, target)
+          lhs, _method, rhs = *node
+          condition = condition_from_binary_op(lhs, rhs, target)
+          condition if condition && !class_reference?(condition)
+        end
+
+        def condition_from_match_node(node, target)
+          lhs, _method, rhs = *node
+          condition_from_binary_op(lhs, rhs, target)
+        end
+
+        def condition_from_include_or_cover_node(node, target)
+          return unless (receiver = node.receiver)
+
+          receiver = deparenthesize(receiver)
+          receiver if receiver.range_type? && node.first_argument == target
+        end
+
+        def condition_from_binary_op(lhs, rhs, target)
+          lhs = deparenthesize(lhs)
+          rhs = deparenthesize(rhs)
+
+          if lhs == target
+            rhs
+          elsif rhs == target
+            lhs
+          end
+        end
+
+        def branch_conditions(node)
+          conditions = []
+          while node&.if_type?
+            conditions << node.condition
+            node = node.else_branch
+          end
+          conditions
+        end
+
+        def const_reference?(node)
+          return false unless node.const_type?
+
+          name = node.children[1].to_s
+
+          # We can no be sure if, e.g. `C`, represents a constant or a class reference
+          name.length > 1 && name == name.upcase
+        end
+
+        def class_reference?(node)
+          node.const_type? && node.children[1].match?(/[[:lower:]]/)
+        end
+
+        def deparenthesize(node)
+          node = node.children.last while node.begin_type?
+          node
+        end
+
+        def correction_range(node)
+          range_between(node.parent.loc.keyword.begin_pos, node.loc.expression.end_pos)
+        end
+
+        # Named captures work with `=~` (if regexp is on lhs) and with `match` (both sides)
+        def regexp_with_working_captures?(node)
+          case node.type
+          when :match_with_lvasgn
+            lhs, _rhs = *node
+            node.loc.selector.source == '=~' && regexp_with_named_captures?(lhs)
+          when :send
+            lhs, method, rhs = *node
+            method == :match && [lhs, rhs].any? { |n| regexp_with_named_captures?(n) }
+          end
+        end
+
+        def regexp_with_named_captures?(node)
+          node.regexp_type? && node.each_capture(named: true).count.positive?
+        end
+      end
+    end
+  end
+end