ul-wukong 4.1.0

data/spec/support/shared_context_for_reducers.rb

@@ -0,0 +1,37 @@
+shared_context "reducers" do
+
+  let(:strings) { %w[apple banana apple cookie] }
+  let(:nums)    { %w[7 7 0 10 3 5 7 6 3 7 3 5 3 1 9 8 3 9 4 2 6 10 9 0 7 7 9 5 2 0 4 9 9 5 9 6 10 2 0 8 4 0 0 1 7 9 5 6 3 0] }
+  let(:json)    do
+    [
+     '{"data":{}}',
+     '{"data":{"n":1,"inner":"snap"},"outer":"apple"}',
+     '{"data":{"n":100,"inner":"crackle"},"outer":"banana"}',
+     '{"data":{"n":5,"inner":"crackle"},"outer":"apple"}',
+     '{"data":{"n":10,"inner":"pop"},"outer":"cookie"}',
+     '{"data":{}}'
+     ]
+  end
+
+  let(:json_sorted_n) do
+    json.map { |j| MultiJson.load(j) }.sort_by { |o| o['data']['n'].to_i }.map { |o| MultiJson.dump(o) }
+  end
+
+  let(:json_sorted_outer) do
+    json.map { |j| MultiJson.load(j) }.sort_by { |o| o['outer'] || '' }.map { |o| MultiJson.dump(o) }
+  end
+  
+  let(:tsv) do
+    [
+     "\tb\t",
+     "apple\tsnap\t1",
+     "banana\tcrackle\t100",
+     "apple\tcrackle\t5",
+     "cookie\tpop\t10",
+     "b"
+     ]
+  end
+
+  let(:tsv_sorted) { tsv.sort_by { |t| t.split("\t")[2].to_i } }
+
+end

data/spec/support/shared_examples_for_builders.rb

@@ -0,0 +1,94 @@
+shared_examples_for 'a Stage::Builder' do
+  before(:each) do
+    @registry = Hanuman::GlobalRegistry.show
+    Hanuman::GlobalRegistry.clear!
+  end
+  
+  after(:each) do
+    Hanuman::GlobalRegistry.merge! @registry
+  end
+  
+  context '.receive' do
+    it 'extra arguments are stored in the :args attribute' do
+      subject = described_class.receive(uncanny: 'x-men')
+      subject.args.should == { uncanny: 'x-men' }
+    end
+  end
+  
+  context '#define' do
+    let(:test_klass){ Object.const_get('WhiteQueen') }
+    
+    around(:each) do |example|
+      Object.const_set('WhiteQueen', Class.new(subject.namespace))
+      example.run
+      Object.send(:remove_const, 'WhiteQueen')
+    end
+
+    it 'returns a Hanuman::Stage class definition' do
+      subject.label = :white_queen
+      subject.define.superclass.should be(subject.namespace)
+    end
+
+    it 'registers the defined class' do
+      subject.for_class = test_klass
+      test_klass.should_receive(:register)
+      subject.define
+    end
+    
+    context 'without :for_class attribute set' do
+      it 'does not create a class definition' do
+        subject.for_class = test_klass
+        subject.should_not_receive(:define_class)
+        subject.define
+      end
+    end
+
+    context 'with :for_class attribute set' do
+      it 'creates a class definition' do
+        subject.label = :white_queen
+        subject.should_receive(:define_class).with(:white_queen).and_return(test_klass)
+        subject.define
+      end
+    end    
+  end
+  
+  context '#define_class' do
+    around(:each) do |example| 
+      subject.namespace.const_set('ProfessorX', Class.new(subject.namespace)) 
+      example.run
+      subject.namespace.send(:remove_const, 'ProfessorX') 
+    end
+    
+    context 'already defined within the namespace' do
+      it 'does not define the class again' do
+        subject.namespace.should_not_receive(:const_set)
+        subject.define_class(:professor_x)
+      end
+    end
+    
+    context 'not defined within the namespace' do
+      let(:defined_class){ double :magneto, :set_builder => true }
+      
+      it 'defines the class' do
+        subject.namespace.should_receive(:const_set).with('Magneto', an_instance_of(Class)).and_return(defined_class)
+        subject.define_class(:magneto)
+      end
+    end
+    
+    context 'builder attribute' do
+      let(:test_klass) { subject.namespace.const_get('ProfessorX') }
+      
+      it 'sets the defined class builder attribute' do
+        test_klass.should_receive(:set_builder).with(subject)
+        subject.define_class(:professor_x)
+      end
+    end
+  end
+  
+  context '#serialize' do
+    it 'serializes into a hash' do
+      subject.serialize.should     include(:label) 
+      subject.serialize.should_not include(:args, :for_class)
+    end
+  end
+end

