dagnabit 2.2.6 → 3.0.0

data/test/connections/native_sqlite3/connection.rb

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

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

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

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

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

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

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

@@ -1,178 +0,0 @@
-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 'recalculate transitive closure when destroying links with custom data' do
-        n1 = ::Node.create
-        n2 = ::Node.create
-        n3 = ::Node.create
-        n4 = ::Node.create
-
-        l1 = CustomDataLink.create(:ancestor => n1, :descendant => n2, :data => 'foo')
-        l2 = CustomDataLink.create(:ancestor => n2, :descendant => n3, :data => 'bar')
-        l3 = CustomDataLink.create(:ancestor => n3, :descendant => n4, :data => 'baz')
-
-        l2.destroy
-
-        tc1 = TransitiveClosureCustomDataLink.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n2.id })
-        assert_not_nil tc1, 'expected to find path from n1 to n2'
-        assert_equal 'foo', tc1.data, 'expected to find custom data attribute on n1->n2 edge'
-
-        tc2 = TransitiveClosureCustomDataLink.find(:first, :conditions => { :ancestor_id => n3.id, :descendant_id => n4.id })
-        assert_not_nil tc2, 'expected to find path from n3 to n4'
-        assert_equal 'baz', tc2.data, 'expected to find custom data attribute on n3->n4 edge'
-
-        tc = TransitiveClosureCustomDataLink.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n3.id })
-        assert_nil tc, 'expected to not find path from n1 to n3'
-        tc = TransitiveClosureCustomDataLink.find(:first, :conditions => { :ancestor_id => n2.id, :descendant_id => n4.id })
-        assert_nil tc, 'expected to not find path from n2 to n4'
-        tc = TransitiveClosureCustomDataLink.find(:first, :conditions => { :ancestor_id => n1.id, :descendant_id => n4.id })
-        assert_nil tc, 'expected to not find path from n1 to n4'
-      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
-
-      should "not recalculate transitive closure if neither a link's source nor target changed" do
-        n1 = ::Node.create
-        n2 = ::Node.create
-
-        l1 = ::Link.new(:ancestor => n1, :descendant => n2)
-
-        l1.expects(:update_transitive_closure_for_destroy).never
-        l1.save
-        l1.save
-      end
-    end
-  end
-end