wukong 3.0.0.pre2 → 3.0.0.pre3

data/lib/wukong/widget/serializers.rb

@@ -1,8 +1,18 @@
 module Wukong
   class Processor
 
-    # An empty parent class for all Serializers to subclass.
+    SerializerError = Class.new(StandardError)
+
     class Serializer < Processor
+      field :on_error, String, default: 'log'
+
+      def handle_error(record, err)
+        case on_error
+        when 'log'    then log.warn "Bad record: #{record}"
+        when 'notify' then notify('error', record: record, error: err)
+        end          
+      end
+
     end
 
     # A widget for serializing inputs to JSON.
@@ -15,19 +25,23 @@ module Wukong
     #
     # @see FromJson
     class ToJson < Serializer
+      field :pretty, :boolean, default: false
+
       # Yields the input `record` serialized as JSON.
       #
       # @param [Object] record
       # @yield [json] the serialized json output
       # @yieldparam [String] json
       def process(record)
-        begin
-          json = ::MultiJson.dump(record)
-        rescue => e
-          # FIXME -- should we log here or what?
-          return
+        raise SerializerError.new("Cannot serialize: <nil>") if record.nil?
+        if record.respond_to?(:to_json) && !record.is_a?(Hash) # We only want to invoke to_json if it has been explicitly defined
+          json = record.to_json(pretty: pretty)
+        else
+          json = MultiJson.dump(record.try(:to_wire) || record, pretty: pretty)
         end
         yield json
+      rescue => e
+        handle_error(record, e)
       end
       register
     end
@@ -47,14 +61,15 @@ module Wukong
       # @param [String] json
       # @yield [obj] the deserialized object
       # @yieldparam [Object] obj
-      def process(json)
-        begin
-          obj = ::MultiJson.load(json)
-        rescue => e
-          # FIXME -- should we log here or what?
-          return
+      def process(record)
+        if record.respond_to?(:from_json)
+          obj = record.from_json
+        else
+          obj = MultiJson.load(record)
         end
         yield obj
+      rescue => e
+        handle_error(record, e)       
       end
       register
     end
@@ -75,13 +90,16 @@ module Wukong
       # @yield [tsv] the serialized TSV output
       # @yieldparam [String] tsv
       def process(record)
-        begin
-          tsv = record.map(&:to_s).join("\t")
-        rescue => e
-          # FIXME -- should we log here or what?
-          return
+        if record.respond_to?(:to_tsv)
+          tsv = record.to_tsv
+        else         
+          wire_format = record.try(:to_wire) || record
+          raise SerializerError.new("Record must be in Array format to be serialized as TSV") unless wire_format.respond_to?(:map)
+          tsv = wire_format.map(&:to_s).join("\t")
         end
         yield tsv
+      rescue => e
+        handle_error(record, e)
       end
       register
     end
@@ -101,14 +119,15 @@ module Wukong
       # @param [String] tsv
       # @yield [obj] the deserialized object
       # @yieldparam [Object] obj
-      def process(tsv)
-        begin
-          record = tsv.split(/\t/)
-        rescue => e
-          # FIXME -- should we log here or what?
-          return
+      def process(record)
+        if record.respond_to?(:from_tsv)
+          obj = record.from_tsv
+        else
+          obj = record.split(/\t/)
         end
-        yield record
+        yield obj
+      rescue => e        
+        handle_error(record, e)
       end
       register
     end
@@ -236,52 +255,23 @@ module Wukong
       # @param [Array<Object>]
       # @yield [inspected]
       # @yieldparam [String] inspected
-      def process(*args)
-        yield args.size == 1 ? args.first.inspect : args.inspect
+      def process(record)
+        yield record.inspect
       end
       register
     end
+    
+    class Recordize < Serializer
+      field :model, Whatever
 
