dagnabit 2.2.1

data/lib/dagnabit/link/transitive_closure_recalculation/on_destroy.rb

@@ -0,0 +1,125 @@
+module Dagnabit
+  module Link
+    module TransitiveClosureRecalculation
+      module OnDestroy
+        def after_destroy
+          super
+          update_transitive_closure_for_destroy(*quoted_dag_link_values)
+        end
+
+        private
+
+        def update_transitive_closure_for_destroy(aid, did, atype, dtype)
+          my_table = self.class.quoted_table_name
+          my_aid, my_did, my_atype, my_dtype = quoted_dag_link_column_names
+          tc = self.class.transitive_closure_table_name
+          tc_aid, tc_did, tc_atype, tc_dtype = quoted_dag_link_column_names
+
+          with_temporary_edge_tables('suspect', 'trusty', 'new') do |suspect, trusty, new|
+            connection.execute <<-END
+              INSERT INTO #{suspect} 
+                SELECT * FROM (
+                  SELECT
+                    TC1.#{tc_aid}, TC2.#{tc_did}, TC1.#{tc_atype}, TC2.#{tc_dtype}
+                    FROM
+                      #{tc} AS TC1, #{tc} AS TC2
+                    WHERE
+                      TC1.#{tc_did} = #{aid} AND TC2.#{tc_aid} = #{did}
+                      AND
+                      TC1.#{tc_dtype} = #{atype} AND TC2.#{tc_atype} = #{dtype}
+                  UNION
+                  SELECT
+                    TC.#{tc_aid}, #{did}, TC.#{tc_atype}, #{dtype}
+                    FROM
+                      #{tc} AS TC
+                    WHERE
+                      TC.#{tc_did} = #{aid} AND TC.#{tc_dtype} = #{atype}
+                  UNION
+                  SELECT
+                    #{aid}, TC.#{tc_did}, #{atype}, TC.#{tc_dtype}
+                    FROM
+                      #{tc} AS TC
+                    WHERE
+                      TC.#{tc_aid} = #{did} AND TC.#{tc_atype} = #{dtype}
+                  UNION
+                    SELECT
+                      #{aid}, #{did}, #{atype}, #{dtype}
+                      FROM
+                        #{tc} AS TC
+                      WHERE
+                        TC.#{tc_aid} = #{aid} AND TC.#{tc_did} = #{did}
+                        AND
+                        TC.#{tc_atype} = #{atype} AND TC.#{tc_dtype} = #{dtype}
+                ) AS tmp0
+            END
+
+            connection.execute <<-END
+              INSERT INTO #{trusty}
+                SELECT
+                  #{tc_aid}, #{tc_did}, #{tc_atype}, #{tc_dtype}
+                  FROM (
+                    SELECT
+                      #{tc_aid}, #{tc_did}, #{tc_atype}, #{tc_dtype}
+                      FROM
+                        #{tc} AS TC
+                      WHERE NOT EXISTS (
+                        SELECT *
+                          FROM
+                            #{suspect} AS SUSPECT
+                          WHERE
+                            SUSPECT.#{tc_aid} = TC.#{tc_aid} AND SUSPECT.#{tc_did} = TC.#{tc_did}
+                            AND
+                            SUSPECT.#{tc_atype} = TC.#{tc_atype} AND SUSPECT.#{tc_dtype} = TC.#{tc_dtype}
+                      )
+                  UNION
+                  SELECT
+                    #{my_aid}, #{my_did}, #{my_atype}, #{my_dtype}
+                    FROM
+                      #{my_table} AS G
+                    WHERE
+                      NOT (G.#{my_aid} = #{aid} AND g.#{my_atype} = #{atype}
+                           AND
+                           G.#{my_did} = #{did} AND g.#{my_dtype} = #{dtype})
+                ) AS tmp0
+            END
+
+            connection.execute <<-END
+              INSERT INTO #{new}
+                SELECT * FROM (
+                  SELECT * FROM #{trusty}
+                  UNION
+                  SELECT
+                    T1.#{tc_aid}, T2.#{tc_aid}, T1.#{tc_atype}, T2.#{tc_dtype}
+                    FROM
+                      #{trusty} T1, #{trusty} T2
+                    WHERE
+                      T1.#{tc_aid} = T2.#{tc_aid} AND T1.#{tc_atype} = T2.#{tc_dtype}
+                  UNION
+                  SELECT
+                    T1.#{tc_aid}, T3.#{tc_aid}, T1.#{tc_atype}, T3.#{tc_dtype}
+                    FROM
+                      #{trusty} T1, #{trusty} T2, #{trusty} T3
+                    WHERE
+                      T1.#{tc_aid} = T2.#{tc_aid} AND T2.#{tc_aid} = T3.#{tc_aid}
+                      AND
+                      T1.#{tc_dtype} = T2.#{tc_atype} AND T2.#{tc_dtype} = T3.#{tc_atype}
+                ) AS tmp0
+            END
+
+            connection.execute <<-END
+              DELETE FROM #{tc} WHERE NOT EXISTS (
+                SELECT *
+                  FROM
+                    #{new} T
+                  WHERE
+                    T.#{tc_aid} = #{tc}.#{tc_aid} AND T.#{tc_did} = #{tc}.#{tc_did}
+                    AND
+                    T.#{tc_atype} = #{tc}.#{tc_atype} AND T.#{tc_dtype} = #{tc}.#{tc_dtype}
+              )
+            END
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dagnabit/link/transitive_closure_recalculation/on_update.rb

