wukong 3.0.0.pre → 3.0.0.pre2

data/spec/wukong/dataflow_spec.rb

@@ -1,65 +1,87 @@
 require 'spec_helper'
-require 'wukong'
 
-describe Wukong::Dataflow, :helpers => true do
-  subject{ described_class.new }
-  let(:test_re){  /^f/ }
+describe Wukong::Dataflow do
 
-  context '#select' do
-    it 'given a regexp, evaluates it on each record, selecting if it matches' do
-      result = subject.select(test_re)
-      result.should      be_a(Wukong::Widget::RegexpFilter)
-      result.pattern.should   be(test_re)
-      result.should      be_select("fitzhume")
-      result.should_not  be_select("milbarge")
-    end
+  # 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
 
-    it 'given a proc, evaluates it on each record, selecting if true' do
-      result = subject.select{|rec| rec.odd? }
-      result.should      be_a(Wukong::Widget::ProcFilter)
-      result.should      be_select(3)
-      result.should_not  be_select(2)
-    end
+end
 
-    it 'given a block arg, evaluates the block on each record, selecting if true' do
-      result = subject.select( ->(rec){ rec.odd? } )
-      result.should      be_a(Wukong::Widget::ProcFilter)
-      result.should      be_select(3)
-      result.should_not  be_select(2)
-    end
+# describe Wukong::Chain, :helpers => true do
+#   subject{ described_class.new }
+#   let(:test_re){  /^f/ }
 
-    it 'adds a stage to the dataflow' do
-      subject.should_receive(:add_stage).and_return(mock_val)
-      subject.select(/^h/).should equal(mock_val)
-    end
-  end
+#   context 'examples' do
 
-  context '#reject' do
-    it 'given a regexp, rejects items matching that regexp' do
-      result = subject.reject(test_re)
-      result.should      be_a(Wukong::Widget::RegexpRejecter)
-      result.pattern.should be(test_re)
-      result.should_not  be_select("fitzhume")
-      result.should      be_select("milbarge")
-    end
+#     subject{
+#       test_sink = test_sink()
+#       Wukong.chain(:integers) do
+#         set_source Wukong::Source::Integers.new(:qty => 100)
+#         set_sink   test_sink
 
-    it 'given a proc, evaluates the proc on each record, rejecting if true' do
-      result = subject.reject{|rec| rec.odd? }
-      result.should      be_a(Wukong::Widget::ProcRejecter)
-      result.should_not  be_select(3)
-      result.should      be_select(2)
-    end
+#         input(:default)    >
+#           map{|i| i.to_s } >
+#           re(/..+/)        >
+#           map(&:reverse)   >
+#           limit(20)        >
+#           output(:default)
+#       end
+#       Wukong::LocalRunner.receive(:flow => Wukong.chain(:integers))
+#     }
 
-    it 'given a block arg, evaluates the block on each record, rejecting if true' do
-      result = subject.reject( ->(rec){ rec.odd? } )
-      result.should      be_a(Wukong::Widget::ProcRejecter)
-      result.should_not  be_select(3)
-      result.should      be_select(2)
-    end
+#     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
 
-    it 'adds a stage to the dataflow' do
-      subject.should_receive(:add_stage).and_return(mock_val)
-      subject.select(/^h/).should equal(mock_val)
-    end
-  end
-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/local_runner_spec.rb

@@ -1,31 +1,31 @@
 require 'spec_helper'
-require 'wukong'
-require 'wukong/local_runner'
+# require 'wukong'
+# require 'wukong/local_runner'
 
-describe Wukong::LocalRunner, :examples_spec => true, :helpers => true do
+# describe Wukong::LocalRunner, :examples_spec => true, :helpers => true do
 
-  context 'examples' do
+#   context 'examples' do
 
