ul-wukong 4.1.0

data/spec/examples/workflow/cherry_pie_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+# require 'wukong'
+
+# require 'hanuman/graphvizzer/gv_presenter'
+
+# describe 'cherry_pie' do
+
+#   # it 'fiddles' do
+#   #   load(Pathname.path_to(:examples, 'workflow/cherry_pie.rb'))
+#   #   Wukong.workflow(:cherry_pie) do
+#   #     Log.dump self
+#   #
+#   #     graph(:crust) do
+#   #       Log.dump self
+#   #       action(:bob)
+#   #     end
+#   #
+#   #     Log.dump graph(:crust)
+#   #
+#   #   end
+#   # end
+
+
+#   describe 'Graphviz View', :if => GRAPHVIZ do
+#     it 'makes a png' do
+#       require Pathname.path_to(:examples, 'workflow/cherry_pie.rb')
+
+#       gv = Wukong.to_graphviz
+
+#       basename = Pathname.path_to(:tmp, 'cherry_pie')
+#       gv.save(basename, 'png')
+#       puts File.read("#{basename}.dot")
+#     end
+#   end
+
+# end

data/spec/hanuman/graph_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe Hanuman::Graph, :hanuman => true do
+
+  include_context "graphs"
+  
+  context "#ancestors" do
+    context "called without any arguments" do
+      it "returns all stages with an ancestor" do
+        graph.ancestors.size.should == 4
+      end
+    end
+
+    context "called with a stage as the first argument" do
+      it "returns the immediate ancestors of the stage" do
+        graph.ancestors(graph.stages[:second]).size.should == 2
+      end
+    end
+  end
+
+  context "#descendents" do
+    context "called without any arguments" do
+      it "returns all stages with a descendent" do
+        graph.descendents.size.should == 4
+      end
+    end
+
+    context "called with a stage as the first argument" do
+      it "returns the immediate descendents of the stage" do
+        graph.descendents(graph.stages[:second]).size.should == 2
+      end
+    end
+  end
+
+  context "#add_stage" do
+    let(:stage) { Hanuman::Stage.receive(label: :orphan) }
+    it "adds the stage to the graph" do
+      expect { graph.add_stage(stage) }.to change { graph.stages[:orphan] }.from(nil).to(stage)
+    end
+    it "doesn't create any links" do
+      expect { graph.add_stage(stage) }.to_not change { graph.links }
+    end
+  end
+
+  context "#add_link" do
+    context "when adding a new stage" do
+      let(:from) { graph.stages[:fourth]  }
+      let(:into) { Hanuman::Stage.receive(label: :fifth) }
+      it "adds the new stage to the graph" do
+        expect { graph.add_link(:simple, from, into) }.to change { graph.stages[:fifth] }.from(nil).to(into)
+      end
+      it "adds the new link to the graph" do
+        expect { graph.add_link(:simple, from, into) }.to change { graph.links.size }.by(1)
+      end
+    end
+    context "when adding an existing link" do
+      let(:from) { graph.stages[:third_a] }
+      let(:into) { graph.stages[:fourth]  }
+      it "duplicates the link in the graph" do
+        expect { graph.add_link(:simple, from, into) }.to change { graph.links.size }.by(1)
+      end
+    end
+    context "when making a cycle" do
+      let(:from) { graph.stages[:fourth] }
+      let(:into) { graph.stages[:first_a]  }
+      it "adds the link in the graph" do
+        expect { graph.add_link(:simple, from, into) }.to change { graph.links.size }.by(1)
+      end
+    end
+    context "when linking a stage to itself" do
+      let(:from) { tree.stages[:fourth] }
+      let(:into) { tree.stages[:fourth]  }
+      it "adds the link in the graph" do
+        expect { graph.add_link(:simple, from, into) }.to change { graph.links.size }.by(1)
+      end
+    end
+  end
+  
+end
+
+describe Hanuman::GraphBuilder, :hanuman => true do
+
+  it_behaves_like 'a Stage::Builder'
+  
+  its(:namespace){ should be(Hanuman::Graph) }
+  
+  context '#define' do
+    let(:block_arg){ ->(){ def say() "I'm the Juggernaut!" ; end } }
+    
+    it 'evalutes a supplied block itself' do
+      subject.label = :juggernaut
+      subject.should_receive(:instance_eval).with(&block_arg)
+      subject.define(&block_arg)
+    end
+  end
+  
+  context '#build' do
+    before do
+      Wukong.processor(:foo) do
+        field :bones, String
+      end
+      Wukong.dataflow(:bar) do
+        foo
+      end
+    end
+    
+    let(:graph){ Wukong.registry.retrieve(:bar) }
+    it 'builds stages with specific options' do
+      built = graph.build(foo: { bones: 'lala' })
+      built.stages[:foo].bones.should eq('lala')
+    end
+  end
+  
+  context '#serialize' do
+    it 'serializes into a Hash with stages and links' do
+      subject.serialize.should include(:stages, :links)
+    end  
+  end
+end

