rubocop-sorted_methods_by_call 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 635807053b2df421a854cdc73001545451f8a7017623c93c6d6eb89bf304e172
-  data.tar.gz: cacd6163f57b4ee053b3053a950240b71bc2665b8bd93d6a4dba916d02490683
+  metadata.gz: 1d62de644bc87dd509f3407cc4db3c9e0b4c46991e6a4e682344a7024eae1217
+  data.tar.gz: 94858039c6204ae841a595b4e5c13db9cf3a0775cf615fdd4696951d68181303
 SHA512:
-  metadata.gz: 4bedcb4e198e0d75209bb286a15d55ba16ec3ea026cbc52769f7acb13bc8c8f118cac590d4ca7fd16bdfd82730e380c3d02782e6dbf24001fc4815f316928d2a
-  data.tar.gz: 05d4815fcce53e4c90e8b66ac1933363ec3a4940f551d6f0464a993b63b2b3af36ba8795be3bea7a34cb462ad9aa6f39da011a87f055ac5154e8e4174319ffab
+  metadata.gz: 91901d4d06ad36e83396752d9c7b47b3c838f61bb42686351b43f382281136aa219dcbeaaf1d5f0e2007db56728dd9e69dd7ba307f1758b9acc26cadf7b7416a
+  data.tar.gz: a06c24a47cf38ea1e06021d54f49a04ed26fb47174f2c4dd1b6491cb768243acbda01fe25933b55895387e58d8f00d7e163c24d08525394f1891953f9a8a6017

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2025-11-06 15:18:01 UTC using RuboCop version 1.81.7.
+# on 2025-11-06 17:19:21 UTC using RuboCop version 1.81.7.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -22,7 +22,7 @@ Gemspec/RequiredRubyVersion:
 # Offense count: 4
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes.
 Metrics/AbcSize:
-  Max: 60
+  Max: 61
 
 # Offense count: 2
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns, inherit_mode.
@@ -33,19 +33,19 @@ Metrics/BlockLength:
 # Offense count: 5
 # Configuration parameters: AllowedMethods, AllowedPatterns.
 Metrics/CyclomaticComplexity:
-  Max: 20
+  Max: 26
 
 # Offense count: 7
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
-  Max: 58
+  Max: 68
 
 # Offense count: 4
 # Configuration parameters: AllowedMethods, AllowedPatterns.
 Metrics/PerceivedComplexity:
-  Max: 22
+  Max: 27
 
-# Offense count: 12
+# Offense count: 16
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 37

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubocop-sorted_methods_by_call (1.1.0)
+    rubocop-sorted_methods_by_call (1.1.1)
       lint_roller
       rubocop (>= 1.72.0)
 

data/config/default.yml

@@ -1,6 +1,6 @@
 SortedMethodsByCall/Waterfall:
   Description: "Enforces method ordering based on call relationships."
   Enabled: false
-  VersionAdded: "1.1.0"
+  VersionAdded: "1.1.1"
   SafeAutoCorrect: false
   AllowedRecursion: true

data/lib/rubocop/cop/sorted_methods_by_call/waterfall.rb

@@ -109,36 +109,74 @@ module RuboCop
           def_nodes = body_nodes.select { |n| %i[def defs].include?(n.type) }
           return if def_nodes.size <= 1
 
-          names = def_nodes.map(&:method_name)
+          names     = def_nodes.map(&:method_name)
           names_set = names.to_set
-          index_of = names.each_with_index.to_h
+          index_of  = names.each_with_index.to_h
+
+          # -----------------------------------------------------------
+          # Phase 1  Collect direct call edges (caller → callee)
+          # -----------------------------------------------------------
+          direct_edges = def_nodes.flat_map do |def_node|
+            calls = local_calls(def_node, names_set)
+            calls.reject { |callee| callee == def_node.method_name }
+                 .map    { |callee| [def_node.method_name, callee] }
+          end
+
+          all_callees = direct_edges.to_set(&:last)
 
-          # Build complete call graph - find ALL method calls in ALL methods
-          edges = []
+          # -----------------------------------------------------------
+          # Phase 2  Add sibling‑order edges for orchestration methods
+          # -----------------------------------------------------------
+          sibling_edges = []
           def_nodes.each do |def_node|
-            local_calls(def_node, names_set).each do |callee|
-              next if callee == def_node.method_name # self-recursion
+            next if all_callees.include?(def_node.method_name)
+
+            calls = local_calls(def_node, names_set)
+            calls.each_cons(2) do |a, b|
+              next if direct_edges.any? { |u, v| (u == a && v == b) || (u == b && v == a) }
 
