bumbleworks 0.0.4

data/lib/bumbleworks/ruote.rb

@@ -0,0 +1,64 @@
+require "ruote"
+
+module Bumbleworks
+  class Ruote
+    class << self
+      def dashboard(options = {})
+        @dashboard ||= begin
+          context = if Bumbleworks.autostart_worker || options[:start_worker] == true
+            ::Ruote::Worker.new(storage)
+          else
+            storage
+          end
+          ::Ruote::Dashboard.new(context)
+        end
+      end
+
+      def start_worker!(options = {})
+        @dashboard = nil
+        dashboard(:start_worker => true)
+        dashboard.join if options[:join] == true
+        dashboard.worker
+      end
+
+      def launch(name, options)
+        dashboard.launch(dashboard.variables[name], options)
+      end
+
+      def register_participants(&block)
+        dashboard.register(&block) if block
+        set_catchall_if_needed
+        dashboard.participant_list
+      end
+
+      def set_catchall_if_needed
+        last_participant = dashboard.participant_list.last
+        unless last_participant && last_participant.regex == "^.+$" && last_participant.classname == "Ruote::StorageParticipant"
+          catchall = ::Ruote::ParticipantEntry.new(["^.+$", ["Ruote::StorageParticipant", {}]])
+          dashboard.participant_list = dashboard.participant_list.push(catchall)
+        end
+      end
+
+      def storage
+        @storage ||= begin
+          all_adapters = Bumbleworks.configuration.storage_adapters
+          adapter = all_adapters.detect do |adapter|
+            adapter.use?(Bumbleworks.storage)
+          end
+          raise UndefinedSetting, "Storage is missing or not supported.  Supported: #{all_adapters.map(&:display_name).join(', ')}" unless adapter
+          adapter.driver.new(Bumbleworks.storage)
+        end
+      end
+
+      def reset!
+        if @storage
+          @storage.purge!
+          @storage.shutdown
+        end
+        @dashboard.shutdown if @dashboard && @dashboard.respond_to?(:shutdown)
+        @storage = nil
+        @dashboard = nil
+      end
+    end
+  end
+end

data/lib/bumbleworks/storage_adapter.rb

@@ -0,0 +1,23 @@
+module Bumbleworks
+  class StorageAdapter
+    class << self
+      attr_accessor :auto_register
+
+      def auto_register?
+        auto_register.nil? || auto_register == true
+      end
+
+      def driver
+        raise "Subclass responsibility"
+      end
+
+      def use?(storage)
+        storage.class.name =~ /^#{display_name}/
+      end
+
+      def display_name
+        raise "Subclass responsibility"
+      end
+    end
+  end
+end

data/lib/bumbleworks/support.rb

@@ -0,0 +1,20 @@
+module Bumbleworks
+  # Support methods for utility functionality such as string modification -
+  # could also be accomplished by monkey-patching String class.
+  module Support
+    module_function
+
+    def camelize(string)
+      string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+      string = string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+    end
+
+    def all_files(directory, options = {})
+      Dir["#{directory}/**/*.rb"].each do |path|
+        name = File.basename(path, '.rb')
+        name = camelize(name) if options[:camelize] == true
+        yield path, name
+      end
+    end
+  end
+end

data/lib/bumbleworks/task.rb

@@ -0,0 +1,109 @@
+module Bumbleworks
+  class Task
+    class AlreadyClaimed < StandardError; end
+    class MissingWorkitem < StandardError; end
+
+    extend Forwardable
+    delegate [:sid, :fei, :fields, :params, :participant_name, :wfid, :wf_name] => :@workitem
+    attr_reader :nickname
+    alias_method :id, :sid
+
+    class << self
+      def for_role(identifier)
+        for_roles([identifier])
+      end
+
+      def for_roles(identifiers)
+        return [] unless identifiers.is_a?(Array)
+        workitems = identifiers.collect { |identifier|
+          storage_participant.by_participant(identifier)
+        }.flatten.uniq
+        from_workitems(workitems)
+      end
+
+      def all
+        from_workitems(storage_participant.all)
+      end
+
+      def find_by_id(sid)
+        workitem = storage_participant[sid] if sid
+        raise MissingWorkitem unless workitem
+        new(workitem)
+      rescue ArgumentError => e
+        raise MissingWorkitem, e.message
+      end
+
+      def storage_participant
+        Bumbleworks.dashboard.storage_participant
+      end
+
+      def from_workitems(workitems)
+        workitems.map { |wi|
+          new(wi) if wi.params['task']
+        }.compact
+      end
+    end
+
+    def initialize(workitem)
+      @workitem = workitem
+      unless workitem && workitem.is_a?(::Ruote::Workitem)
+        raise ArgumentError, "Not a valid workitem"
+      end
+      @nickname = params['task']
+    end
+
+    # alias for fields[] (fields delegated to workitem)
+    def [](key)
+      fields[key]
+    end
+
+    # alias for fields[]= (fields delegated to workitem)
+    def []=(key, value)
+      fields[key] = value
+    end
+
+    def role
+      participant_name
+    end
+
+    # update workitem with changes to fields & params
+    def save
+      storage_participant.update(@workitem)
+    end
+
+    # proceed workitem (saving changes to fields)
+    def complete
+      storage_participant.proceed(@workitem)
+    end
+
+    # Claim task and assign token to claim
+    def claim(token)
+      if token && claimant && token != claimant
+        raise AlreadyClaimed, "Already claimed by #{claimant}"
+      end
+
+      params['claimant'] = token
+      save
+    end
+
+    # Token used to claim task, nil if not claimed
+    def claimant
+      params['claimant']
+    end
+
+    # true if task is claimed
+    def claimed?
+      !claimant.nil?
+    end
+
+    # release claim on task.
+    def release
+      claim(nil)
+    end
+
+    private
+    def storage_participant
+      self.class.storage_participant
+    end
+  end
+end