@@ -0,0 +1,13 @@
+module Dagnabit
+  module Link
+    module TransitiveClosureRecalculation
+      module OnUpdate
+        def after_update
+          old_values = dag_link_column_names.map { |n| connection.quote(changes[n].try(:first) || send(n)) }
+          update_transitive_closure_for_destroy(*old_values)
+          update_transitive_closure_for_create
+        end
+      end
+    end
+  end
+end

data/lib/dagnabit/link/transitive_closure_recalculation/utilities.rb

@@ -0,0 +1,56 @@
+module Dagnabit
+  module Link
+    module TransitiveClosureRecalculation
+      module Utilities
+        private
+
+        def quoted_dag_link_values
+          dag_link_column_names.map { |n| connection.quote(send(n)) }
+        end
+
+        def quoted_dag_link_column_names
+          dag_link_column_names.map { |n| connection.quote_column_name(n) }
+        end
+
+        def dag_link_column_names
+          [ self.class.ancestor_id_column,
+            self.class.descendant_id_column,
+            self.class.ancestor_type_column,
+            self.class.descendant_type_column ]
+        end
+
+        def all_quoted_column_values
+          all_column_names.map { |n| connection.quote(send(n)) }
+        end
+
+        def all_quoted_column_names
+          all_column_names.map { |n| connection.quote_column_name(n) }
+        end
+
+        def all_column_names
+          all_columns.map { |c| c.name }
+        end
+
+        def with_temporary_edge_tables(*tables, &block)
+          tables.each do |table|
+            connection.create_table(table, :temporary => true, :id => false) do |t|
+              all_columns.each do |c|
+                t.send(c.type, c.name)
+              end
+            end
+          end
+
+          yield(tables.map { |t| connection.quote_table_name(t) })
+
+          tables.each do |table|
+            connection.drop_table table
+          end
+        end
+
+        def all_columns
+          self.class.columns.reject { |c| c.name == 'id' || c.name == 'type' }
+        end
+      end
+    end
+  end
+end

data/lib/dagnabit/link/validations.rb

@@ -0,0 +1,26 @@
+module Dagnabit
+  module Link
+    #
+    # Basic validations on link models.
+    #
+    # This module only installs ancestor and descendant presence validations;
+    # the only basic requirement for a link is that it have a valid start point
+    # and a valid end point.  We validate the presence of the +ancestor+ and
+    # +descendant+, instead of +ancestor_id+ and +descendant_id+, in order to
+    # permit scenarios like this:
+    #
+    #   n1 = Node.new
+    #   n2 = Node.new
+    #   l = Link.new(:ancestor => n1, :descendant => n2)
+    #   l.save  # will save l, n1, and n2
+    #
+    module Validations
+      def self.extended(base)
+        base.send(:validates_presence_of, :ancestor)
+        base.send(:validates_presence_of, :descendant)
+        base.send(:validates_associated, :ancestor)
+        base.send(:validates_associated, :descendant)
+      end
+    end
+  end
+end

data/lib/dagnabit/node/associations.rb

