dagable 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e1ce980aa13e26cc4f39e22e4af897ac32921a3e7a815da5294c129ce233da1
-  data.tar.gz: 0c2e385b11f1f9e1fef43667d07c82947e5bc36f12651741b544bb6fe1fccf56
+  metadata.gz: 1105295586a21290d1fefcaec67cc0fb4e4e7dc40e737c6542526d829e5618ee
+  data.tar.gz: b2e61fd515503636536364a7bc3b4694f0dbfa03bedeb5b1d38f1163c24ba074
 SHA512:
-  metadata.gz: 2c0c364e091d5301f9fdc8d9fa19d7c40721c8cb808d402a84d5b4e60c2d82dbb9c6a50977b7e3fb7a5f306dd3f71facf0a4f8ded7979361d00b5c9c17dda91d
-  data.tar.gz: b2464c035a6ef4c969592182d1e71c25552144eed8083a953b079897d97d039fbeebd413c47ff8430081353eb4a474685cdb19f4db8fb3ac3cd310a10a1db125
+  metadata.gz: ee09a550c55af660d7cf30e3ab45203c9a205f6a133525bb40cdf02dc65de9bca6a70ef0506c72f364b8e7bd29880029c16d00ccc004feecb16d2e7bd74087eb
+  data.tar.gz: fe634af62642fb0e0989fcdca6da2b0601be0e5271c225200944020e1c20acaa1d8eed1f6c70d8405c8fcd8e058a33da816890776b99b74c9dbdb67b4b713a86

data/lib/dagable/edge.rb

@@ -10,6 +10,9 @@ module Dagable
   class Edge < ActiveRecord::Base
     self.abstract_class = true
 
+    before_destroy :snapshot_affected_region
+    after_destroy :repair_affected_region
+
     # Materializes all transitive ancestry rows implied by this edge.
     #
     # For an edge (parent -> child), this computes the cross product of all
@@ -20,14 +23,49 @@ module Dagable
     # This is safe to call multiple times — existing ancestry rows are skipped
     # via +INSERT ... ON CONFLICT DO NOTHING+.
     def link_ancestries
-      ancestry_class = self.class.module_parent.const_get("Ancestry")
-      records = ancestry_records(ancestry_class)
+      records = ancestry_records(ancestry_model)
 
-      ancestry_class.insert_all(records, unique_by: %i[predecessor_id successor_id]) if records.any?
+      ancestry_model.insert_all(records, unique_by: %i[predecessor_id successor_id]) if records.any?
     end
 
     private
 
+    def ancestry_model = self.class.module_parent.const_get("Ancestry")
+
+    # Captures the nodes whose ancestry rows could have routed through this
+    # edge — ancestors of the parent (A) and descendants of the child (D).
+    # Any transitive ancestry row (P, S) with P ∈ A and S ∈ D potentially
+    # relied on this edge; everything outside A × D is untouched by its
+    # removal. Run in +before_destroy+ so the snapshot is taken before any
+    # dependent-destroy cascade perturbs the ancestry table.
+    def snapshot_affected_region
+      ancestry = ancestry_model
+      @affected_predecessors = ancestry.where(successor_id: parent_id).pluck(:predecessor_id)
+      @affected_successors = ancestry.where(predecessor_id: child_id).pluck(:successor_id)
+    end
+
+    # Rebuilds ancestry only within the affected region: deletes every
+    # transitive (depth > 0) row in A × D, then replays +link_ancestries+
+    # on remaining edges that touch the region. A single pass suffices —
+    # any surviving path from p ∈ A to s ∈ D must cross a "bridge" edge
+    # whose parent is in A, and replaying that edge re-derives (p, s)
+    # directly from still-intact ancestry outside the region.
+    def repair_affected_region
+      preds = @affected_predecessors
+      succs = @affected_successors
+      return if preds.blank? || succs.blank?
+
+      ancestry = ancestry_model
+      ancestry.where(predecessor_id: preds, successor_id: succs)
+              .where.not(depth: 0)
+              .delete_all
+
+      region_nodes = preds | succs
+      self.class
+          .where("parent_id IN (:nodes) OR child_id IN (:nodes)", nodes: region_nodes)
+          .find_each(&:link_ancestries)
+    end
+
     # Builds the ancestry rows implied by this edge as a cross product.
     #
     # For an edge P -> C, every predecessor of P must be linked to every

data/lib/dagable/instance_methods.rb

@@ -34,25 +34,25 @@ module Dagable
       end
     end
 
