dagable 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e1ce980aa13e26cc4f39e22e4af897ac32921a3e7a815da5294c129ce233da1
-  data.tar.gz: 0c2e385b11f1f9e1fef43667d07c82947e5bc36f12651741b544bb6fe1fccf56
+  metadata.gz: 6659e16d0c901d24bf885a03eb19e340081420a651084fa7b87c5578dec42052
+  data.tar.gz: e6456fa8ee41246b382a0bbf298c647f5f7286f7e21ed3aab44d918b8073e983
 SHA512:
-  metadata.gz: 2c0c364e091d5301f9fdc8d9fa19d7c40721c8cb808d402a84d5b4e60c2d82dbb9c6a50977b7e3fb7a5f306dd3f71facf0a4f8ded7979361d00b5c9c17dda91d
-  data.tar.gz: b2464c035a6ef4c969592182d1e71c25552144eed8083a953b079897d97d039fbeebd413c47ff8430081353eb4a474685cdb19f4db8fb3ac3cd310a10a1db125
+  metadata.gz: 3395f73b85288c51e2e04db6fad33d08e8e0de752c37ecb1dfdc9902746b2af1fa5a95251f01e6e8d110b9b3477e399d8b85a9b822432148a23dd8e8ad72c046
+  data.tar.gz: c042d70a98bdd693168e953a4ed964fcd4641d8654656ed237b6ada29cda2bf40102e0e773d179c8866b61e796da040bf3064ce649d7446d2557e7936408ade1

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/migration_helpers.rb

@@ -34,10 +34,11 @@ module Dagable
 
     def create_dagable_edges_table(source_table_name)
       edges_table = "#{source_table_name}_edges"
+      id_type = source_primary_key_type(source_table_name)
 
       create_table edges_table do |t|
-        t.bigint :parent_id, null: false
-        t.bigint :child_id, null: false
+        t.column :parent_id, id_type, null: false
+        t.column :child_id, id_type, null: false
       end
 
       add_index edges_table, %i[parent_id child_id], unique: true
@@ -47,10 +48,11 @@ module Dagable
 
     def create_dagable_ancestries_table(source_table_name)
       ancestries_table = "#{source_table_name}_ancestries"
+      id_type = source_primary_key_type(source_table_name)
 
       create_table ancestries_table do |t|
-        t.bigint :predecessor_id, null: false
-        t.bigint :successor_id, null: false
+        t.column :predecessor_id, id_type, null: false
+        t.column :successor_id, id_type, null: false
         t.integer :depth, null: false, default: 0
       end
 
@@ -60,5 +62,13 @@ module Dagable
       add_foreign_key ancestries_table, source_table_name, column: :predecessor_id
       add_foreign_key ancestries_table, source_table_name, column: :successor_id
     end
+
+    # Edge and ancestry columns must reference the source table's records, so
+    # their type mirrors whatever the source primary key is (bigint, uuid,
+    # string, ...), read from the live schema.
+    def source_primary_key_type(source_table_name)
+      pk_name = primary_key(source_table_name)
+      columns(source_table_name).find { |column| column.name == pk_name }.sql_type
+    end
   end
 end

data/lib/dagable/migrations/helper.rb

@@ -35,16 +35,16 @@ module Dagable
       end
 
       # Resolves a reference to a dagable record. Accepts either a model
-      # instance or an integer ID.
+      # instance or an ID (integer or UUID/string).
       #
       # @param model [Class] the dagable ActiveRecord model class
-      # @param reference [ActiveRecord::Base, Integer] the record or its ID
+      # @param reference [ActiveRecord::Base, Integer, String] the record or its ID
       # @return [ActiveRecord::Base]
       # @raise [ArgumentError] if the reference type is unsupported
       def retrieve_item(model, reference)
         case reference
         when model then reference
-        when Integer then model.find(reference)
+        when Integer, String then model.find(reference)
         else raise ArgumentError, "Invalid dagable item reference"
         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.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dagable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Leandro Maduro
@@ -138,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: DAG infrastructure for ActiveRecord models
 test_files: []