data/spec/support/shared_examples_for_shortcuts.rb

@@ -0,0 +1,57 @@
+shared_examples_for Hanuman::Shortcuts do
+
+  before(:each) do
+    @orig_reg = subject.registry.show
+    subject.registry.clear!
+  end
+   
+  after(:each)  do
+    subject.registry.clear!
+    subject.registry.merge!(@orig_reg)
+  end
+  
+  context '.registry' do
+    it 'returns the registry'  do
+      subject.registry.should == Hanuman::GlobalRegistry
+    end
+  end
+  
+  context '.add_shortcut_method_for' do
+    let(:shortcut){ :banshee }
+    it 'add shortcut methods for creating builders' do
+      expect{ subject.add_shortcut_method_for(shortcut, Hanuman::StageBuilder) }.to change{ subject.respond_to? shortcut }.from(false).to(true)
+    end
+  end
+
+  context '.builder_shortcut' do
+    context 'with an existing definition' do
+      let(:existing_definition){ Hanuman::StageBuilder.receive(label: :sunfire) }
+
+      it 'returns the existing definition from the registry' do
+        subject.registry.create(:sunfire, existing_definition)
+        subject.registry.should_receive(:retrieve).with(:sunfire).and_return(existing_definition)
+        subject.builder_shortcut(Hanuman::StageBuilder, :sunfire)         
+      end
+    end
+    
+    context 'with a nonexisting definition' do
+      let(:mock_builder_type){ double :builder_type }
+      let(:mock_builder)     { double :builder      }
+      let(:block_arg)        { ->(){ def absorb() 'radiation' ; end } }
+
+      it 'creates a new definition using the supplied builder_type' do
+        mock_builder_type.should_receive(:receive).with(label: :sunfire).and_return mock_builder
+        mock_builder.should_receive(:define).with(&block_arg)
+        subject.builder_shortcut(mock_builder_type, :sunfire, &block_arg)
+      end
+    end
+
+    context 'graph builder decoration' do
+      it 'decorates the builder with registry methods if the builder is a GraphBuilder' do
+        Hanuman::GlobalRegistry.should_receive(:decorate_with_registry).with an_instance_of(Hanuman::GraphBuilder)
+        subject.builder_shortcut(Hanuman::GraphBuilder, :sunfire)
+      end
+    end
+  end
+  
+end

