bumbleworks 0.0.66 → 0.0.67

data/lib/bumbleworks/task/finder.rb

@@ -1,45 +1,67 @@
 module Bumbleworks
   class Task
     class Finder
+      class WorkitemQuery < Proc; end
+      class TaskQuery < Proc; end
+
+      WhereKeyToMethodMap = {
+        :available => :available,
+        :unavailable => :unavailable,
+        :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
+      }
+
       include Enumerable
 
       def initialize(task_class = Bumbleworks::Task)
         @task_class = task_class
         @queries = []
-        @task_filters = []
         @orderers = []
         @wfids = nil
-        add_query { |wi| wi['fields']['params']['task'] }
-      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)
+        @join = :all
+      end
+
+      def where_any(query_group = {})
+        set_join_for_query_group(query_group, :any)
+      end
+
+      def where_all(query_group = {})
+        set_join_for_query_group(query_group, :all)
+      end
+
+      def where(filters, group_type = nil)
+        group_type = :all unless group_type == :any
+        new_finder = self.class.new(@task_class)
+        new_finder.send(:"where_#{group_type}")
+        new_finder = filters.inject(new_finder) { |finder, (key, args)|
+          if method = WhereKeyToMethodMap[key]
+            finder.send(method, args)
+          else
+            finder.with_fields(key => args)
+          end
         }
-        unless fields.empty?
-          query.with_fields(fields)
+        add_subfinder new_finder
+      end
+
+      def available(check = true)
+        if check
+          where_all(:unclaimed => true, :completable => true)
+        else
+          where_any(:claimed => true, :completable => false)
         end
-        query
       end
 
-      def available
-        unclaimed.completable
+      def unavailable(check = true)
+        available(!check)
       end
 
       def by_nickname(nickname)
@@ -48,6 +70,7 @@ module Bumbleworks
 
       def for_roles(identifiers)
         identifiers ||= []
+        identifiers.map! { |i| i.to_s }
         add_query { |wi| identifiers.include?(wi['participant_name']) }
       end
 
@@ -110,13 +133,18 @@ module Bumbleworks
         add_filter { |task| task.completable? == true_or_false }
       end
 
+      def add_subfinder(finder)
+        @queries << finder
+        self
+      end
+
       def add_query(&block)
-        @queries << block
+        @queries << WorkitemQuery.new(&block)
         self
       end
 
       def add_filter(&block)
-        @task_filters << block
+        @queries << TaskQuery.new(&block)
         self
       end
 
@@ -155,10 +183,14 @@ module Bumbleworks
         !any?
       end
 
+      def check_queries(workitem, task)
+        grouped_queries(@join).call(workitem, task)
+      end
+
     private
 
       def add_orderer(fields, field_type = 'fields')
