dagnabit 2.2.1

data/test/connections/native_postgresql/connection.rb

@@ -0,0 +1,17 @@
+print "Using native PostgreSQL\n"
+
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.configurations = {
+  'ActiveRecord::Base' => {
+    :adapter => 'postgresql',
+    :database => 'dagnabit_test',
+    :username => 'dagnabit_test',
+    :password => 'dagnabit_test',
+    :hostname => 'localhost'
+  }
+};
+
+ActiveRecord::Base.establish_connection('ActiveRecord::Base')

data/test/connections/native_sqlite3/connection.rb

@@ -0,0 +1,24 @@
+print "Using native SQLite3\n"
+
+require 'logger'
+
+# The SQLite3 Ruby driver can be present as either a gem or directly present in
+# the Ruby library load path.  This load method addresses these two situations.
+begin
+  require 'sqlite3'
+rescue LoadError
+  require 'rubygems'
+  gem 'sqlite3-ruby'
+  require 'sqlite3'
+end
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+class SqliteError < StandardError
+end
+
+ActiveRecord::Base.configurations = {
+  'ActiveRecord::Base' => { :adapter => 'sqlite3', :database => ':memory:' }
+};
+
+ActiveRecord::Base.establish_connection('ActiveRecord::Base')

data/test/dagnabit/link/test_associations.rb

@@ -0,0 +1,61 @@
+require 'helper'
+
+module Dagnabit
+  module Link
+    class TestAssociations < ActiveRecord::TestCase
+      class Node < ActiveRecord::Base
+        set_table_name 'nodes'
+      end
+
+      class Link < ActiveRecord::Base
+        set_table_name 'edges'
+        extend Dagnabit::Link::Configuration
+        configure_acts_as_dag_link({})
+        extend Dagnabit::Link::Associations
+      end
+
+      class CustomLink < ActiveRecord::Base
+        set_table_name 'other_name_edges'
+
+        extend Dagnabit::Link::Configuration
+        configure_acts_as_dag_link(:ancestor_id_column => 'the_ancestor_id',
+                                   :descendant_id_column => 'the_descendant_id',
+                                   :transitive_closure_table_name => 'my_transitive_closure')
+
+        extend Dagnabit::Link::Associations
+      end
+
+      def setup
+        @node = Node.new
+        @link = Link.new
+        @custom_link = CustomLink.new
+      end
+
+      should 'add an ancestor association proxy' do
+        @link.ancestor = @node
+        @link.save
+        assert_equal @node, @link.reload.ancestor
+      end
+
+      should 'add a descendant association proxy' do
+        @link.descendant = @node
+        @link.save
+        assert_equal @node, @link.reload.descendant
+      end
+
+      should 'permit customization of the ancestor association foreign key' do
+        @custom_link.ancestor = @node
+        @custom_link.save
+        @custom_link = CustomLink.find(@custom_link.id)
+        assert_equal @node, @custom_link.ancestor
+      end
+
+      should 'permit customization of the descendant association foreign key' do
+        @custom_link.descendant = @node
+        @custom_link.save
+        @custom_link = CustomLink.find(@custom_link.id)
+        assert_equal @node, @custom_link.descendant
+      end
+    end
+  end
+end

data/test/dagnabit/link/test_class_methods.rb

