rubocop 0.85.1 → 0.89.0

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

@@ -245,14 +245,13 @@ module RuboCop
         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
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def get_blocks(node, &block)
           case node.type
           when :block
@@ -270,7 +269,6 @@ module RuboCop
             node.each_child_node { |child| get_blocks(child, &block) }
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def proper_block_style?(node)
           return special_method_proper_block_style?(node) if special_method?(node.method_name)

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

@@ -29,13 +29,20 @@ module RuboCop
       #   (1..100).include?(7)
       #   some_string =~ /something/
       #
-      class CaseEquality < Cop
+      class CaseEquality < Base
+        extend AutoCorrector
+
         MSG = 'Avoid the use of the case equality operator `===`.'
 
-        def_node_matcher :case_equality?, '(send #const? :=== _)'
+        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|
+            add_offense(node.loc.selector) do |corrector|
+              replacement = replacement(lhs, rhs)
+              corrector.replace(node, replacement) if replacement
+            end
+          end
         end
 
         private
@@ -47,6 +54,18 @@ module RuboCop
             true
           end
         end
+
+        def replacement(lhs, rhs)
+          case lhs.type
+          when :regexp
+            "#{rhs.source} =~ #{lhs.source}"
+          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,217 @@
+# 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 < Cop
+        include RangeHelp
+
+        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|
+            conditions << []
+            convertible = collect_conditions(branch_condition, target, conditions.last)
+            break unless convertible
+          end
+
+          add_offense(node) if convertible
+        end
+
+        def autocorrect(node)
+          target = find_target(node.condition)
+
+          lambda do |corrector|
+            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
+        end
+
+        private
+
+        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?
+            receiver = deparenthesize(node.receiver)
+            node.arguments.first if receiver.range_type?
+          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 receiver
+
+          if argument.literal? || const_reference?(argument)
+            receiver
+          elsif receiver.literal? || const_reference?(receiver)
+            argument
+          end
+        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?, :=~, :match, :match?
+            lhs, _method, rhs = *node
+            condition_from_binary_op(lhs, rhs, target)
+          when :===
+            lhs, _method, rhs = *node
+            lhs if rhs == target
+          when :include?, :cover?
+            receiver = deparenthesize(node.receiver)
+            receiver if receiver.range_type? && node.arguments.first == target
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        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 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
+
+        def indent(node)
+          ' ' * node.loc.column
+        end
+      end
+    end
+  end
+end

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

@@ -143,7 +143,7 @@ module RuboCop
         end
 
         def compact_node_name?(node)
-          node.loc.name.source =~ /::/
+          /::/.match?(node.loc.name.source)
         end
       end
     end

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

@@ -19,6 +19,15 @@ module RuboCop
       #     @@test = 10
       #   end
       #
+      #   class A
+      #     def self.test(name, value)
+      #       class_variable_set("@@#{name}", value)
+      #     end
+      #   end
+      #
+      #   class A; end
+      #   A.class_variable_set(:@@test, 10)
+      #
       #   # good
       #   class A
       #     @test = 10
@@ -30,6 +39,12 @@ module RuboCop
       #     end
       #   end
       #
+      #   class A
+      #     def self.test(name)
+      #       class_variable_get("@@#{name}") # you can access without offense
+      #     end
+      #   end
+      #
       class ClassVars < Cop
         MSG = 'Replace class var %<class_var>s with a class ' \
               'instance var.'
@@ -38,6 +53,12 @@ module RuboCop
           add_offense(node, location: :name)
         end
 
+        def on_send(node)
+          return unless node.method?(:class_variable_set)
+
+          add_offense(node.first_argument)
+        end
+
         def message(node)
           class_var, = *node
           format(MSG, class_var: class_var)

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

@@ -30,12 +30,12 @@ module RuboCop
         end
 
         def on_send(node)
-          # ignore Java interop code like Java::int
-          return if java_type_node?(node)
-
           return unless node.receiver && node.double_colon?
           return if node.camel_case_method?
 
+          # ignore Java interop code like Java::int
+          return if java_type_node?(node)
+
           add_offense(node, location: :dot)
         end
 

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

@@ -153,7 +153,7 @@ module RuboCop
         end
 
         def contains_backtick?(node)
-          node_body(node) =~ /`/
+          /`/.match?(node_body(node))
         end
 
         def node_body(node)

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

@@ -46,17 +46,20 @@ module RuboCop
         private
 
         KEYWORDS = %w[begin class def end module].freeze
+        KEYWORD_REGEXES = KEYWORDS.map { |w| /^\s*#{w}\s/ }.freeze
+
         ALLOWED_COMMENTS = %w[
           :nodoc:
           :yields:
           rubocop:disable
           rubocop:todo
         ].freeze
+        ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
 
         def offensive?(comment)
           line = line(comment)
-          KEYWORDS.any? { |word| line =~ /^\s*#{word}\s/ } &&
-            ALLOWED_COMMENTS.none? { |c| line =~ /#\s*#{c}/ }
+          KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
+            ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
         end
 
         def message(comment)

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

@@ -30,7 +30,7 @@ module RuboCop
         end
 
         def tail(branch)
-          branch.begin_type? ? [*branch].last : branch
+          branch.begin_type? ? Array(branch).last : branch
         end
 
         # rubocop:disable Metrics/AbcSize
@@ -43,7 +43,7 @@ module RuboCop
           when :and_asgn, :or_asgn
             "#{node.children[0].source} #{node.loc.operator.source} "
           when :casgn
-            "#{node.children[1]} = "
+            lhs_for_casgn(node)
           when *ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES
             "#{node.children[0]} = "
           else
@@ -93,6 +93,15 @@ module RuboCop
           end
         end
 
+        def lhs_for_casgn(node)
+          namespace = node.children[0]
+          if namespace.nil? || namespace.cbase_type?
+            "#{namespace&.source}#{node.children[1]} = "
+          else
+            "#{namespace.source}::#{node.children[1]} = "
+          end
+        end
+
         def setter_method?(method_name)
           method_name.to_s.end_with?(EQUAL) &&
             !%i[!= == === >= <=].include?(method_name)

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

@@ -72,14 +72,14 @@ module RuboCop
           return false if token_index >= processed_source.tokens.size
 
           token = processed_source.tokens[token_index]
-          token.comment? && token.text =~ /^#!.*$/
+          token.comment? && /^#!.*$/.match?(token.text)
         end
 
         def encoding_token?(processed_source, token_index)
           return false if token_index >= processed_source.tokens.size
 
           token = processed_source.tokens[token_index]
-          token.comment? && token.text =~ /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/
+          token.comment? && /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/.match?(token.text)
         end
 
         def notice_found?(processed_source)
@@ -88,7 +88,7 @@ module RuboCop
           processed_source.each_token do |token|
             break unless token.comment?
 
-            notice_found = !(token.text =~ notice_regexp).nil?
+            notice_found = notice_regexp.match?(token.text)
             break if notice_found
           end
           notice_found

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

@@ -50,7 +50,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :historic_date?, <<~PATTERN
-          (send _ _ _ (const (const nil? :Date) _))
+          (send _ _ _ (const (const {nil? (cbase)} :Date) _))
         PATTERN
 
         def_node_matcher :to_datetime?, <<~PATTERN