rubocop 0.48.1 → 1.16.0

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

@@ -4,13 +4,76 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for uses of the case equality operator(===).
-      class CaseEquality < Cop
-        MSG = 'Avoid the use of the case equality operator `===`.'.freeze
+      #
+      # @example
+      #   # bad
+      #   Array === something
+      #   (1..100) === 7
+      #   /something/ === some_string
+      #
+      #   # good
+      #   something.is_a?(Array)
+      #   (1..100).include?(7)
+      #   /something/.match?(some_string)
+      #
+      # @example AllowOnConstant
+      #   # Style/CaseEquality:
+      #   #   AllowOnConstant: true
+      #
+      #   # bad
+      #   (1..100) === 7
+      #   /something/ === some_string
+      #
+      #   # good
+      #   Array === something
+      #   (1..100).include?(7)
+      #   /something/.match?(some_string)
+      #
+      class CaseEquality < Base
+        extend AutoCorrector
 
-        def_node_matcher :case_equality?, '(send _ :=== _)'
+        MSG = 'Avoid the use of the case equality operator `===`.'
+        RESTRICT_ON_SEND = %i[===].freeze
+
+        # @!method case_equality?(node)
+        def_node_matcher :case_equality?, '(send $#const? :=== $_)'
 
         def on_send(node)