@@ -0,0 +1,84 @@
+module Dagnabit
+  module Node
+    #
+    # Association macros added to node in a dagnabit dag.
+    #
+    # == Added associations
+    #
+    # * +links_as_parent+: Links for which this node is a parent.
+    # * +links_as_child+: Links for which this node is a child.
+    # * +links_as_ancestor+: Links for which this node is an ancestor.
+    # * +links_as_descendant+: Links for which this node is a descendant.
+    #
+    # == Illustration
+    #
+    # Suppose we have the following graph:
+    #
+    #    n1
+    #     |
+    #    / \
+    #   n2  n3
+    #    \ /
+    #     n4
+    #
+    # Here are some example queries and outputs:
+    #
+    #   n1.links_as_parent      # => [#<Link ancestor=n1, descendant=n2>, #<Link ancestor=n1, descendant=n3>]
+    #   n4.links_as_child       # => [#<Link ancestor=n2, descendant=n4>, #<Link ancestor=n3, descendant=n4>]
+    #   n1.links_as_ancestor    # => [#<Link ancestor=n1, descendant=n2>, #<Link ancestor=n1, descendant=n3>, #<Link ancestor=n1, descendant=n4>]
+    #   n4.links_as_descendant  # => [#<Link ancestor=n2, descendant=n4>, #<Link ancestor=n3, descendant=n4>, #<Link ancestor=n1, descendant=n4>]
+    #
+    # In this example, we used +Link+ as the class for all links.  This isn't
+    # actually what you get back (see Dagnabit::Link for details), but the
+    # objects you get back _will_ have ancestor and descendant accessors.
+    #
+    module Associations
+      #
+      # Installs associations on the node model.
+      #
+      def self.extended(base)
+        base.install_associations
+      end
+
+      def install_associations
+        klass = self
+        link_class = klass.link_class_name.constantize
+
+        klass.send(:has_many,
+                  :links_as_parent,
+                  :class_name => klass.link_class_name,
+                  :foreign_key => link_class.ancestor_id_column,
+                  :conditions => { link_class.ancestor_type_column => klass.name },
+                  :dependent => :destroy)
+
+        klass.send(:has_many,
+                  :links_as_child,
+                  :class_name => klass.link_class_name,
+                  :foreign_key => link_class.descendant_id_column,
+                  :conditions => { link_class.descendant_type_column => klass.name },
+                  :dependent => :destroy)
+
+        klass.send(:has_many,
+                  :links_as_ancestor,
+                  :class_name => link_class.transitive_closure_class.name,
+                  :foreign_key => link_class.ancestor_id_column,
+                  :conditions => { link_class.ancestor_type_column => klass.name },
+                  :readonly => true)
+
+        klass.send(:has_many,
+                  :links_as_descendant,
+                  :class_name => link_class.transitive_closure_class.name,
+                  :foreign_key => link_class.descendant_id_column,
+                  :conditions => { link_class.descendant_type_column => klass.name },
+                  :readonly => true)
+      end
+
+      private
+
+      def inherited(subclass)
+        super(subclass)
+        subclass.install_associations
+      end
+    end
+  end
+end

data/lib/dagnabit/node/class_methods.rb

@@ -0,0 +1,74 @@
+require 'ostruct'
+
+module Dagnabit
+  module Node
+    module ClassMethods
+      #
+      # Returns a subgraph rooted at a given set of nodes.
+      #
+      # While you can retrieve all descendants of a node pretty easily (i.e.
+      # +node.descendants+), and all links from a node really easily (i.e.
+      # +node.links_as_ancestor), it's not quite as straightforward to get the
+      # nodes and edges (direct edges, that is) out of a graph.
+      #
+      # The subgraph is returned as an object with two properties: +nodes+ and
+      # +edges+.  Both properties are instances of the Set class.
+      # 
+      # == Examples
+      #
+      # In the following examples, the node class is called +Node+.  Variables
+      # of the form +nM+, where M is an integer, denote Node instances.
+      # 
+      # Retrieve all descendants of n1 and all direct edges "underneath" n1
+      # (i.e. n1 to its children and direct edges for each of n1's
+      # descendants):
+      #
+      # <pre>
+      # Node.subgraph_from(n1)
+      #
+      # => #<Graph nodes=... edges=...>
+      # </pre>
+      # 
+      # Same as above, but builds a graph using n1 and n2 as roots.
+      #
+      # <pre>
+      # Node.subgraph_from(n1, n2)
+      # </pre>
+      #
+      # == Usage tip
+      #
+      # +subgraph_from+ forces loading of the +descendants+ and
+      # +links_as_parent+ +links_as_parent+ associations on Node.  In some
+      # situations, you may experience better performance if you use
+      # ActiveRecord's eager-loading capabilities when using subgraph_from:
+      #
+      # <pre>
+      # roots = Node.find(..., :include => [:descendants, :links_as_parent])
+      # Node.subgraph_from(roots)
+      # </pre>
+      #
+      def subgraph_from(*roots)
+        returning(OpenStruct.new) do |g|
+          g.nodes = all_nodes_of(roots)
+          g.edges = direct_edges_of(roots)
+        end
+      end
+
+      private
+
+      def all_nodes_of(roots)
+        roots.inject(Set.new) do |r, root|
+          r += root.descendants
+          r << root
+        end
+      end
+
+      def direct_edges_of(roots)
+        roots.inject(Set.new) do |r, root|
+          r += root.links_as_ancestor.find(:all, :include => { :descendant => :links_as_parent }).map { |l| l.descendant.links_as_parent }.flatten
+          r += root.links_as_parent
+        end
+      end
+    end
+  end
+end