@@ -0,0 +1,102 @@
+require 'helper'
+
+module Dagnabit
+  module Link
+    class TestClassMethods < ActiveRecord::TestCase
+      should 'include a method to build edges' do
+        n1 = ::Node.new
+        n2 = ::Node.new
+
+        link = ::Link.build_edge(n1, n2)
+        assert_equal n1, link.ancestor
+        assert_equal n2, link.descendant
+      end
+
+      should 'permit custom data to be included on edges' do
+        n1 = ::Node.new
+        n2 = ::Node.new
+
+        link = CustomDataLink.build_edge(n1, n2, :data => 'foobar')
+        assert_equal 'foobar', link.data
+      end
+
+      context 'connect' do
+        should 'connect two nodes' do
+          n1 = ::Node.new
+          n2 = ::Node.new
+
+          ::Link.connect(n1, n2)
+          link = ::Link.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n2.id })
+
+          assert_not_nil link
+          assert_equal n1, link.ancestor
+          assert_equal n2, link.descendant
+        end
+
+        should 'permit custom data to be included on edges' do
+          n1 = ::Node.new
+          n2 = ::Node.new
+
+          CustomDataLink.connect(n1, n2, :data => 'foobar')
+          link = CustomDataLink.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n2.id })
+
+          assert_equal 'foobar', link.data
+        end
+
+        should 'return false if connection fails due to node invalidity' do
+          n1 = ::Node.new
+          n2 = ::Node.new
+
+          n1.stubs(:valid?).returns(false)
+
+          result = ::Link.connect(n1, n2)
+          assert_equal false, result
+        end
+
+        should 'not save endpoints if connection fails due to node invalidity' do
+          n1 = ::Node.new
+          n2 = ::Node.new
+
+          n1.stubs(:valid?).returns(false)
+
+          ::Link.connect(n1, n2)
+
+          assert n1.new_record?
+          assert n2.new_record?
+        end
+      end
+
+      context 'path?' do
+        should 'return whether or not a path exists between two nodes' do
+          n1 = ::Node.new
+          n2 = ::Node.new
+          n3 = ::Node.new
+          n4 = ::Node.new
+
+          ::Link.connect(n1, n2)
+          ::Link.connect(n2, n3)
+
+          assert ::Link.path?(n1, n2)
+          assert ::Link.path?(n1, n3)
+          assert !::Link.path?(n1, n4)
+        end
+      end
+
+      context 'paths' do
+        should 'return all paths between two nodes' do
+          n1 = ::Node.new
+          n2 = ::Node.new
+          n3 = ::Node.new
+
+          ::Link.connect(n1, n2)
+          ::Link.connect(n2, n3)
+
+          paths = ::Link.paths(n1, n3)
+          assert_equal 1, paths.length
+          assert_equal n1, paths.first.ancestor
+          assert_equal n3, paths.first.descendant
+        end
+      end
+    end
+  end
+end

data/test/dagnabit/link/test_configuration.rb

@@ -0,0 +1,38 @@
+require 'helper'
+
+module Dagnabit
+  module Link
+    class TestConfiguration < ActiveRecord::TestCase
+      should 'have default and settable names for transitive closure model and column names' do
+        default_model = Class.new(ActiveRecord::Base) do
+          set_table_name 'edges'
+
+          acts_as_dag_link
+        end
+
+        custom_model = Class.new(ActiveRecord::Base) do
+          set_table_name 'other_name_edges'
+
+          acts_as_dag_link  :ancestor_id_column => 'the_ancestor_id',
+                            :descendant_id_column => 'the_descendant_id',
+                            :transitive_closure_table_name => 'my_transitive_closure',
+                            :transitive_closure_class_name => 'MyTransitiveClosureLink'
+        end
+
+        assert_equal 'ancestor_id', default_model.ancestor_id_column
+        assert_equal 'descendant_id', default_model.descendant_id_column
+        assert_equal default_model.connection.quote_table_name('edges_transitive_closure_tuples'), default_model.transitive_closure_table_name
+        assert_equal 'TransitiveClosureLink', default_model.transitive_closure_class_name
+
+        assert_equal 'the_ancestor_id', custom_model.ancestor_id_column
+        assert_equal 'the_descendant_id', custom_model.descendant_id_column
+        assert_equal custom_model.connection.quote_table_name('my_transitive_closure'), custom_model.transitive_closure_table_name
+        assert_equal 'MyTransitiveClosureLink', custom_model.transitive_closure_class_name
+      end
+
+      should 'not have its configuration accessors on ActiveRecord::Base' do
+        assert !ActiveRecord::Base.respond_to?(:ancestor_id_column)
+      end
+    end
+  end
+end