-          case_equality?(node) { add_offense(node, :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?
+          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

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

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

@@ -4,29 +4,36 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of the character literal ?x.
-      class CharacterLiteral < Cop
+      #
+      # @example
+      #   # bad
+      #   ?x
+      #
+      #   # good
+      #   'x'
+      #
+      #   # good
+      #   ?\C-\M-d
+      class CharacterLiteral < Base
         include StringHelp
+        extend AutoCorrector
 
-        MSG = 'Do not use the character literal - ' \
-              'use string literal instead.'.freeze
+        MSG = 'Do not use the character literal - use string literal instead.'
 
         def offense?(node)
           # we don't register an offense for things like ?\C-\M-d
-          node.loc.begin.is?('?') &&
-            node.source.size.between?(2, 3)
+          node.loc.begin.is?('?') && node.source.size.between?(2, 3)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            string = node.source[1..-1]
+        def autocorrect(corrector, node)
+          string = node.source[1..-1]
 
-            # special character like \n
-            # or ' which needs to use "" or be escaped.
-            if string.length == 2 || string == "'"
-              corrector.replace(node.source_range, %("#{string}"))
-            elsif string.length == 1 # normal character
-              corrector.replace(node.source_range, "'#{string}'")
-            end
+          # special character like \n
+          # or ' which needs to use "" or be escaped.
+          if string.length == 2 || string == "'"
+            corrector.replace(node, %("#{string}"))
+          elsif string.length == 1 # normal character
+            corrector.replace(node, "'#{string}'")
           end
         end
 

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

@@ -6,39 +6,125 @@ module RuboCop
       # This cop checks the style of children definitions at classes and
       # modules. Basically there are two different styles:
       #
-      # nested - have each child on its own line
+      # @example EnforcedStyle: nested (default)
+      #   # good
+      #   # have each child on its own line
       #   class Foo
       #     class Bar
       #     end
       #   end
       #
-      # compact - combine definitions as much as possible
+      # @example EnforcedStyle: compact
+      #   # good
+      #   # combine definitions as much as possible
       #   class Foo::Bar
       #   end
       #
       # The compact style is only forced for classes/modules with one child.
-      class ClassAndModuleChildren < Cop
+      class ClassAndModuleChildren < Base
         include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
 
-        NESTED_MSG = 'Use nested module/class definitions instead of ' \
-                     'compact style.'.freeze
-        COMPACT_MSG = 'Use compact module/class definition instead of ' \
-                      'nested style.'.freeze
+        NESTED_MSG = 'Use nested module/class definitions instead of compact style.'
+        COMPACT_MSG = 'Use compact module/class definition instead of nested style.'
 
         def on_class(node)
-          _name, superclass, body = *node
-          return if superclass && style != :nested
-          check_style(node, body)
+          return if node.parent_class && style != :nested
+
+          check_style(node, node.body)
         end
 
         def on_module(node)
-          _name, body = *node
-          check_style(node, body)
+          check_style(node, node.body)
         end
 
         private
 
+        def nest_or_compact(corrector, node)
+          if style == :nested
+            nest_definition(corrector, node)
+          else
+            compact_definition(corrector, node)
+          end
+        end
+
+        def nest_definition(corrector, node)
+          padding = ((' ' * indent_width) + leading_spaces(node)).to_s
+          padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
+
+          replace_namespace_keyword(corrector, node)
+          split_on_double_colon(corrector, node, padding)
+          add_trailing_end(corrector, node, padding_for_trailing_end)
+        end
+
+        def replace_namespace_keyword(corrector, node)
+          class_definition = node.left_sibling&.each_node(:class)&.find do |class_node|
+            class_node.identifier == node.identifier.namespace
+          end
+          namespace_keyword = class_definition ? 'class' : 'module'
+
+          corrector.replace(node.loc.keyword, namespace_keyword)
+        end
+
+        def split_on_double_colon(corrector, node, padding)
+          children_definition = node.children.first
+          range = range_between(children_definition.loc.double_colon.begin_pos,
+                                children_definition.loc.double_colon.end_pos)
+          replacement = "\n#{padding}#{node.loc.keyword.source} "
+
+          corrector.replace(range, replacement)
+        end
+
+        def add_trailing_end(corrector, node, padding)
+          replacement = "#{padding}end\n#{leading_spaces(node)}end"
+          corrector.replace(node.loc.end, replacement)
+        end
+
+        def compact_definition(corrector, node)
+          compact_node(corrector, node)
+          remove_end(corrector, node.body)
+        end
+
+        def compact_node(corrector, node)
+          range = range_between(node.loc.keyword.begin_pos, node.body.loc.name.end_pos)
+          corrector.replace(range, compact_replacement(node))
+        end
+
+        def compact_replacement(node)
+          replacement = "#{node.body.type} #{compact_identifier_name(node)}"
+
+          body_comments = processed_source.ast_with_comments[node.body]
+          unless body_comments.empty?
+            replacement = body_comments.map(&:text).push(replacement).join("\n")
+          end
+          replacement
+        end
+
+        def compact_identifier_name(node)
+          "#{node.identifier.const_name}::" \
+            "#{node.body.children.first.const_name}"
+        end
+
+        def remove_end(corrector, body)
+          range = range_between(
+            body.loc.end.begin_pos - leading_spaces(body).size,
+            body.loc.end.end_pos + 1
+          )
+          corrector.remove(range)
+        end
+
+        def leading_spaces(node)
+          node.source_range.source_line[/\A\s*/]
+        end
+
+        def indent_width
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
+        end
+
         def check_style(node, body)
+          return if node.identifier.children[0]&.cbase_type?
+
           if style == :nested
             check_nested_style(node)
           else
@@ -48,20 +134,35 @@ module RuboCop
 
         def check_nested_style(node)
           return unless compact_node_name?(node)
-          add_offense(node, :name, NESTED_MSG)
+
+          add_offense(node.loc.name, message: NESTED_MSG) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def check_compact_style(node, body)
-          return unless one_child?(body) && !compact_node_name?(node)
-          add_offense(node, :name, COMPACT_MSG)
+          parent = node.parent
+          return if parent&.class_type? || parent&.module_type?
+
+          return unless needs_compacting?(body)
+
+          add_offense(node.loc.name, message: COMPACT_MSG) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          return if node.class_type? && node.parent_class && style != :nested
+
+          nest_or_compact(corrector, node)
         end
 
-        def one_child?(body)
+        def needs_compacting?(body)
           body && %i[module class].include?(body.type)
         end
 
         def compact_node_name?(node)
-          node.loc.name.source =~ /::/
+          /::/.match?(node.identifier.source)
         end
       end
     end