-    subject{
-      test_sink = test_sink()
-      Wukong.dataflow(:integers) do
-        input   :default, Wukong::Source::Integers.new(:size => 100)
-        output  :default, test_sink
+#     subject{
+#       test_sink = test_sink()
+#       Wukong.dataflow(:integers) do
+#         input   :default, Wukong::Source::Integers.new(:size => 100)
+#         output  :default, test_sink
 
-        input(:default)  >
-          map(&:to_s)    >
-          re(/..+/)      >
-          map(&:reverse) >
-          limit(20)      >
-          output(:default)
-      end
-      Wukong::LocalRunner.receive(:flow => Wukong.dataflow(:integers))
-    }
+#         input(:default)  >
+#           map(&:to_s)    >
+#           re(/..+/)      >
+#           map(&:reverse) >
+#           limit(20)      >
+#           output(:default)
+#       end
+#       Wukong::LocalRunner.receive(:flow => Wukong.dataflow(:integers))
+#     }
 
-    it 'runs' do
-      subject.run(:default)
-      subject.flow.output(:default).records.should == %w[01 11 21 31 41 51 61 71 81 91 02 12 22 32 42 52 62 72 82 92]
-    end
+#     it 'runs' do
+#       subject.run(:default)
+#       subject.flow.output(:default).records.should == %w[01 11 21 31 41 51 61 71 81 91 02 12 22 32 42 52 62 72 82 92]
+#     end
 
-  end
-end
+#   end
+# end

data/spec/wukong/model/faker_spec.rb