data/spec/hanuman/hanuman_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Hanuman do
+  
+  it_behaves_like Hanuman::Shortcuts
+
+  it{ should respond_to(:stage) }
+  it{ should respond_to(:graph) }
+
+end

data/spec/hanuman/registry_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Hanuman::Registry, :hanuman => true do
+
+  before(:each) do
+    @orig_reg = Hanuman.registry.show
+    Hanuman.registry.clear!
+  end
+
+  after(:each) do
+    Hanuman.registry.clear!
+    Hanuman.registry.merge!(@orig_reg)
+  end
+  
+  let(:definition){ { :universe => 'Marvel' }                 }
+  let(:builder)   { Hanuman::StageBuilder.receive(definition) }
+  
+  context '#create' do
+    context 'non-existing entry' do
+      it 'creates a new entry for supplied definition' do
+        subject.create(:storm, builder).should be true
+        subject.should be_registered(:storm)
+        subject.retrieve(:storm).should == builder
+      end
+    end
+
+    context 'existing' do
+      it 'does not create a new entry' do
+        subject.create(:storm, builder)
+        subject.create(:storm, builder).should be false
+      end
+    end
+  end
+
+  context '#update' do
+    context 'non-existing entry' do
+      it 'does not update the entry' do
+        subject.update(:rogue, definition).should be false
+        subject.should_not be_registered(:rogue)
+      end
+    end
+
+    context 'existing' do
+      let(:new_definition){ { :universe => 'alternate' } }
+      
+      it 'updates the entry' do
+        subject.create(:rogue, builder)
+        subject.update(:rogue, new_definition).should be true
+        subject.retrieve(:rogue).serialize.should include(new_definition)
+      end
+    end    
+  end
+
+  context '#create_or_update' do
+    context 'non-existing entry' do
+      it 'creates the entry' do
+        subject.should_not be_registered(:cyclops)
+        subject.create_or_update(:cyclops, definition).should be true
+        subject.retrieve(:cyclops).should == definition
+      end
+    end
+
+    context 'existing' do
+      let(:new_definition){ { :universe => 'alternate' } }
+
+      it 'updates the entry' do
+        subject.create(:cyclops, builder)
+        subject.create_or_update(:cyclops, new_definition).should be true
+        subject.retrieve(:cyclops).serialize.should include(new_definition)
+      end
+    end
+  end
+  
+  context '#decorate_with_registry' do
+    let(:graph_builder){ Hanuman::GraphBuilder.receive(label: :beastman) }
+    let(:definition)   { Hanuman::StageBuilder.receive(label: :mystique) }
+    
+    before(:each) do
+      subject.create(:mystique, definition)
+      subject.decorate_with_registry(graph_builder)            
+    end
+
+    it 'decorates a builder with the registry entries as methods' do
+      graph_builder.should respond_to(:mystique)
+    end
+
+    it 'decorates using singleton method definitions' do
+      graph_builder.dup.should_not respond_to(:mystique)
+    end
+    
+    it 'returns an instance of Hanuman::StageBuilder for chaining' do
+      graph_builder.send(:mystique).should be_instance_of(Hanuman::StageBuilder)
+    end
+    
+    it 'adds the instance of Hanuman::StageBuilder to its :stages attribute when used' do
+      graph_builder.stages.should_not include(:mystique)
+      graph_builder.send(:mystique)
+      graph_builder.stages.should include(:mystique)
+    end
+
+    it 'retrieves the Hanuman::StageBuilder from the registry' do
+      Hanuman.registry.should_receive(:retrieve).with(:mystique).and_return(definition)
+      graph_builder.send(:mystique)
+    end
+
+    it 'saves updated definitions in its :stages attribute' do
+      graph_builder.send(:mystique, for_class: String)
+      graph_builder.stages[:mystique].for_class.should == String
+    end
+    
+    it 'allows for relabelling of Hanuman::StageBuilders' do
+      graph_builder.send(:mystique, label: :colossus)
+      graph_builder.stages.should include(:colossus)
+      graph_builder.stages.should_not include(:mystique)
+    end
+  end
+  
+  context '#show' do
+    it 'shows what is currently registered' do
+      subject.show.should be_a(Hash)
+    end
+  end  
+end