data/lib/dagnabit/node/configuration.rb

@@ -0,0 +1,26 @@
+module Dagnabit
+  module Node
+    #
+    # Configuration mechanism for nodes in a dagnabit-managed dag.
+    #
+    module Configuration
+      #
+      # Writes accessors for configuration data into a node.
+      #
+      # The following accessors are available:
+      # [link_class_name]
+      #   The name of the model used to link nodes of this class.
+      #
+      def self.extended(base)
+        base.class_inheritable_accessor :link_class_name
+      end
+
+      #
+      # Configure node behavior.
+      #
+      def configure_acts_as_dag_node(link_class_name)
+        self.link_class_name = link_class_name
+      end
+    end
+  end
+end

data/lib/dagnabit/node/neighbors.rb

@@ -0,0 +1,73 @@
+module Dagnabit
+  module Node
+    #
+    # Instance methods for finding out the neighbors of a node.
+    #
+    # These methods do _not_ behave like association proxies: they're just
+    # wrappers around <tt>ActiveRecord::Base#find</tt>.  Therefore, they do not
+    # cache, do not support calculations, do not support extension modules,
+    # named scopes, etc.
+    #
+    # These methods aren't association proxies because a link's ancestor and
+    # descendant are polymorphic associations, and ActiveRecord does not
+    # support polymorphic has_many :through associations.
+    #
+    module Neighbors
+      #
+      # Finds the parents (immediate predecessors) of this node.
+      #
+      def parents
+        links_as_child.find(:all, :include => :ancestor).map { |l| l.ancestor }
+      end
+
+      #
+      # Finds the parents (immediate predecessors) of this node satisfying a given type.
+      #
+      def parents_of_type(type)
+        links_as_child.ancestor_type(type).find(:all, :include => :ancestor).map { |l| l.ancestor }
+      end
+
+      #
+      # Finds the children (immediate successors) of this node.
+      #
+      def children
+        links_as_parent.find(:all, :include => :descendant).map { |l| l.descendant }
+      end
+
+      #
+      # Finds the children (immediate successors) of this node satisfying a given type.
+      #
+      def children_of_type(type)
+        links_as_parent.descendant_type(type).find(:all, :include => :descendant).map { |l| l.descendant }
+      end
+
+      #
+      # Find the ancestors (predecessors) of this node.
+      #
+      def ancestors
+        links_as_descendant.find(:all, :include => :ancestor).map { |l| l.ancestor }
+      end
+
+      #
+      # Find the ancestors (predecessors) of this node satisfying a given type.
+      #
+      def ancestors_of_type(type)
+        links_as_descendant.ancestor_type(type).find(:all, :include => :ancestor).map { |l| l.ancestor }
+      end
+
+      #
+      # Finds the descendants (successors) of this node.
+      #
+      def descendants
+        links_as_ancestor.find(:all, :include => :descendant).map { |l| l.descendant }
+      end
+
+      #
+      # Finds the descendants (successors) of this node satisfying a given type.
+      #
+      def descendants_of_type(type)
+        links_as_ancestor.descendant_type(type).find(:all, :include => :descendant).map { |l| l.descendant }
+      end
+    end
+  end
+end