@@ -1,131 +1,132 @@
-require 'spec_helper'
-
-describe 'Wukong::Faker', :helpers => true do
-
-  context 'specifies fakers' do
-    subject{ Class.new{ include Gorillib::Model; include Wukong::Faker } }
-
-    it 'using type if no faker given' do
-      subject.field :last_name, String
-      subject.fields[:last_name].type.should_receive(:fake_value)
-      subject.fake_value
-    end
-
-    it 'with proc' do
-      my_proc = ->{ %w[John Paul George Ringo] }
-      subject.field :first_name, String, :faker => my_proc
-      my_proc.should_receive(:call)
-      subject.fake_value
-    end
-
-    it 'with helper name' do
-      subject.field :longitude, String, :faker => :fake_longitude
-      Wukong::Faker::Helpers.should_receive(:fake_longitude)
-      subject.fake_value
-    end
-
-    it 'with explicit faker factory' do
-      subject.field :longitude, String, :faker => Gorillib::Factory::IntegerFactory
-      Gorillib::Factory::IntegerFactory.should_receive(:fake_value)
-      subject.fake_value
-    end
-
-    it 'with explicit method' do
-      subject.define_singleton_method(:fake_orgasm){ 'OHHH YEAHHH' }
-      subject.field :orgasm, String
-      subject.should_receive(:fake_orgasm)
-      subject.fake_value
-    end
-  end
-
-  be_ish_matcher :guid, /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
-
-  be_ish_matcher :fileext,    %r{^[\w\.\-]+$}
-  be_ish_matcher :basename,   %r{^\w+\.\w+$}
-  be_ish_matcher :dirname,    %r{^/(\w+/){1,}\w+$}
-  be_ish_matcher :filename,   %r{^/(\w+/){1,}\w+\.\w+$}
-
-  be_ish_matcher :identifier,  /\A[a-z]\w*\z/
-
-  be_ish_matcher :hostname,    /^(\w+\.)+\w+$/
-  be_ish_matcher :ip_address,  /^(\d+\.){3}\d+$/
-
-  context 'extensions to Gorillib::Factory' do
-    context Gorillib::Factory::StringFactory do
-      its(:fake_value){ should =~ /^\w+$/ }
-    end
-    context(Gorillib::Factory::GuidFactory) do
-      its(:fake_value){ should be_guid_ish }
-    end
-    context(Gorillib::Factory::IpAddressFactory) do
-      its(:fake_value){ should be_ip_address_ish }
-    end
-    context(Gorillib::Factory::HostnameFactory) do
-      its(:fake_value){ should be_hostname_ish }
-    end
-
-    context(Gorillib::Factory::SymbolFactory) do
-      its(:fake_value){ should be_a Symbol }
-      its(:fake_value){ should be_identifier_ish }
-    end
-
-    context(Gorillib::Factory::IntegerFactory) do
-      its(:fake_value){ should be_a Integer }
-      its(:fake_value){ should be < 100 }
-    end
-
-    context(Gorillib::Factory::TimeFactory) do
-      its(:fake_value){ should be_a Time }
-      its(:fake_value){ should be_within(5).of(Time.now) }
-    end
-
-    context(Gorillib::Factory::NilFactory    ){ its(:fake_value){ should equal(nil) } }
-    context(Gorillib::Factory::TrueFactory   ){ its(:fake_value){ should equal(true) } }
-    context(Gorillib::Factory::FalseFactory  ){ its(:fake_value){ should equal(false) } }
-    context(Gorillib::Factory::BooleanFactory){ its(:fake_value){ should be_in([true, false]) } }
-  end
-
-
-  context Wukong::Faker::Helpers do
-    subject{ Wukong::Faker::Helpers }
-
-    its(:fake_integer){ should be_a(Integer) }
-    its(:fake_integer){ should be < 100 }
-    it{ subject.fake_integer(:min => 90, :max => 90).should == 90 }
-    it{ subject.fake_integer(:min => 91, :max => 99).should be_in(91..99) }
-
-    its(:fake_float){ should be_a(Float) }
-    its(:fake_float){ should be < 1.0 }
-    it{ subject.fake_float(:min => 90, :max => 90).should == 90 }
-    it{ subject.fake_float(:min => 91, :max => 99).should be_in(91..99) }
-
-    its(:fake_latitude){       should be_a(Float) }
-    its(:fake_latitude){       should be_in(32 .. 45) }
-    its(:fake_longitude){      should be_a(Float) }
-    its(:fake_longitude){      should be_in(-117 .. -68) }
-
-    its(:fake_country_id){     should be_a(String) }
-
-    its(:fake_area_code){      should be_a(Integer) }
-    its(:fake_area_code){      should be_in( 201 .. 987) }
-
-    its(:fake_identifier){     should be_identifier_ish }
-    its(:fake_sentence){       should =~ /(\S+\s+){1,5}\S+\./ }
-    its(:fake_sentence){       should =~ /(\S+\.)/ }
-
-    its(:fake_fileext ){       should be_a(String) }
-    its(:fake_basename){       should be_a(String) }
-    its(:fake_dirname ){       should be_a(String) }
-    its(:fake_filename){       should be_a(String) }
-    its(:fake_fileext ){       should be_fileext_ish }
-    its(:fake_basename){       should be_basename_ish }
-    its(:fake_dirname ){       should be_dirname_ish }
-    its(:fake_filename){       should be_filename_ish }
-
-    its(:fake_hostname){       should be_hostname_ish }
-    its(:fake_ip_addresss){    should be_ip_address_ish }
-    its(:fake_version_number){ should be_a(String) }
-    its(:fake_version_number){ should =~ /^\d+\.\d+$/ }
-
-  end
-end
+# require 'spec_helper'
+
+# describe 'Wukong::Faker', :helpers => true do
+
+#   context 'specifies fakers' do
+#     subject{ Class.new{ include Gorillib::Model; include Wukong::Faker } }
+
+#     it 'using type if no faker given' do
+#       subject.field :last_name, String
+#       # subject.fields[:last_name].type.should_receive(:fake_value)
+#       Gorillib::Factory(String).should_receive(:fake_value)
+#       subject.fake_value
+#     end
+
+#     it 'with proc' do
+#       my_proc = ->{ %w[John Paul George Ringo] }
+#       subject.field :first_name, String, :faker => my_proc
+#       my_proc.should_receive(:call)
+#       subject.fake_value
+#     end
+
+#     it 'with helper name' do
+#       subject.field :longitude, String, :faker => :fake_longitude
+#       Wukong::Faker::Helpers.should_receive(:fake_longitude)
+#       subject.fake_value
+#     end
+
+#     it 'with explicit faker factory' do
+#       subject.field :longitude, String, :faker => Gorillib::Factory(Integer)
+#       Gorillib::Factory(Integer).should_receive(:fake_value)
+#       subject.fake_value
+#     end
+
+#     it 'with explicit method' do
+#       subject.define_singleton_method(:fake_orgasm){ 'OHHH YEAHHH' }
+#       subject.field :orgasm, String
+#       subject.should_receive(:fake_orgasm)
+#       subject.fake_value
+#     end
+#   end
+
+#   be_ish_matcher :guid, /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+
+#   be_ish_matcher :fileext,    %r{^[\w\.\-]+$}
+#   be_ish_matcher :basename,   %r{^\w+\.\w+$}
+#   be_ish_matcher :dirname,    %r{^/(\w+/){1,}\w+$}
+#   be_ish_matcher :filename,   %r{^/(\w+/){1,}\w+\.\w+$}
+
+#   be_ish_matcher :identifier,  /\A[a-z]\w*\z/
+
+#   be_ish_matcher :hostname,    /^(\w+\.)+\w+$/
+#   be_ish_matcher :ip_address,  /^(\d+\.){3}\d+$/
+
+#   context 'extensions to Gorillib::Factory' do
+#     context Gorillib::Factory(String) do
+#       its(:fake_value){ should =~ /^\w+$/ }
+#     end
+#     context(Gorillib::Factory(Guid)) do
+#       its(:fake_value){ should be_guid_ish }
+#     end
+#     context(Gorillib::Factory(IpAddress)) do
+#       its(:fake_value){ should be_ip_address_ish }
+#     end
+#     context(Gorillib::Factory(Hostname)) do
+#       its(:fake_value){ should be_hostname_ish }
+#     end
+
+#     context(Gorillib::Factory(Symbol)) do
+#       its(:fake_value){ should be_a Symbol }
+#       its(:fake_value){ should be_identifier_ish }
+#     end
+
+#     context(Gorillib::Factory(Integer)) do
+#       its(:fake_value){ should be_a Integer }
+#       its(:fake_value){ should be < 100 }
+#     end
+
+#     context(Gorillib::Factory(Time)) do
+#       its(:fake_value){ should be_a Time }
+#       its(:fake_value){ should be_within(5).of(Time.now) }
+#     end
+
+#     context(Gorillib::Factory(NilClass)    ){ its(:fake_value){ should equal(nil) } }
+#     context(Gorillib::Factory(TrueClass)   ){ its(:fake_value){ should equal(true) } }
+#     context(Gorillib::Factory(FalseClass)  ){ its(:fake_value){ should equal(false) } }
+#     context(Gorillib::Factory(:boolean)    ){ its(:fake_value){ should be_in([true, false]) } }
+
+#   end
+
+#   context Wukong::Faker::Helpers do
+#     subject{ Wukong::Faker::Helpers }
+
+#     its(:fake_integer){ should be_a(Integer) }
+#     its(:fake_integer){ should be < 100 }
+#     it{ subject.fake_integer(:min => 90, :max => 90).should == 90 }
+#     it{ subject.fake_integer(:min => 91, :max => 99).should be_in(91..99) }
+
+#     its(:fake_float){ should be_a(Float) }
+#     its(:fake_float){ should be < 1.0 }
+#     it{ subject.fake_float(:min => 90, :max => 90).should == 90 }
+#     it{ subject.fake_float(:min => 91, :max => 99).should be_in(91..99) }
+
+#     its(:fake_latitude){       should be_a(Float) }
+#     its(:fake_latitude){       should be_in(32 .. 45) }
+#     its(:fake_longitude){      should be_a(Float) }
+#     its(:fake_longitude){      should be_in(-117 .. -68) }
+
+#     its(:fake_country_id){     should be_a(String) }
+
+#     its(:fake_area_code){      should be_a(Integer) }
+#     its(:fake_area_code){      should be_in( 201 .. 987) }
+
+#     its(:fake_identifier){     should be_identifier_ish }
+#     its(:fake_sentence){       should =~ /(\S+\s+){1,5}\S+\./ }
+#     its(:fake_sentence){       should =~ /(\S+\.)/ }
+
+#     its(:fake_fileext ){       should be_a(String) }
+#     its(:fake_basename){       should be_a(String) }
+#     its(:fake_dirname ){       should be_a(String) }
+#     its(:fake_filename){       should be_a(String) }
+#     its(:fake_fileext ){       should be_fileext_ish }
+#     its(:fake_basename){       should be_basename_ish }
+#     its(:fake_dirname ){       should be_dirname_ish }
+#     its(:fake_filename){       should be_filename_ish }
+
+#     its(:fake_hostname){       should be_hostname_ish }
+#     its(:fake_ip_addresss){    should be_ip_address_ish }
+#     its(:fake_version_number){ should be_a(String) }
+#     its(:fake_version_number){ should =~ /^\d+\.\d+$/ }
+#   end
+
+# end