lalala 4.0.0.dev.136 → 4.0.0.dev.141

data/vendor/deps/closure_tree/spec/tag_spec.rb

@@ -1,469 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for "Tag (1)" do
-
-  it "has correct accessible_attributes" do
-    Tag.accessible_attributes.to_a.should =~ %w(parent name)
-  end
-
-  describe "empty db" do
-
-    def nuke_db
-      TagHierarchy.delete_all
-      Tag.delete_all
-    end
-
-    before :each do
-      nuke_db
-    end
-
-    context "empty db" do
-      it "should return no entities" do
-        Tag.roots.should be_empty
-        Tag.leaves.should be_empty
-      end
-    end
-
-    context "1 tag db" do
-      it "should return the only entity as a root and leaf" do
-        a = Tag.create!(:name => "a")
-        Tag.roots.should == [a]
-        Tag.leaves.should == [a]
-      end
-    end
-
-    context "2 tag db" do
-      before :each do
-        @root = Tag.create!(:name => "root")
-        @leaf = @root.add_child(Tag.create!(:name => "leaf"))
-      end
-      it "should return a simple root and leaf" do
-        Tag.roots.should == [@root]
-        Tag.leaves.should == [@leaf]
-      end
-      it "should return child_ids for root" do
-        @root.child_ids.should == [@leaf.id]
-      end
-      it "should return an empty array for leaves" do
-        @leaf.child_ids.should be_empty
-      end
-    end
-
-    context "3 tag collection.create db" do
-      before :each do
-        @root = Tag.create! :name => "root"
-        @mid = @root.children.create! :name => "mid"
-        @leaf = @mid.children.create! :name => "leaf"
-        DestroyedTag.delete_all
-      end
-
-      it "should create all tags" do
-        Tag.all.should =~ [@root, @mid, @leaf]
-      end
-
-      it "should return a root and leaf without middle tag" do
-        Tag.roots.should == [@root]
-        Tag.leaves.should == [@leaf]
-      end
-
-      it "should delete leaves" do
-        Tag.leaves.destroy_all
-        Tag.roots.should == [@root] # untouched
-        Tag.leaves.should == [@mid]
-      end
-
-      it "should delete everything if you delete the roots" do
-        Tag.roots.destroy_all
-        Tag.all.should be_empty
-        Tag.roots.should be_empty
-        Tag.leaves.should be_empty
-        DestroyedTag.all.collect { |t| t.name }.should =~ %w{root mid leaf}
-      end
-    end
-
-    context "3 tag explicit_create db" do
-      before :each do
-        @root = Tag.create!(:name => "root")
-        @mid = @root.add_child(Tag.create!(:name => "mid"))
-        @leaf = @mid.add_child(Tag.create!(:name => "leaf"))
-      end
-
-      it "should create all tags" do
-        Tag.all.should =~ [@root, @mid, @leaf]
-      end
-
-      it "should return a root and leaf without middle tag" do
-        Tag.roots.should == [@root]
-        Tag.leaves.should == [@leaf]
-      end
-
-      it "should prevent parental loops from torso" do
-        @mid.children << @root
-        @root.valid?.should be_false
-        @mid.reload.children.should == [@leaf]
-      end
-
-      it "should prevent parental loops from toes" do
-        @leaf.children << @root
-        @root.valid?.should be_false
-        @leaf.reload.children.should be_empty
-      end
-
-      it "should support re-parenting" do
-        @root.children << @leaf
-        Tag.leaves.should == [@leaf, @mid]
-      end
-
-      it "cleans up hierarchy references for leaves" do
-        @leaf.destroy
-        TagHierarchy.find_all_by_ancestor_id(@leaf.id).should be_empty
-        TagHierarchy.find_all_by_descendant_id(@leaf.id).should be_empty
-      end
-
-      it "cleans up hierarchy references" do
-        @mid.destroy
-        TagHierarchy.find_all_by_ancestor_id(@mid.id).should be_empty
-        TagHierarchy.find_all_by_descendant_id(@mid.id).should be_empty
-        @root.reload.should be_root
-        root_hiers = @root.ancestor_hierarchies.to_a
-        root_hiers.size.should == 1
-        TagHierarchy.find_all_by_ancestor_id(@root.id).should == root_hiers
-        TagHierarchy.find_all_by_descendant_id(@root.id).should == root_hiers
-      end
-    end
-
-    it "performs as the readme says it does" do
-      grandparent = Tag.create(:name => 'Grandparent')
-      parent = grandparent.children.create(:name => 'Parent')
-      child1 = Tag.create(:name => 'First Child', :parent => parent)
-      child2 = Tag.new(:name => 'Second Child')
-      parent.children << child2
-      child3 = Tag.new(:name => 'Third Child')
-      parent.add_child child3
-      grandparent.self_and_descendants.collect(&:name).should ==
-        ["Grandparent", "Parent", "First Child", "Second Child", "Third Child"]
-      child1.ancestry_path.should ==
-        ["Grandparent", "Parent", "First Child"]
-      child3.ancestry_path.should ==
-        ["Grandparent", "Parent", "Third Child"]
-      d = Tag.find_or_create_by_path %w(a b c d)
-      h = Tag.find_or_create_by_path %w(e f g h)
-      e = h.root
-      d.add_child(e) # "d.children << e" would work too, of course
-      h.ancestry_path.should == %w(a b c d e f g h)
-    end
-
-  end
-
-  context "paths" do
-    before :each do
-      @child = Tag.find_or_create_by_path(%w(grandparent parent child))
-      @child.title = "Kid"
-      @parent = @child.parent
-      @parent.title = "Mom"
-      @grandparent = @parent.parent
-      @grandparent.title = "Nonnie"
-      [@child, @parent, @grandparent].each { |ea| ea.save! }
-    end
-
-    it "should build ancestry path" do
-      @child.ancestry_path.should == %w{grandparent parent child}
-      @child.ancestry_path(:name).should == %w{grandparent parent child}
-      @child.ancestry_path(:title).should == %w{Nonnie Mom Kid}
-    end
-
-    it "should find by path" do
-      # class method:
-      Tag.find_by_path(%w{grandparent parent child}).should == @child
-      # instance method:
-      @parent.find_by_path(%w{child}).should == @child
-      @grandparent.find_by_path(%w{parent child}).should == @child
-      @parent.find_by_path(%w{child larvae}).should be_nil
-    end
-
-    it "finds correctly rooted paths" do
-      decoy = Tag.find_or_create_by_path %w(a b c d)
-      b_d = Tag.find_or_create_by_path %w(b c d)
-      Tag.find_by_path(%w(b c d)).should == b_d
-      Tag.find_by_path(%w(c d)).should be_nil
-    end
-
-    it "find_by_path for 1 node" do
-      b = Tag.find_or_create_by_path %w(a b)
-      b2 = b.root.find_by_path(%w(b))
-      b2.should == b
-    end
-
-    it "find_by_path for 2 nodes" do
-      c = Tag.find_or_create_by_path %w(a b c)
-      c.root.find_by_path(%w(b c)).should == c
-      c.root.find_by_path(%w(a c)).should be_nil
-      c.root.find_by_path(%w(c)).should be_nil
-    end
-
-    it "find_by_path for 3 nodes" do
-      d = Tag.find_or_create_by_path %w(a b c d)
-      d.root.find_by_path(%w(b c d)).should == d
-      Tag.find_by_path(%w(a b c d)).should == d
-      Tag.find_by_path(%w(d)).should be_nil
-    end
-
-    it "should return nil for missing nodes" do
-      Tag.find_by_path(%w{missing}).should be_nil
-      Tag.find_by_path(%w{grandparent missing}).should be_nil
-      Tag.find_by_path(%w{grandparent parent missing}).should be_nil
-      Tag.find_by_path(%w{grandparent parent missing child}).should be_nil
-    end
-
-    it "should find or create by path" do
-      # class method:
-      grandparent = Tag.find_or_create_by_path(%w{grandparent})
-      grandparent.should == @grandparent
-      child = Tag.find_or_create_by_path(%w{grandparent parent child})
-      child.should == @child
-      Tag.find_or_create_by_path(%w{events anniversary}).ancestry_path.should == %w{events anniversary}
-      a = Tag.find_or_create_by_path(%w{a})
-      a.ancestry_path.should == %w{a}
-      # instance method:
-      a.find_or_create_by_path(%w{b c}).ancestry_path.should == %w{a b c}
-    end
-  end
-end
-
-shared_examples_for "Tag (2)" do
-  describe "Tag (2)" do
-
-    fixtures :tags
-
-    before :each do
-      Tag.rebuild!
-      DestroyedTag.delete_all
-    end
-
-    context "class injection" do
-      it "should build hierarchy classname correctly" do
-        Tag.hierarchy_class.to_s.should == "TagHierarchy"
-        Tag.hierarchy_class_name.should == "TagHierarchy"
-        Tag.short_hierarchy_class_name.should == "TagHierarchy"
-      end
-
-      it "should have a correct parent column name" do
-        Tag.parent_column_name.should == "parent_id"
-      end
-    end
-
-    context "roots" do
-      it "should find global roots" do
-        roots = Tag.roots.to_a
-        roots.should be_member(tags(:people))
-        roots.should be_member(tags(:events))
-        roots.should_not be_member(tags(:child))
-        tags(:people).root?.should be_true
-        tags(:child).root?.should be_false
-      end
-
-      it "should find an instance root" do
-        tags(:grandparent).root.should == tags(:grandparent)
-        tags(:parent).root.should == tags(:grandparent)
-        tags(:child).root.should == tags(:grandparent)
-      end
-    end
-
-    context "leaves" do
-      it "should assemble global leaves" do
-        Tag.leaves.size.should > 0
-        Tag.leaves.each { |t| t.children.should be_empty, "#{t.name} was returned by leaves but has children: #{t.children}" }
-        Tag.leaves.each { |t| t.should be_leaf, "{t.name} was returned by leaves but was not a leaf" }
-      end
-
-      it "should assemble instance leaves" do
-        tags(:grandparent).leaves.should == [tags(:child)]
-        tags(:parent).leaves.should == [tags(:child)]
-        tags(:child).leaves.should == [tags(:child)]
-      end
-    end
-
-    context "adding children" do
-      it "should work explicitly" do
-        sb = Tag.create!(:name => "Santa Barbara")
-        sb.leaf?.should_not be_nil
-        tags(:california).add_child sb
-        sb.leaf?.should_not be_nil
-        validate_city_tag sb
-      end
-
-      it "should work implicitly through the collection" do
-        eg = Tag.create!(:name => "El Granada")
-        eg.leaf?.should_not be_nil
-        tags(:california).children << eg
-        eg.leaf?.should_not be_nil
-        validate_city_tag eg
-      end
-
-      it "should fail to create ancestor loops" do
-        child = tags(:child)
-        parent = child.parent
-        child.add_child(parent) # this should fail
-        parent.valid?.should be_false
-        child.reload.children.should be_empty
-        parent.reload.children.should == [child]
-      end
-
-      it "should move non-leaves" do
-        # This is what the fixture should encode:
-        tags(:d2).ancestry_path.should == %w{a1 b2 c2 d2}
-        tags(:b1).add_child(tags(:c2))
-        tags(:b2).leaf?.should_not be_nil
-        tags(:b1).children.include?(tags(:c2)).should be_true
-        tags(:d2).reload.ancestry_path.should == %w{a1 b1 c2 d2}
-      end
-
-      it "should move leaves" do
-        l = Tag.find_or_create_by_path(%w{leaftest branch1 leaf})
-        b2 = Tag.find_or_create_by_path(%w{leaftest branch2})
-        b2.children << l
-        l.ancestry_path.should == %w{leaftest branch2 leaf}
-      end
-
-      it "should move roots" do
-        l1 = Tag.find_or_create_by_path(%w{roottest1 branch1 leaf1})
-        l2 = Tag.find_or_create_by_path(%w{roottest2 branch2 leaf2})
-        l1.children << l2.root
-        l1.reload.ancestry_path.should == %w{roottest1 branch1 leaf1}
-        l2.reload.ancestry_path.should == %w{roottest1 branch1 leaf1 roottest2 branch2 leaf2}
-      end
-
-      it "should cascade delete all children" do
-        b2 = tags(:b2)
-        entities = b2.self_and_descendants.to_a
-        names = b2.self_and_descendants.collect { |t| t.name }
-        b2.destroy
-        entities.each { |e| Tag.find_by_id(e.id).should be_nil }
-        DestroyedTag.all.collect { |t| t.name }.should =~ names
-      end
-    end
-
-    context "injected attributes" do
-      it "should compute level correctly" do
-        tags(:grandparent).level.should == 0
-        tags(:parent).level.should == 1
-        tags(:child).level.should == 2
-      end
-
-      it "should determine parent correctly" do
-        tags(:grandparent).parent.should == nil
-        tags(:parent).parent.should == tags(:grandparent)
-        tags(:child).parent.should == tags(:parent)
-      end
-
-      it "should have a sane children collection" do
-        tags(:grandparent).children.include? tags(:parent).should be_true
-        tags(:parent).children.include? tags(:child).should be_true
-        tags(:child).children.should be_empty
-      end
-
-      it "assembles siblings correctly" do
-        tags(:b1).siblings.to_a.should =~ [tags(:b2)]
-        tags(:a1).siblings.to_a.should =~ (Tag.roots.to_a - [tags(:a1)])
-        tags(:a1).self_and_siblings.to_a.should =~ Tag.roots.to_a
-
-        # must be ordered
-        tags(:indoor).siblings.to_a.should == [tags(:home), tags(:museum), tags(:outdoor), tags(:united_states)]
-        tags(:indoor).self_and_siblings.to_a.should == [tags(:home), tags(:indoor), tags(:museum), tags(:outdoor), tags(:united_states)]
-      end
-
-      it "assembles siblings before correctly" do
-        tags(:home).siblings_before.to_a.should == []
-        tags(:indoor).siblings_before.to_a.should == [tags(:home)]
-        tags(:outdoor).siblings_before.to_a.should == [tags(:home), tags(:indoor), tags(:museum)]
-        tags(:united_states).siblings_before.to_a.should == [tags(:home), tags(:indoor), tags(:museum), tags(:outdoor)]
-      end
-
-      it "assembles siblings after correctly" do
-        tags(:indoor).siblings_after.to_a.should == [tags(:museum), tags(:outdoor), tags(:united_states)]
-        tags(:outdoor).siblings_after.to_a.should == [tags(:united_states)]
-        tags(:united_states).siblings_after.to_a.should == []
-      end
-
-      it "assembles ancestors" do
-        tags(:child).ancestors.should == [tags(:parent), tags(:grandparent)]
-        tags(:child).self_and_ancestors.should == [tags(:child), tags(:parent), tags(:grandparent)]
-      end
-
-      it "assembles descendants" do
-        tags(:parent).descendants.should == [tags(:child)]
-        tags(:parent).self_and_descendants.should == [tags(:parent), tags(:child)]
-        tags(:grandparent).descendants.should == [tags(:parent), tags(:child)]
-        tags(:grandparent).self_and_descendants.should == [tags(:grandparent), tags(:parent), tags(:child)]
-        tags(:grandparent).self_and_descendants.collect { |t| t.name }.join(" > ").should == "grandparent > parent > child"
-      end
-    end
-
-
-    def validate_city_tag city
-      tags(:california).children.include?(city).should_not be_nil
-      city.ancestors.should == [tags(:california), tags(:united_states), tags(:places)]
-      city.self_and_ancestors.should == [city, tags(:california), tags(:united_states), tags(:places)]
-    end
-
-  end
-end
-
-describe Tag do
-  it "should not include ActiveModel::ForbiddenAttributesProtection" do
-    if defined?(ActiveModel::ForbiddenAttributesProtection)
-      Tag.ancestors.should_not include(ActiveModel::ForbiddenAttributesProtection)
-    end
-  end
-  it_behaves_like "Tag (1)"
-  it_behaves_like "Tag (2)"
-end
-
-describe "Tag with AR whitelisted attributes enabled" do
-  before(:all) do
-    ActiveRecord::Base.attr_accessible(nil) # turn on whitelisted attributes
-    ActiveRecord::Base.descendants.each { |ea| ea.reset_column_information }
-  end
-  it "should not include ActiveModel::ForbiddenAttributesProtection" do
-    if defined?(ActiveModel::ForbiddenAttributesProtection)
-      Tag.ancestors.should_not include(ActiveModel::ForbiddenAttributesProtection)
-    end
-  end
-  it_behaves_like "Tag (1)"
-  it_behaves_like "Tag (2)"
-end
-
-# This has to be the last one, because we include strong parameters into Tag
-describe "Tag with strong parameters" do
-  before(:all) do
-    require 'strong_parameters'
-    class Tag
-      include ActiveModel::ForbiddenAttributesProtection
-    end
-  end
-  it_behaves_like "Tag (1)"
-  it_behaves_like "Tag (2)"
-end
-
-describe "Tag with UUID" do
-  before(:all) do
-    # Change tables
-    Tag.table_name = Tag.table_name.gsub('tags', 'tags_uuid')
-    Tag.reset_column_information
-    TagHierarchy.table_name = TagHierarchy.table_name.gsub('tag_hierarchies', 'tag_hierarchies_uuid')
-    TagHierarchy.reset_column_information
-
-    # We have to reset a few other caches
-    Tag.closure_tree_options[:hierarchy_table_name] = 'tag_hierarchies_uuid'
-    Tag.reflections.each do |key, ref|
-      ref.instance_variable_set('@table_name', nil)
-      ref.instance_variable_set('@quoted_table_name', nil)
-      ref.options[:order].sub! 'tag_hierarchies', 'tag_hierarchies_uuid' if ref.options[:order]
-    end
-
-    # Add ID
-    Tag.before_create { self.id = UUIDTools::UUID.random_create.to_s }
-  end
-
-  it_behaves_like "Tag (1)"
-end