data/spec/hanuman/stage_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Hanuman::Stage, :hanuman => true do
+
+  before(:each) do
+    @orig_reg = Hanuman.registry.show
+    Hanuman.registry.clear!
+  end
+
+  after(:each) do
+    Hanuman.registry.clear!
+    Hanuman.registry.merge!(@orig_reg)
+  end
+
+  context 'a class inheriting from Hanuman::Stage' do
+
+    klass = Object.const_set('Gambit', Class.new(Hanuman::Stage))
+    subject{ klass }
+
+    it 'creates its own label' do
+      subject.label.should == :gambit
+    end
+    
+    it 'creates its own builder' do
+      subject.builder.should be_instance_of(Hanuman::StageBuilder)
+      subject.builder.for_class.should == subject
+    end    
+        
+    it 'can register its definition' do      
+      expect{ subject.register }.to change{ Hanuman.registry.retrieve(:gambit) }.from(nil).to(subject.builder)
+    end
+
+    it 'can register itself under a different label' do
+      expect{ subject.register(:wolverine) }.to change{ Hanuman.registry.retrieve(:wolverine) }.from(nil)
+      Hanuman.registry.retrieve(:wolverine).label.should == :wolverine
+      Hanuman.registry.should_not be_registered(:gambit)
+    end
+  end  
+end
+
+describe Hanuman::StageBuilder, :hanuman => true do
+
+  it_behaves_like 'a Stage::Builder'
+  
+  its(:namespace){ should be(Hanuman::Stage) }
+
+  context '#define' do
+    let(:test_klass){ Object.const_set('Jubilee', Class.new(subject.namespace)) }
+    let(:block_arg) { ->(){ def shoot_fireworks!() ; end }                      }
+    after(:each)    { Object.send(:remove_const, 'Jubilee')                     }
+
+    context 'with a block' do
+      it 'defines the class which evaluates the block' do       
+        subject.for_class = test_klass
+        test_klass.should_receive(:class_eval).with(&block_arg)
+        subject.define(&block_arg)
+      end
+    end
+  end
+
+  context '#serialize' do
+    it 'does not serialize its :links attribute' do
+      subject.serialize.should_not include(:links)
+    end
+  end
+
+  context '#into' do
+    subject          { described_class.receive(label: :pyro)   }
+    let(:other_stage){ described_class.receive(label: :iceman) }
+    
+    it 'returns the linked into stage for chaining' do
+      subject.into(other_stage).should be(other_stage)
+    end
+    
+    it 'links two stages together with a simple link' do
+      subject.into(other_stage)
+      subject.links.should be_any{ |link| link.from == :pyro and link.into == :iceman }
+    end
+  end
+  
+end

