rubocop 0.88.0 → 0.91.1

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

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

@@ -45,23 +45,18 @@ module RuboCop
       #     end
       #   end
       #
-      class ClassVars < Cop
-        MSG = 'Replace class var %<class_var>s with a class ' \
-              'instance var.'
+      class ClassVars < Base
+        MSG = 'Replace class var %<class_var>s with a class instance var.'
+        RESTRICT_ON_SEND = %i[class_variable_set].freeze
 
         def on_cvasgn(node)
-          add_offense(node, location: :name)
+          add_offense(node.loc.name, message: format(MSG, class_var: node.children.first))
         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)
+          add_offense(
+            node.first_argument, message: format(MSG, class_var: node.first_argument.source)
+          )
         end
       end
     end

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

@@ -37,8 +37,9 @@ module RuboCop
       #   items.select
       #   items.include?
       #
-      class CollectionMethods < Cop
+      class CollectionMethods < Base
         include MethodPreference
+        extend AutoCorrector
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
@@ -47,31 +48,24 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.arguments.one? &&
-                        node.first_argument.block_pass_type?
+          return unless node.arguments.one? && node.first_argument.block_pass_type?
 
           check_method_node(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              preferred_method(node.loc.selector.source))
-          end
-        end
-
         private
 
-        def message(node)
-          format(MSG,
-                 prefer: preferred_method(node.method_name),
-                 current: node.method_name)
-        end
-
         def check_method_node(node)
           return unless preferred_methods[node.method_name]
 
-          add_offense(node, location: :selector)
+          message = message(node)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, preferred_method(node.loc.selector.source))
+          end
+        end
+
+        def message(node)
+          format(MSG, prefer: preferred_method(node.method_name), current: node.method_name)
         end
       end
     end

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

@@ -17,7 +17,9 @@ module RuboCop
       #   FileUtils.rmdir(dir)
       #   Marshal.dump(obj)
       #
-      class ColonMethodCall < Cop
+      class ColonMethodCall < Base
+        extend AutoCorrector
+
         MSG = 'Do not use `::` for method calls.'
 
         def_node_matcher :java_type_node?, <<~PATTERN
@@ -30,17 +32,14 @@ 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
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.dot, '.') }
+          add_offense(node.loc.dot) do |corrector|
+            corrector.replace(node.loc.dot, '.')
+          end
         end
       end
     end

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

@@ -19,17 +19,17 @@ module RuboCop
       #     end
       #   end
       #
-      class ColonMethodDefinition < Cop
+      class ColonMethodDefinition < Base
+        extend AutoCorrector
+
         MSG = 'Do not use `::` for defining class methods.'
 
         def on_defs(node)
           return unless node.loc.operator.source == '::'
 
-          add_offense(node, location: :operator)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.operator, '.') }
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '.')
+          end
         end
       end
     end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where multiple consecutive loops over the same data
+      # can be combined into a single loop. It is very likely that combining them
+      # will make the code more efficient and more concise.
+      #
+      # It is marked as unsafe, because the first loop might modify
+      # a state that the second loop depends on; these two aren't combinable.
+      #
+      # @example
+      #   # bad
+      #   def method
+      #     items.each do |item|
+      #       do_something(item)
+      #     end
+      #
+      #     items.each do |item|
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     items.each do |item|
+      #       do_something(item)
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def method
+      #     for item in items do
+      #       do_something(item)
+      #     end
+      #
+      #     for item in items do
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     for item in items do
+      #       do_something(item)
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      class CombinableLoops < Base
+        MSG = 'Combine this loop with the previous loop.'
+
+        def on_block(node)
+          return unless node.parent&.begin_type?
+          return unless collection_looping_method?(node)
+
+          add_offense(node) if same_collection_looping?(node, node.left_sibling)
+        end
+
+        def on_for(node)
+          return unless node.parent&.begin_type?
+
+          sibling = node.left_sibling
+          add_offense(node) if sibling&.for_type? && node.collection == sibling.collection
+        end
+
+        private
+
+        def collection_looping_method?(node)
+          method_name = node.send_node.method_name
+          method_name.match?(/^each/) || method_name.match?(/_each$/)
+        end
+
+        def same_collection_looping?(node, sibling)
+          sibling&.block_type? &&
+            sibling.send_node.method?(node.method_name) &&
+            sibling.send_node.receiver == node.send_node.receiver
+        end
+      end
+    end
+  end
+end