data/vendor/deps/closure_tree/spec/user_spec.rb

@@ -1,136 +0,0 @@
-require 'spec_helper'
-
-describe "empty db" do
-
-  before :each do
-    ReferralHierarchy.delete_all
-    User.delete_all
-  end
-
-  context "empty db" do
-    it "should return no entities" do
-      User.roots.should be_empty
-      User.leaves.should be_empty
-    end
-  end
-
-  context "1 user db" do
-    it "should return the only entity as a root and leaf" do
-      a = User.create!(:email => "me@domain.com")
-      User.roots.should == [a]
-      User.leaves.should == [a]
-    end
-  end
-
-  context "2 user db" do
-    it "should return a simple root and leaf" do
-      root = User.create!(:email => "first@t.co")
-      leaf = root.children.create!(:email => "second@t.co")
-      User.roots.should == [root]
-      User.leaves.should == [leaf]
-    end
-  end
-
-
-  context "3 User collection.create db" do
-    before :each do
-      @root = User.create! :email => "poppy@t.co"
-      @mid = @root.children.create! :email => "matt@t.co"
-      @leaf = @mid.children.create! :email => "james@t.co"
-      @root_id = @root.id
-    end
-
-    it "should create all Users" do
-      User.all.should =~ [@root, @mid, @leaf]
-    end
-
-    it "should return a root and leaf without middle User" do
-      User.roots.should == [@root]
-      User.leaves.should == [@leaf]
-    end
-
-    it "should delete leaves" do
-      User.leaves.destroy_all
-      User.roots.should == [@root] # untouched
-      User.leaves.should == [@mid]
-    end
-
-    it "should delete roots and maintain hierarchies" do
-      User.roots.destroy_all
-      assert_mid_and_leaf_remain
-    end
-
-    it "should root all children" do
-      @root.destroy
-      assert_mid_and_leaf_remain
-    end
-
-    def assert_mid_and_leaf_remain
-      ReferralHierarchy.find_all_by_ancestor_id(@root_id).should be_empty
-      ReferralHierarchy.find_all_by_descendant_id(@root_id).should be_empty
-      @mid.ancestry_path.should == %w{matt@t.co}
-      @leaf.ancestry_path.should == %w{matt@t.co james@t.co}
-      @mid.self_and_descendants.should =~ [@mid, @leaf]
-      User.roots.should == [@mid]
-      User.leaves.should == [@leaf]
-    end
-  end
-
-  it "supports users with contracts" do
-    u = User.find_or_create_by_path(%w(a@t.co b@t.co c@t.co))
-    u.descendant_ids.should == []
-    u.ancestor_ids.should == [u.parent.id, u.root.id]
-    u.root.descendant_ids.should == [u.parent.id, u.id]
-    u.root.ancestor_ids.should == []
-    c1 = u.contracts.create!
-    c2 = u.parent.contracts.create!
-    u.root.indirect_contracts.to_a.should =~ [c1, c2]
-  end
-
-  it "supports << on shallow unsaved hierarchies" do
-    a = User.new(:email => "a")
-    b = User.new(:email => "b")
-    a.children << b
-    a.save
-    User.roots.should == [a]
-    User.leaves.should == [b]
-    b.ancestry_path.should == %w(a b)
-  end
-
-  it "supports << on deep unsaved hierarchies" do
-    a = User.new(:email => "a")
-    b1 = User.new(:email => "b1")
-    a.children << b1
-    b2 = User.new(:email => "b2")
-    a.children << b2
-    c1 = User.new(:email => "c1")
-    b2.children << c1
-    c2 = User.new(:email => "c2")
-    b2.children << c2
-    d = User.new(:email => "d")
-    c2.children << d
-
-    a.save
-    User.roots.should == [a]
-    User.leaves.should =~ [b1, c1, d]
-    d.ancestry_path.should == %w(a b2 c2 d)
-  end
-
-  it "supports siblings" do
-    User.order_option.should be_nil
-    a = User.create(:email => "a")
-    b1 = a.children.create(:email => "b1")
-    b2 = a.children.create(:email => "b2")
-    b3 = a.children.create(:email => "b3")
-    a.siblings.should be_empty
-    b1.siblings.should =~ [b2, b3]
-  end
-
-  it "properly nullifies descendents" do
-    c = User.find_or_create_by_path %w(a b c)
-    b = c.parent
-    c.root.destroy
-    b.reload.should be_root
-    b.child_ids.should == [c.id]
-  end
-end

data/vendor/deps/closure_tree/tests.sh

@@ -1,19 +0,0 @@
-#!/bin/sh -ex
-export BUNDLE_GEMFILE RMI DB
-
-for RMI in 1.8.7-p370 1.9.3-p327
-do
-  rbenv local $RMI
-  gem install bundler rake # < just to make sure
-  rbenv rehash || true
-
-  for BUNDLE_GEMFILE in ci/Gemfile.rails-3.0.x ci/Gemfile.rails-3.1.x ci/Gemfile.rails-3.2.x
-  do
-    bundle update --quiet
-    for DB in sqlite mysql postgresql
-    do
-      echo $DB $BUNDLE_GEMFILE `ruby -v`
-      bundle exec rake specs_with_db_ixes
-    done
-  done
-done