data/test/dagnabit/link/test_cycle_prevention.rb

@@ -0,0 +1,64 @@
+require 'helper'
+
+module Dagnabit
+  module Link
+    class TestCyclePrevention < ActiveRecord::TestCase
+      should 'prevent simple cycles from being saved' do
+        n1 = ::Node.create
+        n2 = ::Node.create
+
+        l1 = ::Link.create(:ancestor => n1, :descendant => n2)
+        l2 = ::Link.create(:ancestor => n2, :descendant => n1)
+
+        assert l2.new_record?
+      end
+
+      should 'prevent self-referential nodes' do
+        n1 = ::Node.create
+
+        l1 = ::Link.create(:ancestor => n1, :descendant => n1)
+        assert l1.new_record?
+      end
+
+      should 'prevent cycles from being saved' do
+        n1 = ::Node.create
+        n2 = ::Node.create
+        n3 = ::Node.create
+        n4 = ::Node.create
+
+        ::Link.create(:ancestor => n1, :descendant => n2)
+        ::Link.create(:ancestor => n2, :descendant => n3)
+        ::Link.create(:ancestor => n3, :descendant => n4)
+        l = ::Link.create(:ancestor => n4, :descendant => n2)
+
+        assert l.new_record?
+      end
+
+      should 'not prevent links from being saved multiple times in a row' do
+        n1 = ::Node.create
+        n2 = ::Node.create
+
+        l = ::Link.new(:ancestor => n1, :descendant => n2)
+
+        assert l.save
+        assert l.save, 'should have been able to save twice'
+      end
+
+      should 'prevent cycles from being saved in customized links' do
+        n1 = ::Node.create
+        n2 = ::Node.create
+        n3 = ::Node.create
+        
+        ::CustomizedLink.create(:ancestor => n1, :descendant => n2)
+        ::CustomizedLink.create(:ancestor => n1, :descendant => n3)
+        l3 = ::CustomizedLink.create(:ancestor => n3, :descendant => n1)
+        
+        assert l3.new_record?
+      end
+
+      should 'not execute on links that have no ancestor or descendant' do
+        assert_nothing_raised { ::Link.create }
+      end
+    end
+  end
+end

data/test/dagnabit/link/test_named_scopes.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+module Dagnabit
+  module Link
+    class TestNamedScopes < ActiveRecord::TestCase
+      class OtherNode < ActiveRecord::Base
+        set_table_name 'nodes'
+      end
+
+      def setup
+        @n1 = ::Node.new
+        @n2 = OtherNode.new
+        @n3 = ::Node.new
+
+        @l1 = ::Link.build_edge(@n1, @n2)
+        @l2 = ::Link.build_edge(@n2, @n3)
+        @l1.save
+        @l2.save
+      end
+
+      should 'scope links by ancestor type' do
+        links = ::Link.ancestor_type(OtherNode.name)
+        assert_equal [@l2], links
+      end
+
+      should 'scope links by descendant type' do
+        links = ::Link.descendant_type(OtherNode.name)
+        assert_equal [@l1], links
+      end
+    end
+  end
+end

data/test/dagnabit/link/test_transitive_closure_link_model.rb