data/spec/wu/model/reconcilable_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+require 'gorillib/model'
+require 'wu/model/reconcilable'
+require 'support/model_test_helpers'
+
+describe Gorillib::Model::Reconcilable, :model_spec do
+
+  before do
+    smurfhouse_class.class_eval do
+      include Gorillib::Model::Reconcilable
+    end
+    smurf_class.class_eval do
+      include Gorillib::Model::Reconcilable
+      field :cromulence, Integer
+      field :smurfhouse, Gorillib::Test::Smurfhouse
+    end
+  end
+  let(:empty_smurf){ smurf_class.new(name: nil) }
+  let(:angry_smurf){ smurf_class.new(name: 'Angry Smurf', smurfiness: 20, weapon: :smurfchucks) }
+  let(:handy_smurf){ smurf_class.new(name: 'Handy Smurf', smurfiness: 20, weapon: :monkeysmurf) }
+  subject{           smurf_class.new(name: 'Handy Smurf', smurfiness: 20, weapon: :monkeysmurf) }
+
+  context '#reconcilable_attributes' do
+    it 'returns only unset, non-nil values' do
+      subject.weapon = nil
+      subject.reconcilable_attributes.should == { name: 'Handy Smurf', smurfiness: 20 }
+      subject.compact_attributes.should      == { name: 'Handy Smurf', smurfiness: 20, weapon: nil }
+      empty_smurf.reconcilable_attributes.should == {}
+    end
+  end
+
+  context '#conflicting_attribute!' do
+    it 'warns by default' do
+      stdout, stderr = capture_output{ subject.conflicting_attribute!(:weapon, :monkeysmurf, :smurfwrench) }
+      stderr.string.should =~ /conflicting.* weapon: had :monkeysmurf got :smurfwrench\b/
+    end
+    it 'returns false always by default' do
+      subject.stub(:warn)
+      subject.conflicting_attribute!(:weapon, :monkeysmurf, :smurfwrench).should == false
+    end
+  end
+
+  context '#adopt' do
+    it 'returns true on compatible, false on incompatible' do
+      subject.stub(:warn)
+      subject.adopt(empty_smurf).should be_true
+      subject.adopt(angry_smurf).should be_false
+    end
+
+    it 'calls adopt_foo instead of adopt_attribute(:foo, ...) if present' do
+      subject.should_receive(:adopt_weapon).with(:smurfchucks,  angry_smurf).and_return true
+      subject.should_receive(:adopt_name  ).with('Angry Smurf', angry_smurf).and_return true
+      subject.adopt(angry_smurf).should be_true
+    end
+
+    context 'on compatible objects' do
+      before{ subject.should_not_receive(:conflicting_attribute!) }
+      it 'makes no changes from unset or nil values' do
+        subject.adopt(empty_smurf).should be_true
+        subject.should == handy_smurf
+      end
+      it 'makes no changes from equal values' do
+        subject.adopt(handy_smurf).should be_true
+        subject.should == handy_smurf
+      end
+      it 'sets unset attributes to the other value' do
+        handy_smurf.cromulence = 99
+        subject.attribute_set?(:cromulence).should be_false
+        subject.adopt(handy_smurf).should be_true
+        subject.should == handy_smurf
+        subject.cromulence.should == 99
+      end
+      it 'sets nil attributes to the other value' do
+        handy_smurf.cromulence = 99
+        subject.cromulence = nil
+        subject.attribute_set?(:cromulence).should be_true
+        subject.adopt(handy_smurf).should be_true
+        subject.should == handy_smurf
+        subject.cromulence.should == 99
+      end
+      it 'asks adoptable attribute to adopt other value' do
+        handy_smurf.smurfhouse  = smurfhouse_class.new(color: :brown)
+        sh = subject.smurfhouse = smurfhouse_class.new(shape: :mushroom)
+        subject.adopt(handy_smurf).should be_true
+        subject.smurfhouse.attributes.should == { shape: :mushroom, color: :brown }
+        subject.smurfhouse.should equal(sh)
+      end
+      it 'does not call block' do
+        subject.adopt(empty_smurf){ raise 'should not call block' }
+      end
+    end
+
+    context 'on incompatible objects' do
+      it 'returns the value of conflicting_attribute!' do
+        subject.weapon = :smurfwrench
+        subject.should_receive(:conflicting_attribute!).with(:weapon, :smurfwrench, :monkeysmurf).and_return(false)
+        subject.adopt(handy_smurf).should be_false
+      end
+      it 'returns the value of conflicting_attribute!' do
+        subject.weapon = :smurfwrench
+        subject.should_receive(:conflicting_attribute!).with(:weapon, :smurfwrench, :monkeysmurf).and_return(true)
+        subject.adopt(handy_smurf).should be_true
+      end
+      it 'keeps its own value' do
+        subject.stub(:conflicting_attribute!)
+        subject.weapon = :smurfwrench
+        subject.adopt(handy_smurf)
+        subject.weapon.should == :smurfwrench
+      end
+      it 'adoptible attributes reconcile' do
+        handy_smurf.smurfhouse  = smurfhouse_class.new(color: :brown)
+        sh = subject.smurfhouse = smurfhouse_class.new(shape: :mushroom, color: :red)
+        sh.should_receive(:conflicting_attribute!).with(:color, :red, :brown)
+        #
+        subject.adopt(handy_smurf).should be_false
+        subject.smurfhouse.attributes.should == { shape: :mushroom, color: :red }
+        subject.smurfhouse.should equal(sh)
+      end
+      it 'adoptible attributes reconcile and warn' do
+        subject.should_not_receive(:conflicting_attribute!)
+        handy_smurf.smurfhouse  = smurfhouse_class.new(color: :brown)
+        sh = subject.smurfhouse = smurfhouse_class.new(shape: :mushroom, color: :red)
+        sh.should_receive(:conflicting_attribute!).with(:color, :red, :brown)
+        #
+        subject.adopt(handy_smurf)
+      end
+      it 'does not take a block' do
+        subject.stub(:warn)
+        subject.adopt(angry_smurf){ raise 'should not call block' }
+      end
+    end
+  end
+
+  context '#adopt_attribute' do
+    context 'takse a block (useful in overrides):' do
+      it 'on compatible values, block is not called' do
+        subject.should_not_receive(:conflicting_attribute!)
+        subject.send(:adopt_attribute, :weapon, :monkeysmurf) do
+          raise 'should not call block'
+        end
+      end
+      it 'on incompatible values, block is called instead of conflicting_attribute!' do
+        subject.should_not_receive(:conflicting_attribute!)
+        subject.send(:adopt_attribute, :weapon, :smurfwrench) do
+          mock_val
+        end.should == mock_val
+      end
+    end
+  end
+
+
+end

