cuporter 0.2.4 → 0.2.5

data/spec/cuporter/sort_node_spec.rb

@@ -1,187 +0,0 @@
-require 'spec_helper'
-
-module Cuporter
-  describe Node do
-    context 'sorting' do
-      it 'defaults to order of addition' do
-        root = Node.new('root')
-        root.add_child(Node.new('zebra'))
-        root.add_child(Node.new('aardvark'))
-
-        root.names.should == %w[zebra aardvark]
-      end
-
-      it 'sorts direct descendants' do
-        root = Node.new('root')
-        root.add_child(Node.new('zebra'))
-        root.add_child(Node.new('aardvark'))
-
-        root.sort_all_descendants!
-        root.names.should == %w[aardvark zebra]
-      end
-
-      it 'sorts all descendants to an arbitrary depth, such as 6' do
-        root = Node.new('root')
-        zebra  = Node.new("zebra")
-        apple  = Node.new("apple")
-        zebra1 = Node.new("zebra1")
-        apple1 = Node.new("apple1")
-        zebra2 = Node.new("zebra2")
-        apple2 = Node.new("apple2")
-        zebra3 = Node.new("zebra3")
-        apple3 = Node.new("apple3")
-        zebra4 = Node.new("zebra4")
-        apple4 = Node.new("apple4")
-        zebra5 = Node.new("zebra5")
-        apple5 = Node.new("apple5")
-        
-        zebra4.add_child(zebra5)
-        zebra4.add_child(apple5)
-        apple4.add_child(zebra5)
-        apple4.add_child(apple5)
-
-        zebra3.add_child(zebra4)
-        zebra3.add_child(apple4)
-        apple3.add_child(zebra4)
-        apple3.add_child(apple4)
-
-        zebra2.add_child(zebra3)
-        zebra2.add_child(apple3)
-        apple2.add_child(zebra3)
-        apple2.add_child(apple3)
-
-        zebra1.add_child(zebra2)
-        zebra1.add_child(apple2)
-        apple1.add_child(zebra2)
-        apple1.add_child(apple2)
-
-        zebra.add_child(zebra1)
-        zebra.add_child(apple1)
-        apple.add_child(zebra1)
-        apple.add_child(apple1)
-
-        root.add_child(zebra)
-        root.add_child(apple)
-
-        root.sort_all_descendants!
-        root.names.should == %w[apple zebra]
-        gen_1 = %w[apple1 zebra1]
-        root[:apple].names.should == gen_1
-        root[:zebra].names.should == gen_1
-
-        gen_2 = %w[apple2 zebra2]
-        root[:apple][:apple1].names.should == gen_2
-        root[:apple][:zebra1].names.should == gen_2
-        root[:zebra][:apple1].names.should == gen_2
-        root[:zebra][:zebra1].names.should == gen_2
-
-        gen_3 = %w[apple3 zebra3]
-        root[:apple][:apple1][:apple2].names.should == gen_3
-        root[:apple][:apple1][:zebra2].names.should == gen_3
-        root[:apple][:zebra1][:apple2].names.should == gen_3
-        root[:apple][:zebra1][:zebra2].names.should == gen_3
-        root[:zebra][:apple1][:apple2].names.should == gen_3
-        root[:zebra][:apple1][:zebra2].names.should == gen_3
-        root[:zebra][:zebra1][:apple2].names.should == gen_3
-        root[:zebra][:zebra1][:zebra2].names.should == gen_3
-
-        gen_4 = %w[apple4 zebra4]
-        root[:apple][:apple1][:apple2][:apple3].names.should == gen_4
-        root[:apple][:apple1][:apple2][:zebra3].names.should == gen_4
-        root[:apple][:apple1][:zebra2][:apple3].names.should == gen_4
-        root[:apple][:apple1][:zebra2][:zebra3].names.should == gen_4
-
-        root[:apple][:zebra1][:apple2][:apple3].names.should == gen_4
-        root[:apple][:zebra1][:apple2][:zebra3].names.should == gen_4
-        root[:apple][:zebra1][:zebra2][:apple3].names.should == gen_4
-        root[:apple][:zebra1][:zebra2][:zebra3].names.should == gen_4
-
-        root[:zebra][:apple1][:apple2][:apple3].names.should == gen_4
-        root[:zebra][:apple1][:apple2][:zebra3].names.should == gen_4
-        root[:zebra][:apple1][:zebra2][:apple3].names.should == gen_4
-        root[:zebra][:apple1][:zebra2][:zebra3].names.should == gen_4
-
-        root[:zebra][:zebra1][:apple2][:apple3].names.should == gen_4
-        root[:zebra][:zebra1][:apple2][:zebra3].names.should == gen_4
-        root[:zebra][:zebra1][:zebra2][:apple3].names.should == gen_4
-        root[:zebra][:zebra1][:zebra2][:zebra3].names.should == gen_4
-
-        gen_5 = %w[apple5 zebra5]
-        root[:apple][:apple1][:apple2][:apple3][:apple4].names.should == gen_5
-        root[:apple][:apple1][:apple2][:apple3][:zebra4].names.should == gen_5
-        root[:apple][:apple1][:apple2][:apple3][:apple4].names.should == gen_5
-        root[:apple][:apple1][:apple2][:apple3][:zebra4].names.should == gen_5
-        root[:apple][:apple1][:apple2][:zebra3][:apple4].names.should == gen_5
-        root[:apple][:apple1][:apple2][:zebra3][:zebra4].names.should == gen_5
-        root[:apple][:apple1][:apple2][:zebra3][:apple4].names.should == gen_5
-        root[:apple][:apple1][:apple2][:zebra3][:zebra4].names.should == gen_5
-
-        root[:apple][:apple1][:zebra2][:apple3][:apple4].names.should == gen_5
-        root[:apple][:apple1][:zebra2][:apple3][:zebra4].names.should == gen_5
-        root[:apple][:apple1][:zebra2][:apple3][:apple4].names.should == gen_5
-        root[:apple][:apple1][:zebra2][:apple3][:zebra4].names.should == gen_5
-        root[:apple][:apple1][:zebra2][:zebra3][:apple4].names.should == gen_5
-        root[:apple][:apple1][:zebra2][:zebra3][:zebra4].names.should == gen_5
-        root[:apple][:apple1][:zebra2][:zebra3][:apple4].names.should == gen_5
-        root[:apple][:apple1][:zebra2][:zebra3][:zebra4].names.should == gen_5
-
-        root[:apple][:zebra1][:apple2][:apple3][:apple4].names.should == gen_5
-        root[:apple][:zebra1][:apple2][:apple3][:zebra4].names.should == gen_5
-        root[:apple][:zebra1][:apple2][:apple3][:apple4].names.should == gen_5
-        root[:apple][:zebra1][:apple2][:apple3][:zebra4].names.should == gen_5
-        root[:apple][:zebra1][:apple2][:zebra3][:apple4].names.should == gen_5
-        root[:apple][:zebra1][:apple2][:zebra3][:zebra4].names.should == gen_5
-        root[:apple][:zebra1][:apple2][:zebra3][:apple4].names.should == gen_5
-        root[:apple][:zebra1][:apple2][:zebra3][:zebra4].names.should == gen_5
-
-        root[:apple][:zebra1][:zebra2][:apple3][:apple4].names.should == gen_5
-        root[:apple][:zebra1][:zebra2][:apple3][:zebra4].names.should == gen_5
-        root[:apple][:zebra1][:zebra2][:apple3][:apple4].names.should == gen_5
-        root[:apple][:zebra1][:zebra2][:apple3][:zebra4].names.should == gen_5
-        root[:apple][:zebra1][:zebra2][:zebra3][:apple4].names.should == gen_5
-        root[:apple][:zebra1][:zebra2][:zebra3][:zebra4].names.should == gen_5
-        root[:apple][:zebra1][:zebra2][:zebra3][:apple4].names.should == gen_5
-        root[:apple][:zebra1][:zebra2][:zebra3][:zebra4].names.should == gen_5
-
-
-        root[:zebra][:apple1][:apple2][:apple3][:apple4].names.should == gen_5
-        root[:zebra][:apple1][:apple2][:apple3][:zebra4].names.should == gen_5
-        root[:zebra][:apple1][:apple2][:apple3][:apple4].names.should == gen_5
-        root[:zebra][:apple1][:apple2][:apple3][:zebra4].names.should == gen_5
-        root[:zebra][:apple1][:apple2][:zebra3][:apple4].names.should == gen_5
-        root[:zebra][:apple1][:apple2][:zebra3][:zebra4].names.should == gen_5
-        root[:zebra][:apple1][:apple2][:zebra3][:apple4].names.should == gen_5
-        root[:zebra][:apple1][:apple2][:zebra3][:zebra4].names.should == gen_5
-
-        root[:zebra][:apple1][:zebra2][:apple3][:apple4].names.should == gen_5
-        root[:zebra][:apple1][:zebra2][:apple3][:zebra4].names.should == gen_5
-        root[:zebra][:apple1][:zebra2][:apple3][:apple4].names.should == gen_5
-        root[:zebra][:apple1][:zebra2][:apple3][:zebra4].names.should == gen_5
-        root[:zebra][:apple1][:zebra2][:zebra3][:apple4].names.should == gen_5
-        root[:zebra][:apple1][:zebra2][:zebra3][:zebra4].names.should == gen_5
-        root[:zebra][:apple1][:zebra2][:zebra3][:apple4].names.should == gen_5
-        root[:zebra][:apple1][:zebra2][:zebra3][:zebra4].names.should == gen_5
-
-        root[:zebra][:zebra1][:apple2][:apple3][:apple4].names.should == gen_5
-        root[:zebra][:zebra1][:apple2][:apple3][:zebra4].names.should == gen_5
-        root[:zebra][:zebra1][:apple2][:apple3][:apple4].names.should == gen_5
-        root[:zebra][:zebra1][:apple2][:apple3][:zebra4].names.should == gen_5
-        root[:zebra][:zebra1][:apple2][:zebra3][:apple4].names.should == gen_5
-        root[:zebra][:zebra1][:apple2][:zebra3][:zebra4].names.should == gen_5
-        root[:zebra][:zebra1][:apple2][:zebra3][:apple4].names.should == gen_5
-        root[:zebra][:zebra1][:apple2][:zebra3][:zebra4].names.should == gen_5
-
-        root[:zebra][:zebra1][:zebra2][:apple3][:apple4].names.should == gen_5
-        root[:zebra][:zebra1][:zebra2][:apple3][:zebra4].names.should == gen_5
-        root[:zebra][:zebra1][:zebra2][:apple3][:apple4].names.should == gen_5
-        root[:zebra][:zebra1][:zebra2][:apple3][:zebra4].names.should == gen_5
-        root[:zebra][:zebra1][:zebra2][:zebra3][:apple4].names.should == gen_5
-        root[:zebra][:zebra1][:zebra2][:zebra3][:zebra4].names.should == gen_5
-        root[:zebra][:zebra1][:zebra2][:zebra3][:apple4].names.should == gen_5
-        root[:zebra][:zebra1][:zebra2][:zebra3][:zebra4].names.should == gen_5
-
-      end
-
-    end
-  end
-end