data/spec/hanuman/tree_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe Hanuman::Tree do
+
+  include_context "graphs"
+
+  it "iterates over each stage in tree-order" do
+    tree.directed_sort.should == [:first, :second, :third_b, :third_a, :fourth]
+  end
+
+  context "#root" do
+    context "when called without arguments" do
+      it "returns the root of the whole tree" do
+        tree.root.should_not be_nil
+        tree.root.label.should == :first
+      end
+      it "returns the root of a sigle stage tree" do
+        single_stage_tree.root.should_not be_nil
+        single_stage_tree.root.label.should == :first
+      end
+      
+    end
+    context "when called with a stage" do
+      it "should return the root of the whole tree" do
+        tree.root(tree.stages[:fourth]).should_not be_nil
+        tree.root(tree.stages[:fourth]).label.should == :first
+      end
+    end
+  end
+
+  context "#ancestor" do
+    it "returns the ancestor of a stage" do
+      tree.ancestor(tree.stages[:fourth]).should_not be_nil
+      tree.ancestor(tree.stages[:fourth]).label.should == :third_a
+    end
+    it "returns nil for the root" do
+      tree.ancestor(tree.root).should be_nil
+    end
+  end
+
+  context "#leaves" do
+    it "returns the leaf stages of a tree" do
+      tree.leaves.map(&:label).should include(:fourth, :third_b)
+    end
+
+    it "returns the root of a tree that has no other leaves" do
+      single_stage_tree.leaves.map(&:label).should include(:first)
+    end
+    
+  end
+
+  context "#prepend" do
+    let(:zeroth) { Hanuman::Stage.receive(label: :zeroth) }
+    it "adds the given stage" do
+      expect { tree.prepend(zeroth) }.to change { tree.stages[:zeroth] }.from(nil).to(zeroth)
+    end
+    it "adds a link from the new stage to the old root" do
+      expect { tree.prepend(zeroth) }.to change { tree.has_link?(zeroth, tree.stages[:first]) }.from(false).to(true)
+    end
+    it "the root becomes the new stage" do
+      expect { tree.prepend(zeroth) }.to change { tree.root.label }.from(:first).to(:zeroth)
+    end
+  end
+
+  context "#append" do
+    let(:fifth) { Hanuman::Stage.receive(label: :fifth) }
+    it "adds a new stage for each leaf" do
+      expect { tree.append(fifth) }.to change { tree.stages.size }.by(2)
+    end
+    it "adds a link for each of the new stages" do
+      expect { tree.append(fifth) }.to change { tree.links.size }.by(2)
+    end
+    it "but doesn't change the number of leaves " do
+      expect { tree.append(fifth) }.to_not change { tree.leaves.size }
+    end
+  end
+  
+  context "#add_link" do
+    context "when adding a new stage" do
+      let(:from) { tree.stages[:fourth]  }
+      let(:into) { Hanuman::Stage.receive(label: :fifth) }
+      it "adds the new stage to the tree" do
+        expect { tree.add_link(:simple, from, into) }.to change { tree.stages[:fifth] }.from(nil).to(into)
+      end
+      it "adds the new link to the tree" do
+        expect { tree.add_link(:simple, from, into) }.to change { tree.links.size }.by(1)
+      end
+    end
+    context "when adding an existing link" do
+      let(:from) { tree.stages[:third_a] }
+      let(:into) { tree.stages[:fourth]  }
+      it "doesn't duplicate the link in the tree" do
+        expect { tree.add_link(:simple, from, into) }.to_not change { tree.links.size }
+      end
+    end
+    context "when adding a link to a stage with an existing parent" do
+      let(:from) { Hanuman::Stage.receive(label: :fifth) }
+      let(:into) { tree.stages[:fourth]                  }
+      it "raises an error" do
+        expect { tree.add_link(:simple, from, into) }.to raise_error(Hanuman::Tree::MultipleRoots)
+      end
+    end
+    context "when making a cycle" do
+      let(:from) { tree.stages[:fourth] }
+      let(:into) { tree.stages[:first]  }
+      it "raises an error" do
+        expect { tree.add_link(:simple, from, into) }.to raise_error(TSort::Cyclic)
+      end
+    end
+    context "when linking a stage to itself" do
+      let(:from) { tree.stages[:fourth] }
+      let(:into) { tree.stages[:fourth]  }
+      it "raises an error" do
+        expect { tree.add_link(:simple, from, into) }.to raise_error(TSort::Cyclic)
+      end
+    end
+  end
+  
+end