data/spec/wukong/dataflow_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Wukong::Dataflow do
+
+  # context '#handle_dsl_methods_for' do
+  #   let(:block_arg){ ->(rec){ transform_into('kitty pryde') } } 
+  #   it 'accepts a block and assigns it to an :action key' do
+  #     graph_builder.send(:mystique, &block_arg)      
+  #     graph_builder.stages[:mystique].serialize.should include(action: block_arg)
+  #   end
+  # end
+
+end
+
+# describe Wukong::Chain, :helpers => true do
+#   subject{ described_class.new }
+#   let(:test_re){  /^f/ }
+
+#   context 'examples' do
+
+#     subject{
+#       test_sink = test_sink()
+#       Wukong.chain(:integers) do
+#         set_source Wukong::Source::Integers.new(:qty => 100)
+#         set_sink   test_sink
+
+#         input(:default)    >
+#           map{|i| i.to_s } >
+#           re(/..+/)        >
+#           map(&:reverse)   >
+#           limit(20)        >
+#           output(:default)
+#       end
+#       Wukong::LocalRunner.receive(:flow => Wukong.chain(:integers))
+#     }
+
+#     it 'runs' do
+#       subject.run(:default)
+#       subject.flow.output(:default).records.should == ["01", "11", "21", "31", "41", "51", "61", "71", "81", "91", "02", "12", "22", "32", "42", "52", "62", "72", "82", "92"]
+#     end
+
+#   end
+
+#   context '#select' do
+#     it 'evaluates block arg on each record, selecting if true' do
+#       result = subject.select{|rec| rec.odd? }
+#       result.should      be_a(Wukong::Widget::Select)
+#       result.should      be_select(3)
+#       result.should_not  be_select(2)
+#     end
+
+#     it 'given proc as plain arg, evaluates it on each record, selecting if true' do
+#       result = subject.select( ->(rec){ rec.odd? } )
+#       result.should      be_a(Wukong::Widget::Select)
+#       result.should      be_select(3)
+#       result.should_not  be_select(2)
+#     end
+
+#     it 'adds a stage to the dataflow' do
+#       p subject.stages
+#       subject.stages.should_receive(:receive_item).with(:select_1, kind_of(Wukong::Widget::Select))
+#       subject.select{|rec| rec =~ /^h/ }.should be_a(Wukong::Widget::Select)
+#       p subject.stages
+#     end
+#   end
+
+#   context '#reject' do
+#     it 'evaluates block arg on each record, rejecting if true' do
+#       result = subject.reject{|rec| rec.odd? }
+#       result.should      be_a(Wukong::Widget::Reject)
+#       result.should_not  be_select(3)
+#       result.should      be_select(2)
+#     end
+
+#     it 'given proc as plain arg, evaluates it on each record, rejecting if true' do
+#       result = subject.reject( ->(rec){ rec.odd? } )
+#       result.should      be_a(Wukong::Widget::Reject)
+#       result.should_not  be_select(3)
+#       result.should      be_select(2)
+#     end
+
+#     it 'adds a stage to the dataflow' do
+#       subject.should_receive(:receive_item).with(:reject_0, kind_of(Wukong::Widget::Reject))
+#       subject.reject{|rec| rec =~ /^h/ }.should be_a(Wukong::Widget::Reject)
+#     end
+#   end
+# end