-              edges << [def_node.method_name, callee]
+              sibling_edges << [a, b]
             end
           end
 
+          # -----------------------------------------------------------
+          # Phase 3  Combine for sorting, but keep direct set for recursion
+          # -----------------------------------------------------------
+          edges_for_sort = direct_edges + sibling_edges
           allow_recursion = cop_config.fetch('AllowedRecursion') { true }
-          adj = build_adj(names, edges)
 
-          violation = first_backward_edge(edges, index_of, adj, allow_recursion)
+          # Build adjacency only from *direct* calls for recursion checks
+          adj_direct = build_adj(names, direct_edges)
+
+          # Check for violations with edge type tracking
+          violation = first_backward_edge(direct_edges, index_of, adj_direct, allow_recursion)
+          violation_type = :direct if violation
+
+          unless violation
+            violation = first_backward_edge(sibling_edges, index_of, adj_direct, allow_recursion)
+            violation_type = :sibling if violation
+          end
+
           return unless violation
 
           caller_name, callee_name = violation
           callee_node = def_nodes[index_of[callee_name]]
 
-          add_offense(callee_node,
-                      message: format(MSG, callee: "##{callee_name}", caller: "##{caller_name}")) do |corrector|
-            try_autocorrect(corrector, body_nodes, def_nodes, edges)
+          # Choose message based on violation type
+          message = if violation_type == :sibling
+                      "Define ##{callee_name} after ##{caller_name} to match the order they are called together"
+                    else
+                      format(MSG, callee: "##{callee_name}", caller: "##{caller_name}")
+                    end
+
+          add_offense(callee_node, message: message) do |corrector|
+            try_autocorrect(corrector, body_nodes, def_nodes, edges_for_sort, violation)
           end
 
           # Recurse into nested scopes
-          body_nodes.each { |n| analyze_scope(n) if n.class_type? || n.module_type? || n.sclass_type? }
+          body_nodes.each do |n|
+            analyze_scope(n) if n.class_type? || n.module_type? || n.sclass_type?
+          end
         end
 
         # +RuboCop::Cop::SortedMethodsByCall::Waterfall#scope_body_nodes+ -> Array<RuboCop::AST::Node>
@@ -194,73 +232,64 @@ module RuboCop
         # @param [Array<RuboCop::AST::Node>] body_nodes
         # @param [Array<RuboCop::AST::Node>] def_nodes
         # @param [Array<Array(Symbol, Symbol)>] edges
+        # @param [Array(Symbol, Symbol)] violation The found violation (caller, callee)
         # @return [void]
         #
         # @note Applied only when user asked for autocorrections; with SafeAutoCorrect: false, this runs under -A.
         # @note Also preserves contiguous leading doc comments above each method.
-        def try_autocorrect(corrector, body_nodes, def_nodes, edges)
-          # Group method definitions into visibility sections
+        def try_autocorrect(corrector, body_nodes, _def_nodes, edges, violation)
           sections = extract_visibility_sections(body_nodes)
 
-          # Find the section that contains our violating methods
-          caller_name, callee_name = first_backward_edge(
-            edges,
-            def_nodes.map(&:method_name).each_with_index.to_h,
-            build_adj(def_nodes.map(&:method_name), edges),
-            cop_config.fetch('AllowedRecursion') { true }
-          )
-
-          # No violation -> nothing to do
-          return unless caller_name && callee_name
+          caller_name, callee_name = violation
 
-          # Find a visibility section that contains both names
+          # find target section containing both defs
           target_section = sections.find do |section|
-            names_in_section = section[:defs].to_set(&:method_name)
-            names_in_section.include?(caller_name) && names_in_section.include?(callee_name)
+            section_names = section[:defs].map(&:method_name)
+            section_names.include?(caller_name) && section_names.include?(callee_name)
           end
-
-          # If violation spans multiple sections, skip autocorrect
           return unless target_section
 
           defs = target_section[:defs]