-    # Removes +child+ as a direct child of this node. Deletes the edge record
-    # and rebuilds the ancestry table for the entire graph.
+    # Removes +child+ as a direct child of this node. Destroys the edge
+    # record; the edge's destroy callbacks repair ancestry incrementally,
+    # touching only the region reachable through the removed edge.
     #
     # @param child [ActiveRecord::Base] the child node to disconnect
     def remove_child(child)
       ActiveRecord::Base.transaction do
-        child_edges.where(child_id: child.id).delete_all
-        rebuild_ancestries
+        child_edges.where(child_id: child.id).destroy_all
       end
     end
 
-    # Removes +parent+ as a direct parent of this node. Deletes the edge
-    # record and rebuilds the ancestry table for the entire graph.
+    # Removes +parent+ as a direct parent of this node. Destroys the edge
+    # record; the edge's destroy callbacks repair ancestry incrementally,
+    # touching only the region reachable through the removed edge.
     #
     # @param parent [ActiveRecord::Base] the parent node to disconnect
     def remove_parent(parent)
       ActiveRecord::Base.transaction do
-        parent_edges.where(parent_id: parent.id).delete_all
-        rebuild_ancestries
+        parent_edges.where(parent_id: parent.id).destroy_all
       end
     end
 
@@ -122,13 +122,5 @@ module Dagable
         successor_id: id
       ) { |row| row.depth = 0 }
     end
-
-    # Rebuilds the entire ancestry table from direct edges. Deletes all
-    # non-self rows and replays +link_ancestries+ on every edge.
-    def rebuild_ancestries
-      ancestry = ancestry_class
-      ancestry.where.not(depth: 0).delete_all
-      edge_class.find_each(&:link_ancestries)
-    end
   end
 end

data/lib/dagable/model.rb

@@ -26,41 +26,49 @@ module Dagable
   # 5. Register an +after_create+ callback to insert the self-referential
   #    ancestry row (depth 0) for every new record
   module Model
-    def dagable
-      const_set("Edge", edge_class_definition)
-      const_set("Ancestry", ancestry_class_definition)
-
-      include Dagable::Associations.new(const_get("Edge").name, const_get("Ancestry").name)
-      include Dagable::InstanceMethods
+    # Serializes +dagable+ invocations across threads. The window between
+    # +Class.new+ (which registers an anonymous descendant on +Dagable::Edge+
+    # / +Dagable::Ancestry+) and +const_set+ (which names it) is a race if
+    # two threads can be inside +dagable+ at once — concurrent invocations
+    # could observe each other's unnamed clones in the shared descendants
+    # tracker. Holding this mutex ensures at most one anonymous clone of
+    # each base class exists at any instant.
+    @mutex = Mutex.new
 
-      after_create :create_self_ancestry_row
-      after_destroy :rebuild_ancestries
+    class << self
+      attr_reader :mutex
     end
 
-    private
+    def dagable
+      Dagable::Model.mutex.synchronize do
+        edge_klass = const_set("Edge", Class.new(Dagable::Edge))
+        ancestry_klass = const_set("Ancestry", Class.new(Dagable::Ancestry))
 
-    def edge_class_definition
-      klass_name = name
-      table = "#{table_name}_edges"
+        configure_edge_class(edge_klass)
+        configure_ancestry_class(ancestry_klass)
 
-      Class.new(Dagable::Edge) do
-        self.table_name = table
+        include Dagable::Associations.new(edge_klass.name, ancestry_klass.name)
+        include Dagable::InstanceMethods
 
-        belongs_to :parent, class_name: klass_name, inverse_of: :child_edges
-        belongs_to :child, class_name: klass_name, inverse_of: :parent_edges
+        after_create :create_self_ancestry_row
       end
     end
 
-    def ancestry_class_definition
-      klass_name = name
-      table = "#{table_name}_ancestries"
+    private
 
-      Class.new(Dagable::Ancestry) do
-        self.table_name = table
+    # Configure the edge subclass after it has been named via +const_set+,
+    # so +belongs_to+ reflections and +table_name+ are registered against a
+    # class with a stable name rather than an anonymous placeholder.
+    def configure_edge_class(klass)
+      klass.table_name = "#{table_name}_edges"
+      klass.belongs_to :parent, class_name: name, inverse_of: :child_edges
+      klass.belongs_to :child, class_name: name, inverse_of: :parent_edges
+    end
 
-        belongs_to :predecessor, class_name: klass_name, inverse_of: :successor_connections
-        belongs_to :successor, class_name: klass_name, inverse_of: :predecessor_connections
-      end
+    def configure_ancestry_class(klass)
+      klass.table_name = "#{table_name}_ancestries"
+      klass.belongs_to :predecessor, class_name: name, inverse_of: :successor_connections
+      klass.belongs_to :successor, class_name: name, inverse_of: :predecessor_connections
     end
   end
 end

data/lib/dagable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dagable
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dagable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Leandro Maduro