@@ -0,0 +1,69 @@
+require 'helper'
+
+module Dagnabit
+  module Link
+    class TestTransitiveClosureLinkModel < ActiveRecord::TestCase
+      def setup
+        @model = ::Link::TransitiveClosureLink.new
+        @model.class.set_table_name 'edges_transitive_closure_tuples'
+        @node = ::Node.new
+      end
+
+      should 'belong to an ancestor' do
+        @model.ancestor = @node
+        @model.save
+
+        @model = ::Link::TransitiveClosureLink.find(@model.id)
+        assert_equal @node, @model.ancestor
+      end
+
+      should 'belong to a descendant' do
+        @model.descendant = @node
+        @model.save
+
+        @model = ::Link::TransitiveClosureLink.find(@model.id)
+        assert_equal @node, @model.descendant
+      end
+
+      # TODO: wrap tests in transaction
+      should 'support find(:all) queries including associations' do
+        ::Link::TransitiveClosureLink.delete_all
+
+        n1 = ::Node.new
+        n2 = ::Node.new
+        ::Link::TransitiveClosureLink.create(:ancestor => n1, :descendant => n2)
+
+        links = ::Link::TransitiveClosureLink.find(:all, :include => :ancestor)
+        assert_equal 1, links.length
+      end
+
+      should 'support scoping by ancestor type' do
+        ::Link::TransitiveClosureLink.delete_all
+
+        n1 = ::BetaNode.new
+        n2 = ::Node.new
+
+        ::Link::TransitiveClosureLink.create(:ancestor => n1, :descendant => n2)
+
+        links = ::Link::TransitiveClosureLink.ancestor_type(::BetaNode.name)
+
+        assert_equal 1, links.length
+        assert_equal n1, links.first.ancestor
+      end
+
+      should 'support scoping by descendant type' do
+        ::Link::TransitiveClosureLink.delete_all
+
+        n1 = ::Node.new
+        n2 = ::BetaNode.new
+
+        ::Link::TransitiveClosureLink.create(:ancestor => n1, :descendant => n2)
+
+        links = ::Link::TransitiveClosureLink.descendant_type(::BetaNode.name)
+
+        assert_equal 1, links.length
+        assert_equal n2, links.first.descendant
+      end
+    end
+  end
+end

data/test/dagnabit/link/test_transitive_closure_recalculation.rb

