dagnabit 2.2.6 → 3.0.0

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

@@ -1,125 +0,0 @@
-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} (#{tc_aid}, #{tc_did}, #{tc_atype}, #{tc_dtype})
-                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} (#{tc_aid}, #{tc_did}, #{tc_atype}, #{tc_dtype})
-                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} (#{tc_aid}, #{tc_did}, #{tc_atype}, #{tc_dtype})
-                SELECT * FROM (
-                  SELECT #{tc_aid}, #{tc_did}, #{tc_atype}, #{tc_dtype} 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

@@ -1,17 +0,0 @@
-module Dagnabit
-  module Link
-    module TransitiveClosureRecalculation
-      module OnUpdate
-        def after_update
-          current_values = dag_link_column_names.map { |n| connection.quote(send(n)) }
-          old_values = dag_link_column_names.map { |n| connection.quote(changes[n].try(:first) || send(n)) }
-
-          return unless current_values != old_values
-
-          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

@@ -1,56 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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)
-        OpenStruct.new.tap 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

@@ -1,26 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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