data/spec/cuporter/support/functional/cli.rb

@@ -1,10 +0,0 @@
-module Spec
-  module Functional
-    module Cli
-      def one_feature(path)
-        `bin#{File::SEPARATOR}cuporter --input-file #{path}`
-      end
-    end
-  end
-end
-

data/spec/cuporter/tag_list_node_spec.rb

@@ -1,289 +0,0 @@
-require 'spec_helper'
-
-module Cuporter
-  describe TagListNode do
-    context 'new tag list node' do
-      let(:tag_list_node) {TagListNode.new("name", []) }
-      it 'is a node' do
-        tag_list_node.should be_a Node
-      end
-      
-      it 'has an empty tag list' do
-        tag_list_node.should_not have_tags
-      end
-      context 'with tags' do
-        it 'should have tags' do
-          tag_list_node = TagListNode.new("name", %w[tag_1 tag_2])
-          tag_list_node.should have_tags
-        end
-      end
-    end
-
-    context 'children' do
-      context 'with universal tags but none of their own' do
-        it 'child inherits one tag from parent' do
-          tag_list_node = TagListNode.new("parent", ["p_tag_1"])
-          tag_list_node.add_to_tag_nodes(TagListNode.new("child", []))
-
-          tag_list_node.children.size.should == 1
-          tag_list_node.children.first.name.should == "p_tag_1"
-
-          tag_list_node[:p_tag_1].children.size.should == 1
-          tag_list_node[:p_tag_1].children.first.name.should == "child"
-
-        end
-        it 'child inherits 2 tags from parent' do
-          tag_list_node = TagListNode.new("parent", ["p_tag_1", "p_tag_2"])
-          tag_list_node.add_to_tag_nodes(TagListNode.new("child", []))
-
-          tag_list_node.children.size.should == 2
-          tag_list_node.children.first.name.should == "p_tag_1"
-          tag_list_node.children.last.name.should  == "p_tag_2"
-
-          tag_list_node[:p_tag_1].children.size.should == 1
-          tag_list_node[:p_tag_1].children.first.name.should == "child"
-
-          tag_list_node[:p_tag_2].children.size.should == 1
-          tag_list_node[:p_tag_2].children.first.name.should == "child"
-
-        end
-      end
-      context 'without universal tags but some of their own' do
-        let(:tag_list_node) {TagListNode.new("parent", []) }
-        it 'child has one tag' do
-          tag_list_node.add_to_tag_nodes(TagListNode.new("child", ["c_tag_1"]))
-
-          tag_list_node.children.size.should == 1
-          tag_list_node.children.first.name.should == "c_tag_1"
-
-          tag_list_node[:c_tag_1].children.size.should == 1
-          tag_list_node[:c_tag_1].children.first.name.should == "child"
-        end
-        it 'child has two tags' do
-          tag_list_node.add_to_tag_nodes(TagListNode.new("child", ["c_tag_1", "c_tag_2"]))
-
-          tag_list_node.children.size.should == 2
-          tag_list_node.children.first.name.should == "c_tag_1"
-          tag_list_node.children.last.name.should  == "c_tag_2"
-
-          tag_list_node[:c_tag_1].children.size.should == 1
-          tag_list_node[:c_tag_1].children.first.name.should == "child"
-
-          tag_list_node[:c_tag_2].children.size.should == 1
-          tag_list_node[:c_tag_2].children.first.name.should == "child"
-        end
-      end
-      context 'with universal tags and their own tags' do
-        let(:tag_list_node) {TagListNode.new("parent",%w[p_tag_1 p_tag_2]) }
-        it "2 universal tags and 2 child tags" do
-          tag_list_node.add_to_tag_nodes(TagListNode.new("child", ["c_tag_1", "c_tag_2"]))
-
-          tag_list_node.children.size.should == 4
-          tag_list_node.children.collect do |c|
-            c.name
-          end.should == %w[p_tag_1 p_tag_2 c_tag_1 c_tag_2]
-
-          tag_list_node[:p_tag_1].children.size.should == 1
-          tag_list_node[:p_tag_1].children.first.name.should == "child"
-
-          tag_list_node[:p_tag_2].children.size.should == 1
-          tag_list_node[:p_tag_2].children.first.name.should == "child"
-
-          tag_list_node[:c_tag_1].children.size.should == 1
-          tag_list_node[:c_tag_1].children.first.name.should == "child"
-
-          tag_list_node[:c_tag_2].children.size.should == 1
-          tag_list_node[:c_tag_2].children.first.name.should == "child"
-        end
-      end
-      context 'with no tags at all' do
-        it 'top node has no children' do
-          tag_list_node = TagListNode.new("parent", [])
-          tag_list_node.add_to_tag_nodes(TagListNode.new("child", []))
-          
-          tag_list_node.should_not have_children
-
-        end
-
-      end
-
-      context 'second child with preexisting tag' do
-        it 'top node has 1 child and 2 grandchildren' do
-          tag_list_node = TagListNode.new("parent", ["p_tag_1"])
-          tag_list_node.add_to_tag_nodes(TagListNode.new("child_1", []))
-          tag_list_node.add_to_tag_nodes(TagListNode.new("child_2", []))
-
-          tag_list_node.children.size.should == 1
-          tag_list_node.children[0].name.should == "p_tag_1"
-
-          tag_list_node[:p_tag_1].children.size.should == 2
-          tag_list_node[:p_tag_1].children[0].name.should == "child_1"
-          tag_list_node[:p_tag_1].children[1].name.should == "child_2"
-        end
-
-        it '2 child nodes with 1 universal tag and 2 child tags' do
-          tag_list_node = TagListNode.new("parent", ["p_tag_1"])
-          tag_list_node.add_to_tag_nodes(TagListNode.new("child_1", ["c_tag_1"]))
-          tag_list_node.add_to_tag_nodes(TagListNode.new("child_2", ["c_tag_1", "c_tag_2"]))
-
-          tag_list_node.children.size.should == 3
-          tag_list_node.children[0].name.should == "p_tag_1"
-          tag_list_node.children[1].name.should == "c_tag_1"
-          tag_list_node.children[2].name.should == "c_tag_2"
-
-          tag_list_node[:p_tag_1].children.size.should == 2
-          tag_list_node[:p_tag_1].children[0].name.should == "child_1"
-          tag_list_node[:p_tag_1].children[1].name.should == "child_2"
-
-          tag_list_node[:c_tag_1].children.size.should == 2
-          tag_list_node[:c_tag_1].children[0].name.should == "child_1"
-          tag_list_node[:c_tag_1].children[1].name.should == "child_2"
-
-          tag_list_node[:c_tag_2].children.size.should == 1
-          tag_list_node[:c_tag_2].children[0].name.should == "child_2"
-        end
-      end
-
-      context 'child is tag list node' do
-        context '1 universal tag on parent and no universal tags on child' do
-          context "child must be initialized with parent's universal tags" do
-            it 'top node has no children' do
-              p = TagListNode.new("parent", ["p_tag_1"])
-              c = TagListNode.new("child", [] )
-              c.add_to_tag_nodes(TagListNode.new("leaf_1", []))
-
-              p.should_not have_children
-            end
-
-            it 'all leaf nodes are under parent universal tag' do
-              p = TagListNode.new("parent", ["p_tag_1"])
-              c = TagListNode.new("child", p.tags)
-              c.add_to_tag_nodes(TagListNode.new("leaf_1", []))
-              c.add_to_tag_nodes(TagListNode.new("leaf_2", []))
-              p.merge(c)
-
-              p.children.size.should == 1
-              p.children[0].name.should == "p_tag_1"
-
-              p[:p_tag_1].children.size.should == 1
-              p[:p_tag_1].children[0].name.should == "child"
-
-              p[:p_tag_1][:child].children.size.should == 2
-              p[:p_tag_1][:child].children[0].name.should == "leaf_1"
-              p[:p_tag_1][:child].children[1].name.should == "leaf_2"
-
-              p[:p_tag_1][:child][:leaf_1].should_not have_children
-              p[:p_tag_1][:child][:leaf_2].should_not have_children
-            end
-          end
-        end
-
-        context '1 universal tag on parent and 1 universal tag on child' do
-          it "2 tags have 2 leaf nodes" do
-            p = TagListNode.new("parent", ["p_tag_1"])
-            c = TagListNode.new("child", p.tags | ["c_tag_1"])
-            c.add_to_tag_nodes(TagListNode.new("leaf_1", []))
-            c.add_to_tag_nodes(TagListNode.new("leaf_2", []))
-            p.merge(c)
-
-            p.children.size.should == 2
-            p.children[0].name.should == "p_tag_1"
-            p.children[1].name.should == "c_tag_1"
-            p[:p_tag_1].children.size.should == 1
-            p[:p_tag_1].children[0].name.should == "child"
-            p[:c_tag_1].children.size.should == 1
-            p[:c_tag_1].children[0].name.should == "child"
-
-            p[:p_tag_1][:child].children.size.should == 2
-            p[:p_tag_1][:child].children[0].name.should == "leaf_1"
-            p[:p_tag_1][:child].children[1].name.should == "leaf_2"
-
-            p[:c_tag_1][:child].children.size.should == 2
-            p[:c_tag_1][:child].children[0].name.should == "leaf_1"
-            p[:c_tag_1][:child].children[1].name.should == "leaf_2"
-
-            p[:p_tag_1][:child][:leaf_1].should_not have_children
-            p[:p_tag_1][:child][:leaf_2].should_not have_children
-
-            p[:c_tag_1][:child][:leaf_1].should_not have_children
-            p[:c_tag_1][:child][:leaf_2].should_not have_children
-          end
-        end
-
-        context '1 universal tag on parent and 1 tag on 1 leaf' do
-          it "1 tag has 1 leaf node, the other has 2 leaf nodes" do
-            p = TagListNode.new("parent", ["p_tag_1"])
-            c = TagListNode.new("child", p.tags )
-            c.add_to_tag_nodes(TagListNode.new("leaf_1", []))
-            c.add_to_tag_nodes(TagListNode.new("leaf_2", ["l_tag_1"]))
-            p.merge(c)
-
-            p.children.size.should == 2
-            p.children[0].name.should == "p_tag_1"
-            p.children[1].name.should == "l_tag_1"
-            p[:p_tag_1].children.size.should == 1
-            p[:p_tag_1].children[0].name.should == "child"
-            p[:l_tag_1].children.size.should == 1
-            p[:l_tag_1].children[0].name.should == "child"
-
-            p[:p_tag_1][:child].children.size.should == 2
-            p[:p_tag_1][:child].children[0].name.should == "leaf_1"
-            p[:p_tag_1][:child].children[1].name.should == "leaf_2"
-
-            p[:l_tag_1][:child].children.size.should == 1
-            p[:l_tag_1][:child].children[0].name.should == "leaf_2"
-
-            p[:p_tag_1][:child][:leaf_1].should_not have_children
-            p[:p_tag_1][:child][:leaf_2].should_not have_children
-
-            p[:l_tag_1][:child][:leaf_2].should_not have_children
-          end
-        end
-
-        context '1 universal tag on parent 1 universal tag on child 1 tag on leaf' do
-          it "2 tags with 2 leaves, 1 tag with 1 leaf" do
-            p = TagListNode.new("parent", ["p_tag_1"])
-            c = TagListNode.new("child", p.tags | ["c_tag_1"])
-            c.add_to_tag_nodes(TagListNode.new("leaf_1", []))
-            c.add_to_tag_nodes(TagListNode.new("leaf_2", ["l_tag_1"]))
-            p.merge(c)
-
-            p.children.size.should == 3
-            p.children[0].name.should == "p_tag_1"
-            p.children[1].name.should == "c_tag_1"
-            p.children[2].name.should == "l_tag_1"
-            
-            p[:p_tag_1].children.size.should == 1
-            p[:p_tag_1].children[0].name.should == "child"
-
-            p[:c_tag_1].children.size.should == 1
-            p[:c_tag_1].children[0].name.should == "child"
-            
-            p[:l_tag_1].children.size.should == 1
-            p[:l_tag_1].children[0].name.should == "child"
-
-            p[:p_tag_1][:child].children.size.should == 2
-            p[:p_tag_1][:child].children[0].name.should == "leaf_1"
-            p[:p_tag_1][:child].children[1].name.should == "leaf_2"
-
-            p[:c_tag_1][:child].children.size.should == 2
-            p[:c_tag_1][:child].children[0].name.should == "leaf_1"
-            p[:c_tag_1][:child].children[1].name.should == "leaf_2"
-
-            p[:l_tag_1][:child].children.size.should == 1
-            p[:l_tag_1][:child].children[0].name.should == "leaf_2"
-
-            p[:p_tag_1][:child][:leaf_1].should_not have_children
-            p[:p_tag_1][:child][:leaf_2].should_not have_children
-
-            p[:c_tag_1][:child][:leaf_1].should_not have_children
-            p[:c_tag_1][:child][:leaf_2].should_not have_children
-
-            p[:l_tag_1][:child][:leaf_2].should_not have_children
-          end
-        end
-      end
-    end
-
-  end
-end

data/spec/spec_helper.rb

@@ -1,8 +0,0 @@
-require 'rubygems'
-require 'rspec'
-require 'cuporter'
-Dir["spec/cuporter/support/**/*.rb"].each { |lib| require lib }
-
-RSpec.configure do |config|
-  config.include(Spec::Functional::Cli)
-end