-        @orderers << proc { |wi_x, wi_y|
+        @orderers << Proc.new { |wi_x, wi_y|
           relevant_direction, result = :asc, 0
           fields.each do |field, direction|
             sets = [wi_x['fields'], wi_y['fields']]
@@ -173,14 +205,25 @@ module Bumbleworks
       end
 
       def filtered_task_from_raw_workitem(workitem)
-        if @queries.all? { |q| q.call(workitem) }
-          task = from_workitem(::Ruote::Workitem.new(workitem))
-          task if check_filters(task)
-        end
-      end
-
-      def check_filters(task)
-        @task_filters.all? { |f| f.call(task) }
+        task = from_workitem(::Ruote::Workitem.new(workitem))
+        task if check_queries(workitem, task)
+      end
+
+      def grouped_queries(group_type)
+        Proc.new { |wi, task|
+          @queries.send(:"#{group_type}?") { |q|
+            case q
+            when WorkitemQuery
+              q.call(wi)
+            when TaskQuery
+              q.call(task)
+            when self.class
+              q.check_queries(wi, task)
+            else
+              raise "Unrecognized query type"
+            end
+          }
+        }
       end
 
       def from_workitem(workitem)
@@ -188,7 +231,22 @@ module Bumbleworks
       end
 
       def raw_workitems(wfids)
-        Bumbleworks.dashboard.context.storage.get_many('workitems', wfids)
+        Bumbleworks.dashboard.context.storage.get_many('workitems', wfids).select { |wi|
+          wi['fields']['params']['task']
+        }
+      end
+
+      def join=(new_join)
+        @join = new_join if [:all, :any].include?(new_join)
+      end
+
+      def set_join_for_query_group(query_group, type)
+        if query_group.empty?
+          self.join = type
+          self
+        else
+          where(query_group, type)
+        end
       end
     end
   end

data/lib/bumbleworks/version.rb

@@ -1,3 +1,3 @@
 module Bumbleworks
-  VERSION = "0.0.66"
+  VERSION = "0.0.67"
 end

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

@@ -14,6 +14,15 @@ describe Bumbleworks::Task::Finder do
     end
   end
 
+  describe '#check_queries' do
+    it 'raises an exception in case a query type is unrecognized' do
+      subject.instance_variable_set(:@queries, ['not a real query'])
+      expect {
+        subject.check_queries(:wi, :task)
+      }.to raise_error("Unrecognized query type")
+    end
+  end
+
   describe '#add_query' do
     it 'adds given block as new raw workitem query' do
       Bumbleworks.launch!('dog-lifecycle')
@@ -44,6 +53,19 @@ describe Bumbleworks::Task::Finder do
     end
   end
 
+  describe '#add_subfinder' do
+    it 'adds given finder as new sub' do
+      Bumbleworks.launch!('dog-lifecycle')
+      Bumbleworks.dashboard.wait_for(:cat)
+      finder = subject.add_subfinder(
+        Bumbleworks::Task::Finder.new.for_role(:cat)
+      )
+      finder.map(&:nickname).should =~ [
+        'skip_and_jump'
+      ]
+    end
+  end
+
   describe '#all' do
     it 'uses Bumbleworks::Task class by default for task generation' do
       Bumbleworks.launch!('dog-lifecycle')
@@ -64,26 +86,64 @@ describe Bumbleworks::Task::Finder do
 
   describe '#available' do
     it 'adds both unclaimed and completable filters' do
-      subject.should_receive(:unclaimed).and_return(subject)
-      subject.should_receive(:completable).and_return(subject)
+      subject.should_receive(:where_all).with(:unclaimed => true, :completable => true).and_return(subject)
       subject.available
     end
+
+    it 'adds OR-ed claimed and not-completable filters if passed false' do
+      subject.should_receive(:where_any).with(:claimed => true, :completable => false).and_return(subject)
+      subject.available(false)
+    end
+  end
+
+  describe '#unavailable' do
+    it 'checks if not available' do
+      subject.should_receive(:available).with(false).and_return(subject)
+      subject.unavailable
+    end
+
+    it 'checks if available when passed false' do
+      subject.should_receive(:available).with(true).and_return(subject)
+      subject.unavailable(false)
+    end
+  end
+
+  [:all, :any].each do |join_type|
+    describe "#where_#{join_type}" do
+      it "sets join to #{join_type} if no args" do
+        subject.should_receive(:join=).with(join_type)
+        subject.send(:"where_#{join_type}")
+      end
+
+      it "calls where with :#{join_type} type if args" do
+        subject.should_receive(:where).with(:filters, join_type)
+        subject.send(:"where_#{join_type}", :filters)
+      end
+    end
   end
 
   describe '#where' do
-    it 'compiles a finder' do
-      subject.should_receive(:available).and_return(subject)
-      subject.should_receive(:by_nickname).with(:nicholas).and_return(subject)
-      subject.should_receive(:for_roles).with([:dinner, :barca]).and_return(subject)
-      subject.should_receive(:unclaimed).and_return(subject)
-      subject.should_receive(:claimed).and_return(subject)
-      subject.should_receive(:for_claimant).with(:dr_clam).and_return(subject)
-      subject.should_receive(:for_entity).with(:a_luffly_pirate).and_return(subject)
-      subject.should_receive(:for_processes).with([:jasmine, :mulan]).and_return(subject)
-      subject.should_receive(:completable).with(true).and_return(subject)
-      subject.should_receive(:with_fields).with({ :horse => :giant_pony, :pie => :silly_cake }).and_return(subject)
-      subject.where({
+    it 'creates a new finder and adds it to queries' do
+      parent = described_class.new(:a_class)
+      child = described_class.new
+      described_class.stub(:new).with(:a_class).and_return(child)
+      child.should_receive(:where_all)
+      child.should_receive(:available).and_return(child)
+      child.should_receive(:unavailable).and_return(child)
+      child.should_receive(:by_nickname).with(:nicholas).and_return(child)
+      child.should_receive(:for_roles).with([:dinner, :barca]).and_return(child)
+      child.should_receive(:unclaimed).and_return(child)
+      child.should_receive(:claimed).and_return(child)
+      child.should_receive(:for_claimant).with(:dr_clam).and_return(child)
+      child.should_receive(:for_entity).with(:a_luffly_pirate).and_return(child)
+      child.should_receive(:for_processes).with([:jasmine, :mulan]).and_return(child)
+      child.should_receive(:completable).with(true).and_return(child)
+      child.should_receive(:with_fields).with(:horse => :giant_pony).and_return(child)
+      child.should_receive(:with_fields).with(:pie => :silly_cake).and_return(child)
+      parent.should_receive(:add_subfinder).with(child)
+      parent.where({
         :available => true,
+        :unavailable => true,
         :nickname => :nicholas,
         :roles => [:dinner, :barca],
         :unclaimed => true,

data/spec/lib/bumbleworks/task_spec.rb

@@ -335,7 +335,15 @@ describe Bumbleworks::Task do
     it 'returns tasks for all given roles' do
       Bumbleworks.dashboard.wait_for(:father)
       tasks = described_class.for_roles(['heckler', 'mother'])
-      tasks.should have(2).items
+      tasks.map(&:nickname).should == [
+        'comment_on_dancing_ability',
+        'ignore_pleas_for_attention'
+      ]
+    end
+
+    it 'works with symbolized role names' do
+      Bumbleworks.dashboard.wait_for(:father)
+      tasks = described_class.for_roles([:heckler, :mother])
       tasks.map(&:nickname).should == [
         'comment_on_dancing_ability',
         'ignore_pleas_for_attention'
@@ -600,7 +608,7 @@ describe Bumbleworks::Task do
       described_class.new(workflow_item).nickname.should == 'go_to_work'
     end
 
-    it 'is immutable; cannot be changed by modified the param' do
+    it 'is immutable; cannot be changed by modifying the param' do
       task = described_class.new(workflow_item)
       task.nickname.should == 'go_to_work'
       task.params['task'] = 'what_is_wrong_with_you?'
@@ -923,7 +931,7 @@ describe Bumbleworks::Task do
   end
 
   describe 'chained queries' do
-    it 'allows for AND-ed chained finders' do
+    before(:each) do
       module BeProudTask
         def completable?
           role == 'pink'
@@ -945,33 +953,51 @@ describe Bumbleworks::Task do
       described_class.by_nickname('be_really_mad').first.claim('crayon_box')
       described_class.by_nickname('be_a_bit_sad').first.claim('crayon_box')
       described_class.by_nickname('be_scared').first.claim('crayon_box')
+    end
 
+    it 'allows for AND-ed chained finders' do
       tasks = described_class.
         for_roles(['green', 'pink']).
         by_nickname('be_proud')
-      tasks.should have(2).items
       tasks.map(&:nickname).should =~ ['be_proud', 'be_proud']
 
       tasks = described_class.
         for_roles(['green', 'pink', 'blue']).
         completable.
         by_nickname('be_proud')
-      tasks.should have(1).items
       tasks.map(&:nickname).should =~ ['be_proud']
       tasks.first.role.should == 'pink'
 
       tasks = described_class.
         for_claimant('crayon_box').
         for_roles(['red', 'yellow', 'green'])
-      tasks.should have(2).items
       tasks.map(&:nickname).should =~ ['be_really_mad', 'be_scared']
 
       tasks = described_class.
         for_claimant('crayon_box').
         by_nickname('be_a_bit_sad').
         for_role('blue')
-      tasks.should have(1).item
-      tasks.first.nickname.should == 'be_a_bit_sad'
+      tasks.map(&:nickname).should == ['be_a_bit_sad']
+    end
+
+    it 'allows for OR-ed chained finders' do
+      tasks = described_class.where_any.
+        for_role('blue').
+        by_nickname('be_proud')
+      tasks.map(&:nickname).should =~ ['be_a_bit_sad', 'be_proud', 'be_proud']
+
+      tasks = described_class.where_any.
+        completable.
+        claimed
+      tasks.map(&:nickname).should =~ ['be_really_mad', 'be_scared', 'be_a_bit_sad', 'be_envious', 'be_proud']
+    end
+
+    it 'allows for combination of AND-ed and OR-ed finders' do
+      tasks = described_class.
+        for_claimant('crayon_box').
+        for_roles(['red', 'yellow', 'green']).
+        where_any(:nickname => 'spittle', :role => 'red')
+      tasks.map(&:nickname).should =~ ['be_really_mad']
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bumbleworks
 version: !ruby/object:Gem::Version
-  version: 0.0.66
+  version: 0.0.67
   prerelease: 
 platform: ruby
 authors:
@@ -263,7 +263,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2932416293581742499
+      hash: -828437829805338939
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -272,7 +272,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2932416293581742499
+      hash: -828437829805338939
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23