wukong 3.0.0.pre → 3.0.0.pre2

data/spec/hanuman/stage_spec.rb

@@ -1,12 +1,66 @@
 require 'spec_helper'
-require 'hanuman'
 
-describe :stages, :slot_specs => true, :helpers => true do
+describe Hanuman::Stage, :hanuman => true do
 
-  describe Hanuman::Stage do
-    it{ should respond_to(:setup)  }
-    it{ should respond_to(:stop)   }
-    it{ should respond_to(:notify) }
-    it{ should respond_to(:report) }
+  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
 end

data/spec/spec_helper.rb

@@ -1,29 +1,39 @@
-require 'bundler' ; Bundler.require(:default, :development)
+require 'bundler' ; Bundler.setup(:default, :development, :test)
 
-SimpleCov.start do
-  add_filter '/gorillib/'
-  add_filter '/away/'
-  add_group  'Hanuman', '/hanuman/'
+if ENV['WUKONG_COV']
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter '/gorillib/'
+    add_filter '/away/'
+    add_group  'Hanuman', '/hanuman/'
+  end
 end
 
 require 'wukong'
-require 'gorillib/model'
-require 'gorillib/pathname'
-require 'gorillib/type/extended'
-require 'wukong/model/faker'
+require 'wukong/spec_helpers'
+require_relative './support/shared_examples_for_builders'
+require_relative './support/shared_examples_for_shortcuts'
+require_relative './support/shared_context_for_reducers'
+
+# require 'gorillib/pathname'
+# require 'gorillib/type/extended'
+# require 'wukong/model/faker'
 
-Pathname.register_path(:wukong_root, File.expand_path('..', File.dirname(__FILE__)))
-Pathname.register_path(:examples,    :wukong_root, 'examples')
-Pathname.register_path(:tmp,         :wukong_root, 'tmp')
-Pathname.register_path(:data,        :wukong_root, 'data')
-Pathname.path_to(:tmp).mkpath
+# Pathname.register_path(:wukong_root, File.expand_path('..', File.dirname(__FILE__)))
+# Pathname.register_path(:examples,    :wukong_root, 'examples')
+# Pathname.register_path(:tmp,         :wukong_root, 'tmp')
+# Pathname.register_path(:data,        :wukong_root, 'data')
+# Pathname.path_to(:tmp).mkpath
 
-Dir[ Pathname.path_to('spec', 'support', '*.rb') ].each{ |f| require f }
+# Dir[ Pathname.path_to('spec', 'support', '*.rb') ].each{|f| require f }
 
-result   = `dot -V 2>&1` rescue nil
-GRAPHVIZ = ($?.exitstatus == 0) && (result =~ /dot - graphviz version/)
-puts 'Some specs require graphviz to run -- brew/apt install graphviz, it is pretty awesome' unless GRAPHVIZ
+# result   = `dot -V 2>&1` rescue nil
+# GRAPHVIZ = ($?.exitstatus == 0) && (result =~ /dot - graphviz version/)
+# puts 'Some specs require graphviz to run -- brew/apt install graphviz, it is pretty awesome' unless GRAPHVIZ
 
 RSpec.configure do |config|
-  include WukongTestHelpers
+  config.mock_with :rspec
+  include Wukong::SpecHelpers
+  # config.treat_symbols_as_metadata_keys_with_true_values = true
 end

data/spec/support/hanuman_test_helpers.rb

@@ -5,7 +5,7 @@ shared_context 'hanuman', :helpers => true do
 
   let :example_graph do
     Hanuman::Graph.new(:name => :scraper) do
-      action(:listener) << resource(:scrape_requests) << resource(:more_requests)
+      action(:listener) << product(:scrape_requests) << product(:more_requests)
       action(:parser).input(:listener)
       action(:models).input(:parser)
     end
@@ -16,7 +16,7 @@ end
 shared_examples_for 'it can be linked into' do
   let(:mock_slot){ mock('mock slot') }
   before do
-    mock_dataflow.stub(:connect).with(mock_slot, subject).and_return([mock_slot, subject])
+    mock_dataflow.stub(:connect).with(mock_slot, :default, subject, :default).and_return([mock_slot, subject])
     subject.write_attribute(:owner, mock_dataflow)
   end
 
@@ -32,7 +32,7 @@ shared_examples_for 'it can be linked into' do
 
   context '#from' do
     it 'asks its owner to register an edge from self into given stage' do
-      mock_dataflow.should_receive(:connect).with(mock_slot, subject)
+      mock_dataflow.should_receive(:connect).with(mock_slot, :default, subject, :default)
       subject.from mock_slot
     end
     it 'returns the stage itself, for chaining' do
@@ -40,13 +40,15 @@ shared_examples_for 'it can be linked into' do
     end
   end
 
-  context 'set_output' do
-    it 'returns the actual receivoutg slot' do
-      subject.set_output(mock_stage).should equal(subject)
+  context 'set_sink' do
+    it 'returns the actual receiving slot' do
+      # subject.set_sink(:default, mock_stage).should equal(subject)
+      subject.set_sink(mock_stage).should equal(subject)
     end
     it 'sets the output attribute' do
       subject.should_receive(:write_attribute).with(:output, mock_stage)
