bumbleworks 0.0.51 → 0.0.52

data/lib/bumbleworks.rb

@@ -11,6 +11,7 @@ require "bumbleworks/hash_storage"
 require "bumbleworks/error_handler"
 require "bumbleworks/entity"
 require "bumbleworks/participant"
+require "bumbleworks/workitem"
 
 # default implementations
 require "bumbleworks/simple_logger"
@@ -21,6 +22,7 @@ module Bumbleworks
   class UndefinedSetting < StandardError; end
   class InvalidSetting < StandardError; end
   class InvalidEntity < StandardError; end
+  class EntityNotFound < StandardError; end
 
   class << self
     extend Forwardable

data/lib/bumbleworks/entity.rb

@@ -5,19 +5,19 @@ module Bumbleworks
     end
 
     def launch_process(process_name, options = {})
-      identifier_column = self.class.processes[process_name.to_sym][:column]
-      if (options[:force] == true || (process_identifier = self.send(identifier_column)).nil?)
-        workitem_fields = process_fields(process_name.to_sym)
-        variables = process_variables(process_name.to_sym)
+      identifier_attribute = attribute_for_process_name(process_name.to_sym)
+      if (options[:force] == true || (process_identifier = self.send(identifier_attribute)).nil?)
+        workitem_fields = process_fields(process_name.to_sym).merge(options[:fields] || {})
+        variables = process_variables(process_name.to_sym).merge(options[:variables] || {})
         process_identifier = Bumbleworks.launch!(process_name.to_s, workitem_fields, variables).wfid
-        persist_process_identifier(identifier_column.to_sym, process_identifier)
+        persist_process_identifier(identifier_attribute.to_sym, process_identifier)
       end
       Bumbleworks::Process.new(process_identifier)
     end
 
-    def persist_process_identifier(identifier_column, process_identifier)
+    def persist_process_identifier(identifier_attribute, process_identifier)
       if self.respond_to?(:update)
-        update(identifier_column => process_identifier)
+        update(identifier_attribute => process_identifier)
       else
         raise "Entity must define #persist_process_identifier method if missing #update method."
       end
@@ -27,7 +27,7 @@ module Bumbleworks
       return {} unless self.class.processes
       process_names = self.class.processes.keys
       process_names.inject({}) do |memo, name|
-        pid = self.send(self.class.processes[name][:column])
+        pid = self.send(attribute_for_process_name(name))
         memo[name] = pid ? Bumbleworks::Process.new(pid) : nil
         memo
       end
@@ -38,11 +38,18 @@ module Bumbleworks
     end
 
     def cancel_all_processes!
-      processes.each do |process|
+      processes_by_name.each do |name, process|
+        next unless process
+        identifier_attribute = attribute_for_process_name(name)
         process.cancel!
+        persist_process_identifier(identifier_attribute, nil)
       end
     end
 
+    def attribute_for_process_name(name)
+      self.class.processes[name][:attribute]
+    end
+
     def tasks(nickname = nil)
       finder = Bumbleworks::Task.for_entity(self)
       finder = finder.by_nickname(nickname) if nickname
@@ -69,7 +76,7 @@ module Bumbleworks
       attr_reader :processes
 
       def process(process_name, options = {})
-        options[:column] ||= process_identifier_column(process_name)
+        options[:attribute] ||= default_process_identifier_attribute(process_name)
         (@processes ||= {})[process_name.to_sym] = options
       end
 
@@ -77,11 +84,11 @@ module Bumbleworks
         Bumbleworks::Support.tokenize(name)
       end
 