-          return unless defs.size > 1
-
-          # Apply topological sort only within this visibility section
-          names = defs.map(&:method_name)
-          idx_of = names.each_with_index.to_h
-
-          # Filter edges to only those within this section
-          section_names = names.to_set
-          section_edges = edges.select { |u, v| section_names.include?(u) && section_names.include?(v) }
-
-          sorted_names = topo_sort(names, section_edges, idx_of)
-          return unless sorted_names
+          return if defs.size <= 1
+
+          section_names   = defs.map(&:method_name)
+          section_edges   = edges.select { |u, v| section_names.include?(u) && section_names.include?(v) }
+          section_idx_of  = section_names.each_with_index.to_h
+
+          # sort within section or minimally fix if graph is cyclic
+          sorted_names = topo_sort(section_names, section_edges, section_idx_of)
+
+          # forcibly fix when topo_sort failed or produced same order
+          if sorted_names.nil? || sorted_names == section_names
+            sorted_names = section_names.dup
+            # remove callee and reinsert it after its caller
+            sorted_names.delete(callee_name)
+            caller_index = sorted_names.index(caller_name) || -1
+            sorted_names.insert(caller_index + 1, callee_name)
+          end
 
-          # Capture each def with its leading contiguous comment block
-          ranges_by_name = defs.to_h { |d| [d.method_name, range_with_leading_comments(d)] }
-          sorted_def_sources = sorted_names.map { |name| ranges_by_name[name].source }
+          # reconstruct source
+          ranges_by_name = defs.to_h do |d|
+            [d.method_name, range_with_leading_comments(d)]
+          end
+          sorted_def_sources = sorted_names.map { |n| ranges_by_name[n].source }
 
-          # Reconstruct the section: keep the visibility modifier (if any) above the first def
-          visibility_node = target_section[:visibility]
+          visibility_node   = target_section[:visibility]
           visibility_source = visibility_node&.source.to_s
 
-          new_content = if visibility_source.empty?
-                          sorted_def_sources.join("\n\n")
-                        else
-                          "#{visibility_source}\n\n#{sorted_def_sources.join("\n\n")}"
-                        end
+          new_content =
+            if visibility_source.empty?
+              sorted_def_sources.join("\n\n")
+            else
+              "#{visibility_source}\n\n#{sorted_def_sources.join("\n\n")}"
+            end
 
-          # Expand the replaced region:
-          # - if a visibility node exists, start from its begin_pos
-          # - otherwise, start from the earliest leading doc-comment of the defs
           section_begin =
             if visibility_node
               visibility_node.source_range.begin_pos
             else
               defs.map { |d| range_with_leading_comments(d).begin_pos }.min
             end
-
-          # Always end at the end of the last def
           section_end = defs.last.source_range.end_pos
 
           region = Parser::Source::Range.new(processed_source.buffer, section_begin, section_end)
@@ -360,9 +389,10 @@ module RuboCop
               current_defs << node
               section_start ||= node.source_range.begin_pos
             when :send
-              # Check if this is a visibility modifier (private/protected/public)
-              if node.receiver.nil? && %i[private protected public].include?(node.method_name) && node.arguments.empty?
-                # End current section if it has defs
+              # visibility modifier?
+              if node.receiver.nil? &&
+                 %i[private protected public].include?(node.method_name) &&
+                 node.arguments.empty?
                 unless current_defs.empty?
                   sections << {
                     visibility: current_visibility,
@@ -375,7 +405,7 @@ module RuboCop
                 end
                 current_visibility = node
               else
-                # Non-visibility send - breaks contiguity
+                # anything else breaks contiguous run
                 unless current_defs.empty?
                   sections << {
                     visibility: current_visibility,
@@ -385,11 +415,9 @@ module RuboCop
                   }
                   current_defs = []
                   section_start = nil
-                  current_visibility = nil
                 end
               end
             else
-              # Any other node type breaks contiguity
               unless current_defs.empty?
                 sections << {
                   visibility: current_visibility,
@@ -399,12 +427,11 @@ module RuboCop
                 }
                 current_defs = []
                 section_start = nil
-                current_visibility = nil
               end
             end
           end
 
-          # Handle trailing defs
+          # trailing defs
           unless current_defs.empty?
             sections << {
               visibility: current_visibility,
@@ -414,7 +441,20 @@ module RuboCop
             }
           end
 
-          sections
+          # -----------------------------------------------
+          # merge consecutive groups with identical visibility
+          # -----------------------------------------------
+          merged = []
+          sections.each do |s|
+            if !merged.empty? &&
+               merged.last[:visibility]&.source == s[:visibility]&.source
+              merged.last[:defs].concat(s[:defs])
+              merged.last[:end_pos] = s[:end_pos]
+            else
+              merged << s
+            end
+          end
+          merged
         end
 
         # +RuboCop::Cop::SortedMethodsByCall::Waterfall#topo_sort+ -> Array<Symbol>, nil

data/lib/rubocop/sorted_methods_by_call/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module SortedMethodsByCall
-    VERSION = '1.1.0'
+    VERSION = '1.1.1'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-sorted_methods_by_call
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - unurgunite