@@ -0,0 +1,139 @@
+require 'helper'
+
+module Dagnabit
+  module Link
+    class TestTransitiveClosureRecalculation < ActiveRecord::TestCase
+      TransitiveClosureLink = ::Link::TransitiveClosureLink
+      CustomTransitiveClosureLink = CustomizedLink::TransitiveClosureLink
+      TransitiveClosureCustomDataLink = CustomDataLink::TransitiveClosureLink
+
+      should 'recalculate transitive closure on create' do
+        n1 = ::Node.create
+        n2 = ::Node.create
+        n3 = ::Node.create
+
+        ::Link.create(:ancestor => n1, :descendant => n2)
+        ::Link.create(:ancestor => n2, :descendant => n3)
+
+        tc = TransitiveClosureLink.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n3.id })
+        assert_not_nil tc, 'expected to find path from n1 to n3'
+      end
+
+      should 'transfer custom data attributes to transitive closure' do
+        n1 = ::Node.create
+        n2 = ::Node.create
+        n3 = ::Node.create
+
+        CustomDataLink.create(:ancestor => n1, :descendant => n2, :data => 'foo')
+        CustomDataLink.create(:ancestor => n2, :descendant => n3, :data => 'bar')
+
+        tc1 = TransitiveClosureCustomDataLink.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n2.id })
+        tc2 = TransitiveClosureCustomDataLink.find(:first, :conditions => { :ancestor_id => n2.id, :descendant_id => n3.id })
+        tc3 = TransitiveClosureCustomDataLink.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n3.id })
+
+        assert_equal 'foo', tc1.data, 'expected to find custom data attribute on n1->n2 edge'
+        assert_equal 'bar', tc2.data, 'expected to find custom data attribute on n2->n3 edge'
+        assert_not_nil tc3, 'expected to find path from n1 to n3'
+        assert_nil tc3.data, 'expected to find no custom data attribute on n1->n3 path'
+      end
+
+      should 'recalculate transitive closure on destroy' do
+        n1 = ::Node.create
+        n2 = ::Node.create
+        n3 = ::Node.create
+
+        l1 = ::Link.create(:ancestor => n1, :descendant => n2)
+        l2 = ::Link.create(:ancestor => n2, :descendant => n3)
+
+        l2.destroy
+
+        tc = TransitiveClosureLink.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n2.id })
+        assert_not_nil tc, 'expected to find path from n1 to n2'
+
+        tc = TransitiveClosureLink.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n3.id })
+        assert_nil tc, 'expected to not find path from n1 to n3'
+      end
+
+      should 'include edges in the graph when reconstructing the transitive closure on destroy' do
+        n1 = ::Node.create
+        n2 = ::Node.create
+        n3 = ::Node.create
+
+        l1 = ::Link.create(:ancestor => n1, :descendant => n2)
+        l2 = ::Link.create(:ancestor => n2, :descendant => n3)
+        l3 = ::Link.create(:ancestor => n1, :descendant => n3)
+
+        l1.destroy
+        l2.destroy
+
+        tc = TransitiveClosureLink.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n3.id })
+        assert_not_nil tc, 'expected to find path from n1 to n3'
+      end
+
+      should 'recalculate transitive closure on update' do
+        n1 = ::Node.create
+        n2 = ::Node.create
+        n3 = ::Node.create
+        n4 = ::Node.create
+
+        l1 = ::Link.create(:ancestor => n1, :descendant => n2)
+        l2 = ::Link.create(:ancestor => n2, :descendant => n3)
+
+        l2.update_attribute(:descendant, n4)
+
+        tc = TransitiveClosureLink.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n4.id })
+        assert_not_nil tc, 'expected to find path from n1 to n4'
+
+        tc = TransitiveClosureLink.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n3.id })
+        assert_nil tc, 'expected to not find path from n1 to n3'
+      end
+
+      should 'recalculate transitive closure on create using custom-configured link' do
+        n1 = ::Node.create
+        n2 = ::Node.create
+        n3 = ::Node.create
+
+        CustomizedLink.create(:ancestor => n1, :descendant => n2)
+        CustomizedLink.create(:ancestor => n2, :descendant => n3)
+
+        tc = CustomTransitiveClosureLink.find(:first, :conditions => { :the_ancestor_id => n1.id, :the_descendant_id => n3.id })
+        assert_not_nil tc, 'expected to find path from n1 to n3'
+      end
+
+      should 'recalculate transitive closure on destroy using custom-configured link' do
+        n1 = ::Node.create
+        n2 = ::Node.create
+        n3 = ::Node.create
+
+        l1 = CustomizedLink.create(:ancestor => n1, :descendant => n2)
+        l2 = CustomizedLink.create(:ancestor => n2, :descendant => n3)
+
+        l2.destroy
+
+        tc = CustomTransitiveClosureLink.find(:first, :conditions => { :the_ancestor_id => n1.id, :the_descendant_id => n2.id })
+        assert_not_nil tc, 'expected to find path from n1 to n2'
+
+        tc = CustomTransitiveClosureLink.find(:first, :conditions => { :the_ancestor_id => n1.id, :the_descendant_id => n3.id })
+        assert_nil tc, 'expected to not find path from n1 to n3'
+      end
+
+      should 'recalculate transitive closure on update using custom-configured link' do
+        n1 = ::Node.create
+        n2 = ::Node.create
+        n3 = ::Node.create
+        n4 = ::Node.create
+
+        l1 = CustomizedLink.create(:ancestor => n1, :descendant => n2)
+        l2 = CustomizedLink.create(:ancestor => n2, :descendant => n3)
+
+        l2.update_attribute(:descendant, n4)
+
+        tc = CustomTransitiveClosureLink.find(:first, :conditions => { :the_ancestor_id => n1.id, :the_descendant_id => n4.id })
+        assert_not_nil tc, 'expected to find path from n1 to n4'
+
+        tc = CustomTransitiveClosureLink.find(:first, :conditions => { :the_ancestor_id => n1.id, :the_descendant_id => n3.id })
+        assert_nil tc, 'expected to not find path from n1 to n3'
+      end
+    end
+  end
+end