-      def process_identifier_column(process_name)
-        identifier_column = "#{process_name}_process_identifier"
-        identifier_column.gsub!(/^#{entity_type}_/, '')
-        identifier_column.gsub!(/process_process/, 'process')
-        identifier_column.to_sym
+      def default_process_identifier_attribute(process_name)
+        identifier_attribute = "#{process_name}_process_identifier"
+        identifier_attribute.gsub!(/^#{entity_type}_/, '')
+        identifier_attribute.gsub!(/process_process/, 'process')
+        identifier_attribute.to_sym
       end
     end
   end

data/lib/bumbleworks/process.rb

@@ -1,5 +1,7 @@
 module Bumbleworks
   class Process
+    class EntityConflict < StandardError; end
+
     attr_reader :id
 
     def initialize(wfid)
@@ -12,6 +14,16 @@ module Bumbleworks
       wfid == other.wfid
     end
 
+    def entity
+      return nil unless process_status
+      workitems = leaves.map(&:applied_workitem).map { |wi| Bumbleworks::Workitem.new(wi) }
+      if workitems.map(&:entity_fields).uniq.length == 1
+        workitems.first.entity
+      else
+        raise EntityConflict
+      end
+    end
+
     def tasks
       Bumbleworks::Task.for_process(wfid)
     end

data/lib/bumbleworks/task/finder.rb

@@ -11,6 +11,32 @@ module Bumbleworks
         @wfids = nil
       end
 
+      def where(filters)
+        key_method_map = {
+          :available => :available,
+          :nickname => :by_nickname,
+          :roles => :for_roles,
+          :role => :for_role,
+          :unclaimed => :unclaimed,
+          :claimed => :claimed,
+          :fields => :with_fields,
+          :claimant => :for_claimant,
+          :entity => :for_entity,
+          :processes => :for_processes,
+          :process => :for_process,
+          :completable => :completable
+        }
+        fields = filters.select { |k,v| !key_method_map.keys.include? k }
+        methods = filters.select { |k,v| key_method_map.keys.include? k }
+        query = methods.inject(self) { |query, (method, args)|
+          query.send(key_method_map[method], args)
+        }
+        unless fields.empty?
+          query.with_fields(fields)
+        end
+        query
+      end
+
       def available
         unclaimed.completable
       end
@@ -39,6 +65,11 @@ module Bumbleworks
         unclaimed(false)
       end
 
+      def with_fields(field_hash)
+        @queries << proc { |wi| field_hash.all? { |k, v| wi['fields'][k.to_s] == v } }
+        self
+      end
+
       def for_claimant(token)
         @queries << proc { |wi| wi['fields']['params']['claimant'] == token }
         self
@@ -75,8 +106,8 @@ module Bumbleworks
         from_workitems(workitems)
       end
 
-      def completable
-        @task_filters << proc { |task| task.completable? }
+      def completable(true_or_false = true)
+        @task_filters << proc { |task| task.completable? == true_or_false }
         self
       end
 

data/lib/bumbleworks/version.rb

@@ -1,3 +1,3 @@
 module Bumbleworks
-  VERSION = "0.0.51"
+  VERSION = "0.0.52"
 end

data/lib/bumbleworks/workitem.rb

@@ -0,0 +1,52 @@
+module Bumbleworks
+  class Workitem
+    def initialize(raw_workitem)
+      @raw_workitem = raw_workitem
+    end
+
+    def entity(options = {})
+      @entity = nil if options[:reload] == true
+      @entity ||= if has_entity_fields?
+        klass = Bumbleworks::Support.constantize(entity_type)
+        entity = klass.first_by_identifier(entity_id)
+      end
+      raise EntityNotFound, {:entity_id => entity_id, :entity_type => entity_type} unless @entity
+      @entity
+    end
+
+    def has_entity?
+      !entity.nil?
+    rescue EntityNotFound
+      false
+    end
+
+    def has_entity_fields?
+      entity_id && entity_type
+    end
+
+    def entity_fields(options = {})
+      return {} unless has_entity_fields?
+      type = if options[:humanize] == true
+        Bumbleworks::Support.humanize(entity_type)
+      elsif options[:titleize] == true
+        Bumbleworks::Support.titleize(entity_type)
+      else
+        entity_type
+      end
+      {
+        :type => type,
+        :identifier => entity_id
+      }
+    end
+
+  private
+
+    def entity_id
+      @raw_workitem.fields[:entity_id] || @raw_workitem.fields['entity_id']
+    end
+
+    def entity_type
+      @raw_workitem.fields[:entity_type] || @raw_workitem.fields['entity_type']
+    end
+  end
+end

data/lib/bumbleworks/workitem_entity_storage.rb

@@ -1,50 +1,11 @@
 module Bumbleworks
   module WorkitemEntityStorage
-    class EntityNotFound < StandardError; end
+    extend Forwardable
 
-    def entity(options = {})
-      @entity = nil if options[:reload] == true
-      @entity ||= if has_entity_fields?
-        klass = Bumbleworks::Support.constantize(entity_type)
-        entity = klass.first_by_identifier(entity_id)
-      end
-      raise EntityNotFound, {:entity_id => entity_id, :entity_type => entity_type} unless @entity
-      @entity
-    end
-
-    def has_entity?
-      !entity.nil?
-    rescue EntityNotFound
-      false
-    end
-
-    def has_entity_fields?
-      entity_id && entity_type
-    end
-
-    def entity_fields(options = {})
-      return {} unless has_entity_fields?
-      type = if options[:humanize] == true
-        Bumbleworks::Support.humanize(entity_type)
-      elsif options[:titleize] == true
-        Bumbleworks::Support.titleize(entity_type)
-      else
-        entity_type
-      end
-      {
-        :type => type,
-        :identifier => entity_id
-      }
-    end
-
-  private
-
-    def entity_id
-      workitem.fields[:entity_id] || workitem.fields['entity_id']
-    end
+    delegate [:entity, :has_entity?, :has_entity_fields?, :entity_fields] => :entity_storage_workitem
 
-    def entity_type
-      workitem.fields[:entity_type] || workitem.fields['entity_type']
+    def entity_storage_workitem
+      @entity_storage_workitem ||= Bumbleworks::Workitem.new(workitem)
     end
   end
 end

data/spec/fixtures/entities/{furby.rb → rainbow_loom.rb}

@@ -1,10 +1,12 @@
-class Furby
+class RainbowLoom
   include Bumbleworks::Entity
 
   process :make_honey
+  process :make_molasses, :attribute => :molasses_pid
 
-  attr_reader :identifier
+  attr_accessor :identifier
   attr_accessor :make_honey_process_identifier
+  attr_accessor :molasses_pid
 
   def initialize(identifier)
     @identifier = identifier
@@ -24,6 +26,7 @@ class Furby
 
   class << self
     def first_by_identifier(identifier)
+      return nil unless identifier
       new(identifier)
     end
   end

data/spec/integration/entity_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(fixtures_path, 'entities', 'furby'))
+require File.expand_path(File.join(fixtures_path, 'entities', 'rainbow_loom'))
 
 describe 'Entity Module' do
   let(:app_root) {
@@ -10,27 +10,29 @@ describe 'Entity Module' do
     load File.join(app_root, 'full_initializer.rb')
   end
 
-  describe 'launching a process' do
-    it 'assigns entity to process and subsequent tasks' do
-      furby = Furby.new('12345')
-      furby.launch_process(:make_honey)
+  describe 'process control' do
+    it 'launching assigns entity to process and subsequent tasks' do
+      rainbow_loom = RainbowLoom.new('12345')
+      process = rainbow_loom.launch_process(:make_honey)
       Bumbleworks.dashboard.wait_for(:dave)
       task = Bumbleworks::Task.for_role('dave').first
-      task.entity.should == furby
+      task.entity.should == rainbow_loom
+      process.entity.should == rainbow_loom
     end
 
-    it 'links processes with identifiers' do
-      furby = Furby.new('12345')
-      process = furby.launch_process(:make_honey)
-      furby.processes_by_name.should == {
-        :make_honey => process
+    it 'launching links processes with identifiers' do
+      rainbow_loom = RainbowLoom.new('12345')
+      process = rainbow_loom.launch_process(:make_honey)
+      rainbow_loom.processes_by_name.should == {
+        :make_honey => process,
+        :make_molasses => nil
       }
     end
 
     it 'persists process identifier' do
-      furby = Furby.new('12345')
-      process = furby.launch_process(:make_honey)
-      furby.make_honey_process_identifier.should == process.wfid
+      rainbow_loom = RainbowLoom.new('12345')
+      process = rainbow_loom.launch_process(:make_honey)
+      rainbow_loom.make_honey_process_identifier.should == process.wfid
     end
   end
 
@@ -40,8 +42,8 @@ describe 'Entity Module' do
         tell_entity :to => 'cook_it_up', :with => [2, 'orange'], :and_save_as => 'yum'
         critic :task => 'checkit_that_foods'
       end
-      furby = Furby.new('12345')
-      process = Bumbleworks.launch!('here_we_go', :entity => furby)
+      rainbow_loom = RainbowLoom.new('12345')
+      process = Bumbleworks.launch!('here_we_go', :entity => rainbow_loom)
       Bumbleworks.dashboard.wait_for(:critic)
       process.tasks.first['yum'].should == "2 and orange"
     end

data/spec/lib/bumbleworks/entity_spec.rb

@@ -5,7 +5,7 @@ describe Bumbleworks::Entity do
     it 'returns hash of process names and process instances' do
       [:zoom, :foof, :nook].each do |pname|
         entity_class.send(:attr_accessor, :"#{pname}_pid")
-        entity_class.process pname, :column => :"#{pname}_pid"
+        entity_class.process pname, :attribute => :"#{pname}_pid"
       end
 
       entity = entity_class.new
@@ -27,7 +27,7 @@ describe Bumbleworks::Entity do
     it 'returns array of process instances for all running processes' do
       [:zoom, :foof, :nook].each do |pname|
         entity_class.send(:attr_accessor, :"#{pname}_pid")
-        entity_class.process pname, :column => :"#{pname}_pid"
+        entity_class.process pname, :attribute => :"#{pname}_pid"
       end
       entity = entity_class.new
       entity.foof_pid = '1234'
@@ -45,12 +45,21 @@ describe Bumbleworks::Entity do
 
   describe '#cancel_all_processes!' do
     it 'cancels all processes with registered identifiers' do
+      [:zoom, :foof, :nook].each do |pname|
+        entity_class.send(:attr_accessor, :"#{pname}_pid")
+        entity_class.process pname, :attribute => :"#{pname}_pid"
+      end
       entity = entity_class.new
-      bp1 = Bumbleworks::Process.new('1234')
-      bp2 = Bumbleworks::Process.new('pickles')
-      entity.stub(:processes).and_return([bp1, bp2])
+      entity.foof_pid = '1234'
+      entity.nook_pid = 'pickles'
+      entity.stub(:processes_by_name => {
+        :foof => bp1 = Bumbleworks::Process.new('1234'),
+        :nook => bp2 = Bumbleworks::Process.new('pickles')
+      })
       bp1.should_receive(:cancel!)
       bp2.should_receive(:cancel!)
+      entity.should_receive(:update).with(:foof_pid => nil)
+      entity.should_receive(:update).with(:nook_pid => nil)
       entity.cancel_all_processes!
     end
   end
@@ -80,8 +89,8 @@ describe Bumbleworks::Entity do
   describe '#persist_process_identifier' do
     it 'calls #update if method exists' do
       entity = entity_class.new
-      entity.should_receive(:update).with(:a_column => :a_value)
-      entity.persist_process_identifier(:a_column, :a_value)
+      entity.should_receive(:update).with(:a_attribute => :a_value)
+      entity.persist_process_identifier(:a_attribute, :a_value)
     end
 
     it 'raises exception if #update method does not exist' do
@@ -89,7 +98,7 @@ describe Bumbleworks::Entity do
       entity.stub(:respond_to?).with(:update).and_return(false)
       entity.should_receive(:update).never
       expect {
-        entity.persist_process_identifier(:a_column, :a_value)
+        entity.persist_process_identifier(:a_attribute, :a_value)
       }.to raise_error("Entity must define #persist_process_identifier method if missing #update method.")
     end
   end
@@ -97,34 +106,72 @@ describe Bumbleworks::Entity do
   describe '#launch_process' do
     it 'launches process and return process if identifier not set' do
       bp = Bumbleworks::Process.new('12345')
-      entity_class.process :noodles, :column => :noodles_pid
+      entity_class.process :noodles, :attribute => :noodles_pid
       entity = entity_class.new
       entity.stub(:noodles_pid)
-      entity.stub(:process_fields).with(:noodles).and_return('the_fields')
-      entity.stub(:process_variables).with(:noodles).and_return('the_variables')
-      Bumbleworks.stub(:launch!).with('noodles', 'the_fields', 'the_variables').and_return(bp)
+      entity.stub(:process_fields).with(:noodles).and_return({:f => 1})
+      entity.stub(:process_variables).with(:noodles).and_return({:v => 2})
+      Bumbleworks.stub(:launch!).with('noodles', {:f => 1}, {:v => 2}).and_return(bp)
       entity.should_receive(:persist_process_identifier).with(:noodles_pid, '12345')
       entity.launch_process('noodles').should == bp
     end
 
-    it 'does nothing but returns existing process if identifier column already set' do
+    it 'does nothing but returns existing process if identifier attribute already set' do
       bp = Bumbleworks::Process.new('already set')
-      entity_class.process :noodles, :column => :noodles_pid
+      entity_class.process :noodles, :attribute => :noodles_pid
       entity = entity_class.new
       entity.stub(:noodles_pid => 'already set')
       Bumbleworks.should_receive(:launch!).never
       entity.launch_process('noodles').should == bp
     end
 
-    it 'launches new process anyway if identifier column already set but force is true' do
+    it 'launches new process anyway if identifier attribute already set but force is true' do
       bp = Bumbleworks::Process.new('12345')
-      entity_class.process :noodles, :column => :noodles_pid
+      entity_class.process :noodles, :attribute => :noodles_pid
       entity = entity_class.new
       entity.stub(:noodles_pid => 'already set')
       Bumbleworks.stub(:launch! => bp)
       entity.should_receive(:persist_process_identifier).with(:noodles_pid, '12345')
       entity.launch_process('noodles', :force => true).should == bp
     end
+
+    it 'sends additional fields and variables to launch' do
+      entity_class.process :noodles, :attribute => :noodles_pid
+      entity = entity_class.new
+      entity.stub(:noodles_pid)
+      entity.stub(:persist_process_identifier)
+      Bumbleworks.should_receive(:launch!).with(
+        'noodles',
+        { :entity => entity, :drink => 'apathy smoothie', :berry => 'black' },
+        { :so_you_said => :well_so_did_i }
+      ).and_return(Bumbleworks::Process.new(1))
+      entity.launch_process(:noodles,
+        :fields => { :drink => 'apathy smoothie', :berry => 'black' },
+        :variables => { :so_you_said => :well_so_did_i }
+      )
+    end
+  end
+
+  describe '#attribute_for_process_name' do
+    it 'returns attribute set for given process' do
+      entity_class.stub(:processes).and_return({
+        :goose => { :attribute => :goose_pid },
+        :the_punisher => { :attribute => :your_skin }
+      })
+      entity = entity_class.new
+      entity.attribute_for_process_name(:goose).should == :goose_pid
+      entity.attribute_for_process_name(:the_punisher).should == :your_skin
+    end
+
+    it 'raises exception if no process found for given name' do
+      entity_class.stub(:processes).and_return({
+        :goose => { :attribute => :goose_pid },
+      })
+      entity = entity_class.new
+      expect {
+        entity.attribute_for_process_name(:the_punisher)
+      }.to raise_error
+    end
   end
 
   describe '#subscribed_events' do
@@ -174,28 +221,28 @@ describe Bumbleworks::Entity do
 
   describe '.process' do
     it 'registers a new process' do
-      entity_class.stub(:process_identifier_column).with(:whatever).and_return('loob')
+      entity_class.stub(:default_process_identifier_attribute).with(:whatever).and_return('loob')
       entity_class.process :whatever
       entity_class.processes.should == {
         :whatever => {
-          :column => 'loob'
+          :attribute => 'loob'
         }
       }
     end
   end
 
-  describe '.process_identifier_column' do
+  describe '.default_process_identifier_attribute' do
     it 'adds _process_identifier to end of given process name' do
-      entity_class.process_identifier_column('zoof').should == :zoof_process_identifier
+      entity_class.default_process_identifier_attribute('zoof').should == :zoof_process_identifier
     end
 
     it 'ensures no duplication of _process' do
-      entity_class.process_identifier_column('zoof_process').should == :zoof_process_identifier
+      entity_class.default_process_identifier_attribute('zoof_process').should == :zoof_process_identifier
     end
 
     it 'removes entity_type from beginning of identifier' do
       entity_class.stub(:entity_type).and_return('zoof')
-      entity_class.process_identifier_column('zoof_process').should == :process_identifier
+      entity_class.default_process_identifier_attribute('zoof_process').should == :process_identifier
     end
   end
 

data/spec/lib/bumbleworks/process_spec.rb

@@ -1,3 +1,5 @@
+require File.expand_path(File.join(fixtures_path, 'entities', 'rainbow_loom'))
+
 describe Bumbleworks::Process do
   before :each do
     Bumbleworks.reset!
@@ -119,6 +121,45 @@ describe Bumbleworks::Process do
     end
   end
 
+  describe '#entity' do
+    it 'returns nil if process not ready yet' do
+      bp = described_class.new('nothing')
+      bp.entity.should be_nil
+    end
+
+    it 'returns entity provided at launch' do
+      rainbow_loom = RainbowLoom.new('1234')
+      bp = Bumbleworks.launch!('going_to_the_dance', :entity => rainbow_loom)
+      wait_until { bp.trackers.count > 0 }
+      bp.entity.should == rainbow_loom
+    end
+
+    it 'raises exception if multiple workitems have conflicting entity info' do
+      Bumbleworks.define_process 'conflict_this' do
+        concurrence do
+          sequence do
+            set 'entity_id' => 'swoo'
+            just_wait
+          end
+          sequence do
+            set 'entity_id' => 'fwee'
+            just_wait
+          end
+        end
+      end
+      bp = Bumbleworks.launch!('conflict_this', :entity => RainbowLoom.new('1234'))
+      Bumbleworks.dashboard.wait_for(:just_wait)
+      expect {
+        bp.entity
+      }.to raise_error(Bumbleworks::Process::EntityConflict)
+    end
+
+    it 'returns nil if no entity' do
+      bp = Bumbleworks.launch!('going_to_the_dance')
+      bp.entity.should be_nil
+    end
+  end
+
   describe '#process_status' do
     it 'returns a process_status instance for the wfid' do
       bp = described_class.new('frogheads')

data/spec/lib/bumbleworks/task/finder_spec.rb

@@ -40,4 +40,31 @@ describe Bumbleworks::Task::Finder do
       query.available
     end
   end
+
+  describe '#where' do
+    it 'compiles a finder' do
+      query = Bumbleworks::Task::Finder.new
+      query.should_receive(:available).and_return(query)
+      query.should_receive(:by_nickname).with(:nicholas).and_return(query)
+      query.should_receive(:for_roles).with([:dinner, :barca]).and_return(query)
+      query.should_receive(:unclaimed).and_return(query)
+      query.should_receive(:for_claimant).with(:dr_clam).and_return(query)
+      query.should_receive(:for_entity).with(:a_luffly_pirate).and_return(query)
+      query.should_receive(:for_processes).with([:jasmine, :mulan]).and_return(query)
+      query.should_receive(:completable).with(true).and_return(query)
+      query.should_receive(:with_fields).with({ :horse => :giant_pony, :pie => :silly_cake }).and_return(query)
+      query.where({
+        :available => true,
+        :nickname => :nicholas,
+        :roles => [:dinner, :barca],
+        :unclaimed => true,
+        :claimant => :dr_clam,
+        :entity => :a_luffly_pirate,
+        :processes => [:jasmine, :mulan],
+        :completable => true,
+        :horse => :giant_pony,
+        :pie => :silly_cake
+      })
+    end
+  end
 end

data/spec/lib/bumbleworks/task_spec.rb

@@ -371,7 +371,7 @@ describe Bumbleworks::Task do
   end
 
   describe '.completable' do
-    it 'returns only completable tasks' do
+    it 'filters by completability' do
       module WuggleHandsTask
         def completable?
           false
@@ -393,6 +393,11 @@ describe Bumbleworks::Task do
         ['a_fella', 'waggle_hands'],
         ['a_lady', 'wiggle_hands']
       ]
+      tasks = described_class.completable(false)
+      tasks.should have(1).item
+      tasks.map { |t| [t.role, t.nickname] }.should == [
+        ['a_monkey', 'wuggle_hands']
+      ]
     end
   end
 
@@ -469,7 +474,7 @@ describe Bumbleworks::Task do
     end
   end
 
-  context '.for_claimant' do
+  describe '.for_claimant' do
     it 'returns all tasks claimed by given claimant' do
       Bumbleworks.define_process 'dog-lifecycle' do
         concurrence do
@@ -493,7 +498,34 @@ describe Bumbleworks::Task do
     end
   end
 
-  context '.for_entity' do
+  describe '.with_fields' do
+    it 'returns all tasks with given fields' do
+      Bumbleworks.define_process 'divergination' do
+        concurrence do
+          sequence do
+            set 'bumby' => 'fancy'
+            bumber :task => 'wear_monocle'
+          end
+          sequence do
+            set 'bumby' => 'not_fancy'
+            concurrence do
+              bumber :task => 'wear_natties'
+              loofer :task => 'snuffle'
+            end
+          end
+        end
+      end
+      Bumbleworks.launch!('divergination', :grumbles => true)
+      Bumbleworks.dashboard.wait_for(:loofer)
+      described_class.with_fields(:grumbles => true).count.should == 3
+      described_class.with_fields(:bumby => 'fancy').count.should == 1
+      described_class.with_fields(:bumby => 'not_fancy').count.should == 2
+      described_class.with_fields(:grumbles => false, :bumby => 'not_fancy').should be_empty
+      described_class.with_fields(:what => 'ever').should be_empty
+    end
+  end
+
+  describe '.for_entity' do
     it 'returns all tasks associated with given entity' do
       fake_sandwich = OpenStruct.new(:identifier => 'rubies')
       Bumbleworks.define_process 'existential_pb_and_j' do

data/spec/lib/bumbleworks/workitem_entity_storage_spec.rb

@@ -3,121 +3,33 @@ require "bumbleworks/workitem_entity_storage"
 describe Bumbleworks::WorkitemEntityStorage do
   class FakeEntityHolder
     include Bumbleworks::WorkitemEntityStorage
-    def initialize(fields = {})
-      @fields = fields
-    end
-
-    def workitem
-      OpenStruct.new(:fields => @fields)
-    end
-  end
-
-  describe '#has_entity_fields?' do
-    it 'returns true if workitem fields include entity fields' do
-      feh = FakeEntityHolder.new('entity_id' => '1', 'entity_type' => 'SomeEntity')
-      feh.should have_entity_fields
-    end
-
-    it 'returns true if workitem fields include symbolized version of entity fields' do
-      feh = FakeEntityHolder.new(:entity_id => '1', :entity_type => 'SomeEntity')
-      feh.should have_entity_fields
-    end
-
-    it 'returns false if workitem fields do not include entity fields' do
-      feh = FakeEntityHolder.new
-      feh.should_not have_entity_fields
+    attr_reader :workitem
+    def initialize(workitem)
+      @workitem = workitem
     end
   end
 
-  describe '#has_entity?' do
-    it 'returns true if entity is not nil' do
-      feh = FakeEntityHolder.new
-      feh.stub(:entity).and_return(:a_real_boy_not_a_puppet)
-      feh.has_entity?.should be_true
+  describe '#entity_storage_workitem' do
+    it 'returns new Bumbleworks::Workitem instance with workitem' do
+      Bumbleworks::Workitem.stub(:new).with(:a_workitem).and_return(:the_workitem)
+      feh = FakeEntityHolder.new(:a_workitem)
+      feh.entity_storage_workitem.should == :the_workitem
     end
 
-    it 'returns false if EntityNotFound' do
-      feh = FakeEntityHolder.new
-      feh.stub(:entity).and_raise(Bumbleworks::WorkitemEntityStorage::EntityNotFound)
-      feh.has_entity?.should be_false
+    it 'is memoized' do
+      feh = FakeEntityHolder.new(:a_workitem)
+      esw = feh.entity_storage_workitem
+      feh.entity_storage_workitem.should be esw
     end
   end
 
-  describe '#entity' do
-    before :all do
-      class LovelyEntity
-        attr_accessor :identifier
-        def initialize(identifier)
-          @identifier = identifier
-        end
-
-        def self.first_by_identifier(identifier)
-          return nil unless identifier
-          new(identifier)
-        end
+  [:has_entity_fields?, :has_entity?, :entity, :entity_fields].each do |method|
+    describe "##{method}" do
+      it 'delegates to entity storage workitem' do
+        feh = FakeEntityHolder.new(:a_workitem)
+        feh.entity_storage_workitem.stub(method).with(1, 2, 3).and_return(:yay_for_bikes)
+        feh.send(method, 1, 2, 3).should == :yay_for_bikes
       end
     end
-
-    after :all do
-      Object.send(:remove_const, :LovelyEntity)
-    end
-
-    it 'attempts to instantiate business entity from _id and _type fields' do
-      feh = FakeEntityHolder.new('entity_id' => '15', 'entity_type' => 'LovelyEntity')
-      feh.entity.identifier.should == '15'
-    end
-
-    it 'works with symbolized _id and _type fields' do
-      feh = FakeEntityHolder.new(:entity_id => '15', :entity_type => 'LovelyEntity')
-      feh.entity.identifier.should == '15'
-    end
-
-    it 'throw exception if entity fields not present' do
-      feh = FakeEntityHolder.new
-      expect {
-        feh.entity
-      }.to raise_error Bumbleworks::WorkitemEntityStorage::EntityNotFound
-    end
-
-    it 'throw exception if entity returns nil' do
-      feh = FakeEntityHolder.new('entity_id' => nil, 'entity_type' => 'LovelyEntity')
-      expect {
-        feh.entity
-      }.to raise_error Bumbleworks::WorkitemEntityStorage::EntityNotFound, '{:entity_id=>nil, :entity_type=>"LovelyEntity"}'
-    end
-
-    it 'returns same instance when called twice' do
-      feh = FakeEntityHolder.new('entity_id' => '15', 'entity_type' => 'LovelyEntity')
-      feh.entity.identifier = 'pickles'
-      feh.entity.identifier.should == 'pickles'
-    end
-
-    it 'reloads instance when called with reload option' do
-      feh = FakeEntityHolder.new('entity_id' => '15', 'entity_type' => 'LovelyEntity')
-      feh.entity.identifier = 'pickles'
-      feh.entity(:reload => true).identifier.should == '15'
-    end
-  end
-
-  describe "#entity_fields" do
-    it 'returns empty hash if no entity' do
-      feh = FakeEntityHolder.new
-      feh.entity_fields.should == {}
-    end
-
-    it 'returns class name and identifier by default' do
-      feh = FakeEntityHolder.new('entity_id' => '15', 'entity_type' => 'LovelyEntity')
-      feh.entity_fields.should == { :type => 'LovelyEntity', :identifier => '15' }
-    end
-
-    it 'humanizes class name when requested' do
-      feh = FakeEntityHolder.new('entity_id' => '15', 'entity_type' => 'LovelyEntity')
-      feh.entity_fields(:humanize => true).should == { :type => 'Lovely entity', :identifier => '15' }
-    end
-
-    it 'titleizes class name when requested' do
-      feh = FakeEntityHolder.new('entity_id' => '15', 'entity_type' => 'LovelyEntity')
-      feh.entity_fields(:titleize => true).should == { :type => 'Lovely Entity', :identifier => '15' }
-    end
   end
 end

data/spec/lib/bumbleworks/workitem_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.join(fixtures_path, 'entities', 'rainbow_loom'))
+
+describe Bumbleworks::Workitem do
+  let(:ruote_workitem) { Ruote::Workitem.new('fields' => {'entity_id' => '123', 'entity_type' => 'RainbowLoom'} ) }
+  let(:workitem) { Bumbleworks::Workitem.new(ruote_workitem)}
+
+  describe '#has_entity_fields?' do
+    it 'returns true if workitem fields include entity fields' do
+      workitem.should have_entity_fields
+    end
+
+    it 'returns true if workitem fields include symbolized version of entity fields' do
+      ruote_workitem.fields = { :entity_id => '123', :entity_type => 'RainbowLoom' }
+      workitem.should have_entity_fields
+    end
+
+    it 'returns false if workitem fields do not include entity fields' do
+      ruote_workitem.fields = {}
+      workitem.should_not have_entity_fields
+    end
+  end
+
+  describe '#has_entity?' do
+    it 'returns true if entity is not nil' do
+      workitem.stub(:entity).and_return(:a_real_boy_not_a_puppet)
+      workitem.has_entity?.should be_true
+    end
+
+    it 'returns false if EntityNotFound' do
+      workitem.stub(:entity).and_raise(Bumbleworks::EntityNotFound)
+      workitem.has_entity?.should be_false
+    end
+  end
+
+  describe '#entity' do
+    it 'attempts to instantiate business entity from _id and _type fields' do
+      workitem.entity.identifier.should == '123'
+    end
+
+    it 'works with symbolized _id and _type fields' do
+      ruote_workitem.fields = { :entity_id => '125', :entity_type => 'RainbowLoom' }
+      workitem.entity.identifier.should == '125'
+    end
+
+    it 'throw exception if entity fields not present' do
+      ruote_workitem.fields = {}
+      expect {
+        workitem.entity
+      }.to raise_error Bumbleworks::EntityNotFound
+    end
+
+    it 'throw exception if entity returns nil' do
+      ruote_workitem.fields['entity_id'] = nil
+      expect {
+        workitem.entity
+      }.to raise_error Bumbleworks::EntityNotFound, '{:entity_id=>nil, :entity_type=>"RainbowLoom"}'
+    end
+
+    it 'returns same instance when called twice' do
+      workitem.entity.identifier = 'nerfus'
+      workitem.entity.identifier.should == 'nerfus'
+    end
+
+    it 'reloads instance when called with reload option' do
+      workitem.entity.identifier = 'pickles'
+      workitem.entity(:reload => true).identifier.should == '123'
+    end
+  end
+
+  describe "#entity_fields" do
+    it 'returns empty hash if no entity' do
+      ruote_workitem.fields = {}
+      workitem.entity_fields.should == {}
+    end
+
+    it 'returns class name and identifier by default' do
+      workitem.entity_fields.should == { :type => 'RainbowLoom', :identifier => '123' }
+    end
+
+    it 'humanizes class name when requested' do
+      workitem.entity_fields(:humanize => true).should == { :type => 'Rainbow loom', :identifier => '123' }
+    end
+
+    it 'titleizes class name when requested' do
+      workitem.entity_fields(:titleize => true).should == { :type => 'Rainbow Loom', :identifier => '123' }
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bumbleworks
 version: !ruby/object:Gem::Version
-  version: 0.0.51
+  version: 0.0.52
   prerelease: 
 platform: ruby
 authors:
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-21 00:00:00.000000000 Z
+date: 2013-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruote
@@ -192,6 +192,7 @@ files:
 - lib/bumbleworks/task/finder.rb
 - lib/bumbleworks/tree_builder.rb
 - lib/bumbleworks/version.rb
+- lib/bumbleworks/workitem.rb
 - lib/bumbleworks/workitem_entity_storage.rb
 - lib/tasks/bumbleworks.rake
 - spec/fixtures/apps/with_default_directories/config_initializer.rb
@@ -209,7 +210,7 @@ files:
 - spec/fixtures/definitions/a_list_of_jams.rb
 - spec/fixtures/definitions/nested_folder/test_nested_process.rb
 - spec/fixtures/definitions/test_process.rb
-- spec/fixtures/entities/furby.rb
+- spec/fixtures/entities/rainbow_loom.rb
 - spec/integration/entity_spec.rb
 - spec/integration/example_configurations_spec.rb
 - spec/integration/history_storage_spec.rb
@@ -236,6 +237,7 @@ files:
 - spec/lib/bumbleworks/task_spec.rb
 - spec/lib/bumbleworks/tree_builder_spec.rb
 - spec/lib/bumbleworks/workitem_entity_storage_spec.rb
+- spec/lib/bumbleworks/workitem_spec.rb
 - spec/lib/bumbleworks_spec.rb
 - spec/spec_helper.rb
 - spec/support/path_helpers.rb
@@ -256,7 +258,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3654012293200384530
+      hash: -2295219259305146267
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -265,7 +267,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3654012293200384530
+      hash: -2295219259305146267
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -288,7 +290,7 @@ test_files:
 - spec/fixtures/definitions/a_list_of_jams.rb
 - spec/fixtures/definitions/nested_folder/test_nested_process.rb
 - spec/fixtures/definitions/test_process.rb
-- spec/fixtures/entities/furby.rb
+- spec/fixtures/entities/rainbow_loom.rb
 - spec/integration/entity_spec.rb
 - spec/integration/example_configurations_spec.rb
 - spec/integration/history_storage_spec.rb
@@ -315,6 +317,7 @@ test_files:
 - spec/lib/bumbleworks/task_spec.rb
 - spec/lib/bumbleworks/tree_builder_spec.rb
 - spec/lib/bumbleworks/workitem_entity_storage_spec.rb
+- spec/lib/bumbleworks/workitem_spec.rb
 - spec/lib/bumbleworks_spec.rb
 - spec/spec_helper.rb
 - spec/support/path_helpers.rb