data/spec/wukong/driver_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe Wukong::DriverMethods do
+  
+  describe "#construct_dataflow" do
+    
+    context "given a label registered to a processor" do
+      let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/) }
+      
+      context "constructs an anonymous dataflow" do
+        let(:dataflow) { driver.dataflow }
+        subject        { dataflow }
+        
+        it          { should_not be_nil   }
+        its(:label) { should     be_nil   }
+        its(:links) { should     be_empty }
+        
+        context "with a single stage" do
+          let(:stage) { dataflow.stages.values.first }
+          subject     { stage }
+
+          it          { should_not be_nil }
+          its(:label) { should == :regexp }
+          its(:match) { should == /hi/    }
+        end
+      end
+    end
+
+    context "given a serialization argument" do
+      context "that does not match a registered serializer" do
+        it "raises an error" do
+          expect { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/, to: 'fake') }.to raise_error(Wukong::Error)
+        end
+      end
+      context "that matches a registered serializer" do
+        let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/, to: 'json') }
+        let(:dataflow) { driver.dataflow }
+        it "appends the serializer to each of the leaves" do
+          dataflow.leaves.size.should == 1
+          dataflow.leaves.map(&:label).should_not include(:regexp)
+        end
+      end
+    end
+    
+    context "given a deserialization argument" do
+      let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/, from: 'json') }
+      let(:dataflow) { driver.dataflow }
+
+      context "adds a deserializer" do
+        subject { dataflow.stages[:from_json] }
+        it      { should_not be_nil   }
+        it "which is the root of the dataflow" do
+          dataflow.root.should == subject
+        end
+        it "which is linked to the original root" do
+          dataflow.ancestors(dataflow.stages[:regexp]).should include(subject)
+        end
+      end
+    end
+
+    context "given a recordization argument" do
+      let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/, as: Time) }
+      let(:dataflow) { driver.dataflow }
+      
+      context "adds a recordizer" do
+        subject { dataflow.stages[:recordize] }
+        it      { should_not be_nil   }
+        it "which is the root of the dataflow" do
+          dataflow.root.should == subject
+        end
+        it "which is linked to the original root" do
+          dataflow.ancestors(dataflow.stages[:regexp]).should include(subject)
+        end
+      end
+    end
+
+    context "given deserialization and recordization arguments" do
+      let(:driver)       { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/, from: 'json', as: Time) }
+      let(:dataflow)     { driver.dataflow }
+      let(:recordizer)   { dataflow.stages[:recordize] }
+      let(:deserializer) { dataflow.stages[:from_json] }
+
+      context "adds a deserializer" do
+        subject { deserializer      }
+        it      { should_not be_nil }
+        it "which is the root of the dataflow" do
+          dataflow.root.should == subject
+        end
+        it "which is linked to the recordizer" do
+          dataflow.ancestors(dataflow.stages[:recordizer]).should include(subject)
+        end
+      end
+      
+      context "adds a recordizer" do
+        subject { recordizer        }
+        it      { should_not be_nil }
+        it "which is linked to the original root" do
+          dataflow.ancestors(dataflow.stages[:regexp]).should include(subject)
+        end
+      end
+      
+    end
+  end
+
+  describe "#setup_dataflow" do
+    let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/) }
+    
+    it "calls the driver's #setup method" do
+      driver.should_receive(:setup)
+      driver.setup_dataflow
+    end
+
+    it "calls setup on each stage of the dataflow" do
+      driver.dataflow.each_stage do |stage|
+        stage.should_receive(:setup)
+      end
+      driver.setup_dataflow
+    end
+  end
+
+  describe "#finalize_dataflow" do
+    let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/) }
+    it "calls the driver's #finalize method" do
+      driver.should_receive(:finalize)
+      driver.finalize_dataflow
+    end
+
+    it "calls finalize on each stage of the dataflow" do
+      driver.dataflow.each_stage do |stage|
+        stage.should_receive(:finalize)
+      end
+      driver.finalize_dataflow
+    end
+  end
+
+  describe "#finalize_and_stop_dataflow" do
+    let(:driver)   { Wukong::SpecHelpers::UnitTestDriver.new(:regexp, match: /hi/) }
+    it "calls the driver's #finalize and #stop methods" do
+      driver.should_receive(:finalize)
+      driver.should_receive(:stop)
+      driver.finalize_and_stop_dataflow
+    end
+
+    it "calls finalize and stop on each stage of the dataflow" do
+      driver.dataflow.each_stage do |stage|
+        stage.should_receive(:finalize)
+        stage.should_receive(:stop)
+      end
+      driver.finalize_and_stop_dataflow
+    end
+    
+  end
+  
+end