data/lib/bumbleworks/tree_builder.rb

@@ -0,0 +1,60 @@
+require "ruote"
+require "ruote/reader"
+
+module Bumbleworks
+  class TreeBuilder
+    class InvalidTree < StandardError; end
+
+    attr_reader :tree, :name
+
+    def initialize(options)
+      @forced_name = options[:name]
+      @definition = options[:definition]
+      @tree = options[:tree]
+      unless !!@definition ^ !!@tree
+        raise ArgumentError, "Must specify either definition or tree (not both)" 
+      end
+    end
+
+    def build!
+      initialize_tree_from_definition! unless @tree
+      if @name = name_from_tree
+        @forced_name ||= name
+        raise InvalidTree, "Name does not match name in definition" if @forced_name != @name
+        @tree[1].delete(@tree[1].keys.first)
+      end
+      @name = @forced_name
+      add_name_to_tree!
+      @tree
+    rescue ::Ruote::Reader::Error => e
+      raise InvalidTree, e.message
+    end
+
+    class << self
+      def from_definition(*args, &block)
+        tree = ::Ruote.define *args, &block
+        builder = new(:tree => tree)
+      end
+    end
+
+  private
+
+    def initialize_tree_from_definition!
+      converted = @definition.strip.gsub(/^Bumbleworks.define_process/, 'Ruote.define')
+      @tree = ::Ruote::Reader.read(converted)
+    end
+
+    def name_from_tree
+      first_key, first_value = @tree[1].first
+      name_from_tree = if first_key == 'name'
+        first_value
+      elsif first_value.nil?
+        first_key
+      end
+    end
+
+    def add_name_to_tree!
+      @tree[1] = { "name" => @name }.merge(@tree[1])
+    end
+  end
+end

data/lib/bumbleworks/version.rb

@@ -0,0 +1,3 @@
+module Bumbleworks
+  VERSION = "0.0.4"
+end

data/spec/fixtures/apps/with_default_directories/app/participants/honey_participant.rb

@@ -0,0 +1,3 @@
+class HoneyParticipant
+
+end

data/spec/fixtures/apps/with_default_directories/app/participants/molasses_participant.rb

@@ -0,0 +1,3 @@
+class MolassesParticipant
+
+end

data/spec/fixtures/apps/with_default_directories/config_initializer.rb

@@ -0,0 +1,4 @@
+Bumbleworks.configure! do |c|
+  c.root = File.dirname(__FILE__)
+  c.storage = {}
+end

data/spec/fixtures/apps/with_default_directories/full_initializer.rb

@@ -0,0 +1,12 @@
+Bumbleworks.configure! do |c|
+  c.root = File.dirname(__FILE__)
+  c.storage = {}
+  c.autostart_worker = true
+end
+
+Bumbleworks.register_participants do
+  honey_maker    HoneyParticipant
+  molasses_maker MolassesParticipant
+end
+
+Bumbleworks.start!

data/spec/fixtures/apps/with_default_directories/lib/process_definitions/garbage_collector.rb

@@ -0,0 +1,3 @@
+Bumbleworks.define_process 'garbage_collector' do
+  george :ref => 'garbage collector'
+end

data/spec/fixtures/apps/with_default_directories/lib/process_definitions/make_honey.rb

@@ -0,0 +1,3 @@
+Bumbleworks.define_process 'make_honey' do
+  dave :task => 'make_some_honey'
+end

data/spec/fixtures/apps/with_default_directories/lib/process_definitions/make_molasses.rb

@@ -0,0 +1,6 @@
+Bumbleworks.define_process 'make_molasses' do
+  concurrence do
+    dave :task => 'make_some_molasses'
+    sam :task => 'taste_that_molasses'
+  end
+end