-    # A widget for pretty printing input records.
-    #
-    # @example Pretty printing JSON on the command-line
-    #
-    #   $ cat input
-    #   {"id": 1, "word": "apple" }
-    #   $ cat input | wu-local pretty
-    #   {
-    #     "id":2,
-    #     "parent_id":3
-    #   }
-    class Pretty < Serializer
-      # Pretty print `record` if we can.
-      #
-      # @param [Object] record
-      # @yield [pretty]
-      # @yieldparam [String] pretty the pretty-printed record
-      def process record
-        if record.is_a?(String) && record =~ /^\s*\{/
-          yield pretty_json(record)
-        else
-          yield record.to_s
-        end
-      end
-
-      # Attempt to pretty-print the given `json`, returning the
-      # original on an error.
-      #
-      # @param [String] json ugly JSON
-      # @return [String] prettier JSON
-      def pretty_json json
-        begin
-          MultiJson.dump(MultiJson.load(json), :pretty => true)
-        rescue => e
-          json
-        end
+      def process(record)
+        wire_format = record.try(:to_wire) || record
+        raise SerializerError.new("Record must be in hash format to be recordized") unless wire_format.is_a?(Hash)
+        yield model.receive(wire_format)
+      rescue => e        
+        handle_error(record, e)  
       end
-      
       register
-    end
-
+    end    
   end
 end

data/lib/wukong/widgets.rb

@@ -1,5 +1,3 @@
-require 'wukong/widget/source'
-require 'wukong/widget/sink'
 require 'wukong/widget/processors'
 require 'wukong/widget/reducers'
 require 'wukong/widget/serializers'

data/spec/hanuman/graph_spec.rb

@@ -32,6 +32,20 @@ describe Hanuman::GraphBuilder, :hanuman => true do
   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

data/spec/spec_helper.rb

@@ -1,39 +1,13 @@
-require 'bundler' ; Bundler.setup(:default, :development, :test)
-
-if ENV['WUKONG_COV']
-  require 'simplecov'
-
-  SimpleCov.start do
-    add_filter '/gorillib/'
-    add_filter '/away/'
-    add_group  'Hanuman', '/hanuman/'
-  end
-end
-
 require 'wukong'
 require 'wukong/spec_helpers'
-require_relative './support/shared_examples_for_builders'
 require_relative './support/shared_examples_for_shortcuts'
+require_relative './support/shared_examples_for_builders'
+require_relative './support/integration_helper'
 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
-
-# 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
-
 RSpec.configure do |config|
   config.mock_with :rspec
   include Wukong::SpecHelpers
-  # config.treat_symbols_as_metadata_keys_with_true_values = true
+  include Wukong::Local::IntegrationHelper
+  config.treat_symbols_as_metadata_keys_with_true_values = true
 end

data/spec/support/{wukong_test_helpers.rb → example_test_helpers.rb}

@@ -1,4 +1,31 @@
-require 'gorillib/utils/capture_output'
+if ENV['WUKONG_COV']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/gorillib/'
+    add_filter '/away/'
+    add_group  'Hanuman', '/hanuman/'
+  end
+end
+
+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
+
+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
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end
 
 shared_context 'wukong', :helpers => true do
 
@@ -21,6 +48,7 @@ shared_context 'wukong', :helpers => true do
   let(:test_dataflow)       { Wukong.dataflow(:test_dataflow)                       }
 end
 
+require 'gorillib/utils/capture_output'
 
 module WukongTestHelpers
 
@@ -65,5 +93,4 @@ RSpec::Core::DSL.module_eval do
       yield "#{basename}.dot" if block_given?
     end
   end
-
 end

data/spec/support/integration_helper.rb

@@ -0,0 +1,38 @@
+module Wukong
+  module Local
+    module IntegrationHelper
+
+      def root
+        @root ||= Pathname.new(File.expand_path('../../..', __FILE__))
+      end
+
+      def lib_dir *args
+        root.join('lib', *args)
+      end
+
+      def bin_dir *args
+        root.join('bin', *args)
+      end
+      
+      def examples_dir *args
+        root.join('examples', *args)
+      end
+
+      def integration_env
+        {
+          "PATH"    => [bin_dir.to_s, ENV["PATH"]].compact.join(':'),
+          "RUBYLIB" => [lib_dir.to_s, ENV["RUBYLIB"]].compact.join(':')
+        }
+      end
+
+      def integration_cwd
+        root.to_s
+      end
+
+      def example_script *args
+        examples_dir(*args)
+      end
+
+    end
+  end
+end

data/spec/support/model_test_helpers.rb

@@ -0,0 +1,115 @@
+require 'gorillib/utils/nuke_constants'
+require 'gorillib/utils/capture_output'
+
+module Gorillib ;               module Test ;       end ; end
+module Meta ; module Gorillib ; module Test ; end ; end ; end
+
+shared_context 'model', :model_spec do
+  include Gorillib::TestHelpers
+
+  after(:each){ Gorillib::Test.nuke_constants ; Meta::Gorillib::Test.nuke_constants }
+
+  let(:mock_val){ mock('mock value') }
+
+  let(:smurf_class) do
+    class Gorillib::Test::Smurf
+      include Gorillib::Model
+      field :name,       String
+      field :smurfiness, Integer
+      field :weapon,     Symbol
+    end
+    Gorillib::Test::Smurf
+  end
+  let(:papa_smurf   ){ smurf_class.receive(:name => 'Papa Smurf', :smurfiness => 9,  :weapon => 'staff') }
+  let(:smurfette    ){ smurf_class.receive(:name => 'Smurfette',  :smurfiness => 11, :weapon => 'charm') }
+
+  let(:smurf_collection_class) do
+    smurf_class
+    class Gorillib::Test::SmurfCollection < Gorillib::ModelCollection
+      include Gorillib::Collection::ItemsBelongTo
+      self.item_type        = Gorillib::Test::Smurf
+      self.parentage_method = :village
+    end
+    Gorillib::Test::SmurfCollection
+  end
+
+  let(:smurf_village_class) do
+    smurf_class ; smurf_collection_class
+    module Gorillib::Test
+      class SmurfVillage
+        include Gorillib::Model
+        field      :name,   Symbol
+        collection :smurfs, SmurfCollection, item_type: Smurf, key_method: :name
+      end
+    end
+    Gorillib::Test::SmurfVillage
+  end
+
+  let(:smurfhouse_class) do
+    module Gorillib::Test
+      class Smurfhouse
+        include Gorillib::Model
+        field   :shape, Symbol
+        field   :color, Symbol
+      end
+    end
+    Gorillib::Test::Smurfhouse
+  end
+
+end
+
+shared_context 'builder', :model_spec, :builder_spec do
+  let(:engine_class) do
+    class Gorillib::Test::Engine
+      include Gorillib::Builder
+      magic    :name,         Symbol, :default => ->{ "#{owner? ? owner.name : ''} engine"}
+      magic    :carburetor,   Symbol, :default => :stock
+      magic    :volume,       Integer, :doc => 'displacement volume, in in^3'
+      magic    :cylinders,    Integer
+      member   :owner,        Whatever
+      self
+    end
+    Gorillib::Test::Engine
+  end
+
+  let(:car_class) do
+    engine_class
+    class Gorillib::Test::Car
+      include Gorillib::Builder
+      magic    :name,          Symbol
+      magic    :make_model,    String
+      magic    :year,          Integer
+      magic    :doors,         Integer
+      member   :engine,        Gorillib::Test::Engine
+      self
+    end
+    Gorillib::Test::Car
+  end
+
+  let(:garage_class) do
+    car_class
+    class Gorillib::Test::Garage
+      include Gorillib::Builder
+      collection :cars,       Gorillib::Test::Car, key_method: :name
+      self
+    end
+    Gorillib::Test::Garage
+  end
+
+  let(:wildcat) do
+    car_class.receive( :name => :wildcat,
+      :make_model => 'Buick Wildcat', :year => 1968, :doors => 2,
+      :engine => { :volume => 455, :cylinders => 8 } )
+  end
+  let(:ford_39) do
+    car_class.receive( :name => :ford_39,
+      :make_model => 'Ford Tudor Sedan', :year => 1939, :doors => 2, )
+  end
+  let(:garage) do
+    garage_class.new
+  end
+  let(:example_engine) do
+    engine_class.new( :name => 'Geo Metro 1.0L', :volume => 61, :cylinders => 3 )
+  end
+
+end