-      subject.set_output(mock_stage)
+      # subject.set_sink(:default, mock_stage)
+      subject.set_sink(mock_stage)
     end
   end
 end
@@ -54,13 +56,13 @@ end
 shared_examples_for 'it can be linked from' do
   let(:mock_slot){ mock('mock slot') }
   before do
-    mock_dataflow.stub(:connect).with(subject, mock_slot).and_return([subject, mock_slot])
+    mock_dataflow.stub(:connect).with(subject, :default, mock_slot, :default).and_return([subject, mock_slot])
     subject.write_attribute(:owner, mock_dataflow)
   end
 
   context '#>' do
     it 'asks its owner to register an edge into self from given stage' do
-      mock_dataflow.should_receive(:connect).with(subject, mock_slot)
+      mock_dataflow.should_receive(:connect).with(subject, :default, mock_slot, :default)
       subject.into mock_slot
     end
     it 'returns the output stage' do
@@ -70,7 +72,7 @@ shared_examples_for 'it can be linked from' do
 
   context '#into' do
     it 'asks its owner to register an edge into self from given stage' do
-      mock_dataflow.should_receive(:connect).with(subject, mock_slot)
+      mock_dataflow.should_receive(:connect).with(subject, :default, mock_slot, :default)
       subject.into mock_slot
     end
     it 'returns the stage itself, for chaining' do
@@ -80,11 +82,11 @@ shared_examples_for 'it can be linked from' do
 
   context 'set_input' do
     it 'returns the actual receiving slot' do
-      subject.set_input(mock_stage).should equal(subject)
+      subject.set_source(mock_stage).should equal(subject)
     end
     it 'sets the input attribute' do
       subject.should_receive(:write_attribute).with(:input, mock_stage)
-      subject.set_input(mock_stage)
+      subject.set_source(mock_stage)
     end
   end
 end

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,101 @@
+shared_examples_for 'a Stage::Builder' do
+  before(:each){ Hanuman::GlobalRegistry.clear! }
+  
+  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
+
+  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/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/support/wukong_test_helpers.rb

@@ -8,17 +8,17 @@ shared_context 'wukong', :helpers => true do
     RSpec::Matchers.define("be_#{handle}_ish"){ match{|actual| actual.should =~ regexp } }
   end
 
-  let(:mock_val   ){ mock('mock val') }
-  let(:mock_record){ mock('mock record') }
-  let(:mock_stage    ){ m = mock('mock stage') ; m }
-  let(:mock_processor){ m = mock ; m.stub(:name => 'mock processor', :attributes => { :a => :b }) ; m }
-
-  let(:test_source){          Wukong::Integers.new(:name => :integers, :size => 100) }
-  let(:test_sink){            Wukong::Sink::ArraySink.new(:name => :test_sink) }
-  let(:test_processor_class){ Wukong::AsIs }
-  let(:test_processor){       test_processor_class.new }
-  let(:test_filter){          Wukong::Widget::RegexpFilter.new(:re => /^m/) }
-  let(:test_dataflow){        Wukong.dataflow(:test_dataflow) }
+  let(:mock_val)      { mock('mock val')       }
+  let(:mock_record)   { mock('mock record')    }
+  let(:mock_stage)    { mock('mock stage')     }
+  let(:mock_processor){ mock('mock processor') }
+
+  let(:test_source)         { Wukong::Integers.new(:name => :integers, :qty => 100) }
+  let(:test_sink)           { Wukong::Sink::ArraySink.new(:name => :test_sink)      }
+  let(:test_processor_class){ Wukong::AsIs                                          }
+  let(:test_processor)      { test_processor_class.new                              }
+  let(:test_filter)         { Wukong::Widget::RegexpFilter.new(:re => /^m/)         }
+  let(:test_dataflow)       { Wukong.dataflow(:test_dataflow)                       }
 end
 
 
@@ -41,3 +41,29 @@ module WukongTestHelpers
   end
 
 end
+
+RSpec::Core::DSL.module_eval do
+  def describe_example_script(example_name, source_file, attrs={}, &block)
+    return unless attrs[:only]
+    load Pathname.path_to(:examples, source_file)
+    describe "Example: #{example_name}", attrs.merge(:examples_spec => true, :helpers => true) do
+      let(:example_name){ example_name }
+      instance_eval(&block)
+    end
+  rescue StandardError => err
+    warn "Broken example #{example_name} with script #{source_file} (#{attrs})"
+    warn err
+    warn err.backtrace.join("\n")
+  end
+
+  def it_generates_graphviz
+    it 'generates a graphviz picture', :if => GRAPHVIZ do
+      require 'hanuman/graphvizzer/gv_presenter'
+      #
+      basename = Pathname.path_to(:tmp, example_name.to_s)
+      Wukong.to_graphviz.save(basename, 'png')
+      yield "#{basename}.dot" if block_given?
+    end
+  end
+
+end