rubocop 0.89.0 → 0.92.0

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

@@ -132,14 +132,14 @@ module RuboCop
       #     puts foo
       #   end
       #
-      class BlockDelimiters < Cop
+      class BlockDelimiters < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
+        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?
@@ -158,22 +158,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.'
@@ -219,29 +223,25 @@ 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')
-          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')
+          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)

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,17 +27,20 @@ module RuboCop
       #   # good
       #   Array === something
       #   (1..100).include?(7)
-      #   some_string =~ /something/
+      #   /something/.match?(some_string)
       #
       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? :=== $_)'
 
         def on_send(node)
           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
@@ -58,7 +61,12 @@ module RuboCop
         def replacement(lhs, rhs)
           case lhs.type
           when :regexp
-            "#{rhs.source} =~ #{lhs.source}"
+            # 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-hq/rubocop-performance/issues/152
+            #
+            # So here is noop.
           when :begin
             child = lhs.children.first
             "#{lhs.source}.include?(#{rhs.source})" if child&.range_type?

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

@@ -26,8 +26,9 @@ module RuboCop
       #     final_action
       #   end
       #
-      class CaseLikeIf < Cop
+      class CaseLikeIf < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Convert `if-elsif` to `case-when`.'
 
@@ -46,28 +47,30 @@ module RuboCop
             break unless convertible
           end
 
-          add_offense(node) if convertible
+          return unless convertible
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           target = find_target(node.condition)
 
-          lambda do |corrector|
-            corrector.insert_before(node, "case #{target.source}\n#{indent(node)}")
+          corrector.insert_before(node, "case #{target.source}\n#{indent(node)}")
 
-            branch_conditions(node).each do |branch_condition|
-              conditions = []
-              collect_conditions(branch_condition, target, conditions)
+          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
+            range = correction_range(branch_condition)
+            branch_replacement = "when #{conditions.map(&:source).join(', ')}"
+            corrector.replace(range, branch_replacement)
           end
         end
 
-        private
-
         def should_check?(node)
           !node.unless? && !node.elsif? && !node.modifier_form? && !node.ternary? &&
             node.elsif_conditional?
@@ -112,7 +115,7 @@ module RuboCop
         def find_target_in_equality_node(node)
           argument = node.arguments.first
           receiver = node.receiver
-          return unless receiver
+          return unless argument && receiver
 
           if argument.literal? || const_reference?(argument)
             receiver
@@ -156,9 +159,10 @@ module RuboCop
           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 :==, :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
@@ -169,6 +173,17 @@ module RuboCop
         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_binary_op(lhs, rhs, target)
           lhs = deparenthesize(lhs)
           rhs = deparenthesize(rhs)
@@ -199,6 +214,10 @@ module RuboCop
             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

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

@@ -21,9 +21,10 @@ module RuboCop
       #   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.'
@@ -40,14 +41,6 @@ module RuboCop
           check_style(node, node.body)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            return if node.class_type? && node.parent_class && style != :nested
-
-            nest_or_compact(corrector, node)
-          end
-        end
-
         private
 
         def nest_or_compact(corrector, node)
@@ -119,6 +112,8 @@ module RuboCop
         end
 
         def check_style(node, body)
+          return if node.identifier.children[0]&.cbase_type?
+
           if style == :nested
             check_nested_style(node)
           else
@@ -129,13 +124,23 @@ module RuboCop
         def check_nested_style(node)
           return unless compact_node_name?(node)
 
-          add_offense(node, location: :name, message: 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, location: :name, message: COMPACT_MSG)
+          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)

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

@@ -23,23 +23,18 @@ module RuboCop
       #   var.kind_of?(Time)
       #   var.kind_of?(String)
       #
-      class ClassCheck < Cop
+      class ClassCheck < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Prefer `Object#%<prefer>s` over `Object#%<current>s`.'
-
-        def_node_matcher :class_check?, '(send _ ${:is_a? :kind_of?} _)'
+        RESTRICT_ON_SEND = %i[is_a? kind_of?].freeze
 
         def on_send(node)
-          class_check?(node) do |method_name|
-            return if style == method_name
-
-            add_offense(node, location: :selector)
-          end
-        end
+          return if style == node.method_name
 
-        def autocorrect(node)
-          lambda do |corrector|
+          message = message(node)
+          add_offense(node.loc.selector, message: message) do |corrector|
             replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
 
             corrector.replace(node.loc.selector, replacement)

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