data/spec/fixtures/apps/with_specified_directories/config_initializer.rb

@@ -0,0 +1,5 @@
+Bumbleworks.configure! do |c|
+  c.root = File.dirname(__FILE__)
+  c.definitions_directory = 'specific_directory/definitions'
+  c.participants_directory = 'specific_directory/participants'
+end

data/spec/fixtures/definitions/a_list_of_jams.rb

@@ -0,0 +1,4 @@
+raise "Haha I tricked you"
+Raspberry
+Traffic
+Def

data/spec/fixtures/definitions/nested_folder/test_nested_process.rb

@@ -0,0 +1,3 @@
+Bumbleworks.define_process do
+  nothing_nested
+end

data/spec/fixtures/definitions/test_process.rb

@@ -0,0 +1,5 @@
+
+Bumbleworks.define_process 'test_process' do
+  nothing
+end
+

data/spec/integration/configuration_spec.rb

@@ -0,0 +1,43 @@
+describe Bumbleworks::Configuration do
+  let(:specified_app_path) { File.join(fixtures_path, 'apps', 'with_specified_directories') }
+  let(:default_app_path) { File.join(fixtures_path, 'apps', 'with_default_directories') }
+  let(:specified_initializer) { File.join(specified_app_path, 'config_initializer.rb') }
+  let(:default_initializer) { File.join(default_app_path, 'config_initializer.rb') }
+
+  describe '#root' do
+    it 'returns configured root' do
+      load default_initializer
+      Bumbleworks.root.should == default_app_path
+    end
+  end
+
+  describe '#definitions_directory' do
+    it 'returns specified directory when set in configuration' do
+      load specified_initializer
+      Bumbleworks.definitions_directory.should == File.join(specified_app_path, 'specific_directory', 'definitions')
+    end
+
+    it 'returns default directory when not set in configuration' do
+      load default_initializer
+      Bumbleworks.definitions_directory.should == File.join(default_app_path, 'lib', 'process_definitions')
+    end
+  end
+
+  describe '#participants_directory' do
+    it 'returns specified directory when set in configuration' do
+      load specified_initializer
+      Bumbleworks.participants_directory.should == File.join(specified_app_path, 'specific_directory', 'participants')
+    end
+
+    it 'returns default directory when not set in configuration' do
+      load default_initializer
+      Bumbleworks.participants_directory.should == File.join(default_app_path, 'app', 'participants')
+    end
+
+    it 'returns second default directory if first not found' do
+      load default_initializer
+      Bumbleworks.root = File.join(default_app_path, 'app')
+      Bumbleworks.participants_directory.should == File.join(default_app_path, 'app', 'participants')
+    end
+  end
+end

data/spec/integration/sample_application_spec.rb

@@ -0,0 +1,45 @@
+describe 'Bumbleworks Sample Application' do
+  describe 'initializer' do
+    let(:app_root) {
+      File.expand_path(File.join(fixtures_path, 'apps', 'with_default_directories'))
+    }
+
+    before :each do
+      Bumbleworks.reset!
+      load File.join(app_root, 'full_initializer.rb')
+    end
+
+    it 'registers participants' do
+      Bumbleworks.dashboard.participant_list.should have(3).items
+      Bumbleworks.dashboard.participant_list.map(&:classname).should =~ ['HoneyParticipant', 'MolassesParticipant', 'Ruote::StorageParticipant']
+    end
+
+    it 'loads process definitions' do
+      Bumbleworks.dashboard.variables['make_honey'].should == ["define",
+        {"name"=>"make_honey"}, [["dave", {"task"=>"make_some_honey"}, []]]]
+      Bumbleworks.dashboard.variables['garbage_collector'].should == ["define",
+        {"name"=>"garbage_collector"}, [["george", {"ref"=>"garbage collector"}, []]]]
+
+      Bumbleworks.dashboard.variables['make_molasses'].should == ["define",
+        {"name"=>"make_molasses"},
+        [["concurrence",
+          {},
+          [["dave", {"task"=>"make_some_molasses"}, []], ["sam", {"task"=>"taste_that_molasses"}, []]]]]]
+    end
+
+    it 'automatically starts engine and waits for first task in catchall participant' do
+      Bumbleworks.launch!('make_honey')
+      Bumbleworks.dashboard.wait_for(:dave)
+      Bumbleworks::Task.all.should have(1).item
+    end
+
+    it 'automatically starts engine and waits for first task in catchall participant' do
+      Bumbleworks.launch!('make_molasses')
+      Bumbleworks.dashboard.wait_for(:dave)
+      Bumbleworks::Task.all.should have(2).item
+      Bumbleworks::Task.for_role('dave').should have(1).item
+      Bumbleworks::Task.for_role('sam').should have(1).item
+    end
+  end
+end
+