@@ -20,7 +20,9 @@ module RuboCop
       #       # ...
       #     end
       #   end
-      class ClassMethods < Cop
+      class ClassMethods < Base
+        extend AutoCorrector
+
         MSG = 'Use `self.%<method>s` instead of `%<class>s.%<method>s`.'
 
         def on_class(node)
@@ -36,23 +38,17 @@ module RuboCop
         end
         alias on_module on_class
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.name, 'self') }
-        end
-
         private
 
         def check_defs(name, node)
           # check if the class/module name matches the definee for the defs node
           return unless name == node.receiver
 
-          add_offense(node.receiver, location: :name)
-        end
-
-        def message(node)
-          _, class_name = *node
+          message = format(MSG, method: node.method_name, class: name.source)
 
-          format(MSG, method: node.parent.method_name, class: class_name)
+          add_offense(node.receiver.loc.name, message: message) do |corrector|
+            corrector.replace(node.receiver, 'self')
+          end
         end
       end
     end

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces using `def self.method_name` or `class << self` to define class methods.
+      #
+      # @example EnforcedStyle: def_self (default)
+      #   # bad
+      #   class SomeClass
+      #     class << self
+      #       attr_accessor :class_accessor
+      #
+      #       def class_method
+      #         # ...
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     def self.class_method
+      #       # ...
+      #     end
+      #
+      #     class << self
+      #       attr_accessor :class_accessor
+      #     end
+      #   end
+      #
+      #   # good - contains private method
+      #   class SomeClass
+      #     class << self
+      #       attr_accessor :class_accessor
+      #
+      #       private
+      #
+      #       def private_class_method
+      #         # ...
+      #       end
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: self_class
+      #   # bad
+      #   class SomeClass
+      #     def self.class_method
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     class << self
+      #       def class_method
+      #         # ...
+      #       end
+      #     end
+      #   end
+      #
+      class ClassMethodsDefinitions < Base
+        include ConfigurableEnforcedStyle
+        include CommentsHelp
+        include VisibilityHelp
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred>s` to define a class method.'
+        MSG_SCLASS = 'Do not define public methods within class << self.'
+
+        def on_sclass(node)
+          return unless def_self_style?
+          return unless node.identifier.source == 'self'
+          return unless all_methods_public?(node)
+
+          add_offense(node, message: MSG_SCLASS) do |corrector|
+            autocorrect_sclass(node, corrector)
+          end
+        end
+
+        def on_defs(node)
+          return if def_self_style?
+
+          message = format(MSG, preferred: 'class << self')
+          add_offense(node, message: message)
+        end
+
+        private
+
+        def def_self_style?
+          style == :def_self
+        end
+
+        def all_methods_public?(sclass_node)
+          def_nodes = def_nodes(sclass_node)
+          return false if def_nodes.empty?
+
+          def_nodes.all? { |def_node| node_visibility(def_node) == :public }
+        end
+
+        def def_nodes(sclass_node)
+          sclass_def = sclass_node.body
+          return [] unless sclass_def
+
+          if sclass_def.def_type?
+            [sclass_def]
+          elsif sclass_def.begin_type?
+            sclass_def.each_child_node(:def).to_a
+          else
+            []
+          end
+        end
+
+        def autocorrect_sclass(node, corrector)
+          rewritten_defs = []
+
+          def_nodes(node).each do |def_node|
+            next unless node_visibility(def_node) == :public
+
+            range, source = extract_def_from_sclass(def_node, node)
+
+            corrector.remove(range)
+            rewritten_defs << source
+          end
+
+          if sclass_only_has_methods?(node)
+            corrector.remove(node)
+            rewritten_defs.first&.strip!
+          else
+            corrector.insert_after(node, "\n")
+          end
+
+          corrector.insert_after(node, rewritten_defs.join("\n"))
+        end
+
+        def sclass_only_has_methods?(node)
+          node.body.def_type? || node.body.each_child_node.all?(&:def_type?)
+        end
+
+        def extract_def_from_sclass(def_node, sclass_node)
+          range = source_range_with_comment(def_node)
+          source = range.source.sub!(
+            "def #{def_node.method_name}",
+            "def self.#{def_node.method_name}"
+          )
+
+          source = source.gsub(/^ {#{indentation_diff(def_node, sclass_node)}}/, '')
+          [range, source.chomp]
+        end
+
+        def indentation_diff(node1, node2)
+          node1.loc.column - node2.loc.column
+        end
+      end
+    end
+  end
+end