swarm 0.1.0

data/lib/swarm/expressions/branch_expression.rb

@@ -0,0 +1,44 @@
+require_relative "../router"
+
+module Swarm
+  class BranchExpression < Expression
+    class InvalidPositionError < StandardError; end;
+
+    def children
+      (child_ids || []).map { |child_id|
+        Expression.fetch(child_id, hive: hive)
+      }
+    end
+
+    def kick_off_children(at_positions)
+      at_positions.each do |at_position|
+        add_and_apply_child(at_position)
+      end
+      save
+    end
+
+    def add_and_apply_child(at_position)
+      new_child = add_child(at_position)
+      new_child.apply
+    end
+
+    def add_child(at_position)
+      node = tree[at_position]
+      raise InvalidPositionError unless node
+      expression = create_child_expression(node: node, at_position: at_position)
+      (self.child_ids ||= []) << expression.id
+      expression
+    end
+
+    def create_child_expression(node:, at_position:)
+      klass = Router.expression_class_for_node(node)
+      expression = klass.create(
+        :hive => hive,
+        :parent_id => id,
+        :position => position + [at_position],
+        :workitem => workitem,
+        :process_id => process_id
+      )
+    end
+  end
+end

data/lib/swarm/expressions/concurrence_expression.rb

@@ -0,0 +1,41 @@
+require_relative "branch_expression"
+
+module Swarm
+  class ConcurrenceExpression < BranchExpression
+    def work
+      kick_off_children(tree.each_index.to_a)
+    end
+
+    def replied_children
+      children.select(&:replied_at)
+    end
+
+    def ready_to_proceed?
+      required_replies = arguments.fetch("required_replies", nil)
+      return all_children_replied? unless required_replies
+      replied_children.count >= required_replies
+    end
+
+    def all_children_replied?
+      replied_children.count == tree.size
+    end
+
+    def move_on_from(child)
+      merge_child_workitem(child)
+      save
+      if all_children_replied?
+        reply
+      end
+    end
+
+    def merge_child_workitem(child)
+      self.workitem = Swarm::Support.deep_merge(
+        workitem, child.workitem, :combine_arrays => array_combination_method
+      )
+    end
+
+    def array_combination_method
+      arguments.fetch("combine_arrays", "uniq")
+    end
+  end
+end

data/lib/swarm/expressions/conditional_expression.rb

@@ -0,0 +1,36 @@
+require_relative "branch_expression"
+
+module Swarm
+  class ConditionalExpression < BranchExpression
+    alias_method :original_tree, :tree
+
+    def work
+      if tree.empty?
+        reply
+      else
+        kick_off_children([0])
+      end
+    end
+
+    def move_on_from(child)
+      self.workitem = child.workitem
+      reply
+    end
+
+    def tree
+      @tree ||= select_branch || []
+    end
+
+    def select_branch
+      if branch_condition_met?
+        original_tree["true"]
+      else
+        original_tree["false"]
+      end
+    end
+
+    def branch_condition_met?
+      evaluator.check_condition(command, arguments["condition"])
+    end
+  end
+end

data/lib/swarm/expressions/sequence_expression.rb

@@ -0,0 +1,16 @@
+require_relative "branch_expression"
+
+module Swarm
+  class SequenceExpression < BranchExpression
+    def work
+      kick_off_children([0])
+    end
+
+    def move_on_from(child)
+      self.workitem = child.workitem
+      kick_off_children([child.branch_position + 1])
+    rescue InvalidPositionError => e
+      reply
+    end
+  end
+end

data/lib/swarm/expressions/subprocess_expression.rb

@@ -0,0 +1,14 @@
+module Swarm
+  class SubprocessExpression < Expression
+    def work
+      definition = ProcessDefinition.find_by_name(arguments.fetch("name", nil))
+      raise Swarm::ProcessDefinition::RecordNotFoundError unless definition
+      process = definition.launch_process(workitem: workitem, parent_expression_id: id)
+    end
+
+    def move_on_from(process)
+      self.workitem = process.workitem
+      reply
+    end
+  end
+end

data/lib/swarm/hive.rb

@@ -0,0 +1,69 @@
+require_relative "storage"
+
+module Swarm
+  class Hive
+    class MissingTypeError < StandardError; end
+    class IllegalDefaultError < StandardError; end
+    class NoDefaultSetError < StandardError; end
+
+    class << self
+      def default=(default)
+        unless default.is_a?(self)
+          raise IllegalDefaultError.new("Default must be a Swarm::Hive")
+        end
+        @default = default
+      end
+
+      def default
+        unless @default
+          raise NoDefaultSetError.new("No default Hive defined yet")
+        end
+        @default
+      end
+    end
+
+    attr_reader :storage, :work_queue
+
+    def initialize(storage:, work_queue:)
+      @storage = storage
+      @work_queue = work_queue
+    end
+
+    def registered_observers
+      @registered_observers ||= []
+    end
+
+    def inspect
+      "#<Swarm::Hive storage: #{storage.backend.class}, work_queue: #{work_queue.name}>"
+    end
+
+    def traced
+      storage["trace"] ||= []
+    end
+
+    def trace(new_element)
+      storage["trace"] = traced + [new_element]
+    end
+
+    def queue(action, object)
+      @work_queue.add_job({
+        :action => action,
+        :metadata => object.to_hash
+      })
+    end
+
+    def fetch(klass, id)
+      Swarm::Support.constantize(klass).fetch(id, hive: self)
+    end
+
+    def reify_from_hash(hsh)
+      Support.symbolize_keys!(hsh)
+      raise MissingTypeError.new(hsh.inspect) unless hsh[:type]
+      Swarm::Support.constantize(hsh.delete(:type)).new_from_storage(
+        hsh.merge(
+          :hive => self
+        )
+      )
+    end
+  end
+end

data/lib/swarm/hive_dweller.rb

@@ -0,0 +1,170 @@
+module Swarm
+  class HiveDweller
+    class RecordNotFoundError < StandardError; end
+
+    attr_reader :hive, :id
+
+    def initialize(hive: Hive.default, **args)
+      @hive = hive
+      @changed_attributes = {}
+      set_attributes(args, record_changes: false)
+    end
+
+    def new?
+      id.nil?
+    end
+
+    def changed?
+      !@changed_attributes.empty?
+    end
+
+    def set_attributes(args, record_changes: true)
+      unknown_arguments = args.keys - self.class.columns
+      unless unknown_arguments.empty?
+        raise ArgumentError, "unknown keywords: #{unknown_arguments.join(', ')}"
+      end
+      args.each do |key, value|
+        change_attribute(key, value, record: record_changes)
+      end
+    end
+
+    def change_attribute(key, value, record: true)
+      if record
+        @changed_attributes[key] = [send(key), value]
+      end
+      instance_variable_set(:"@#{key}", value)
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.to_hash == to_hash
+    end
+
+    def storage_id
+      self.class.storage_id_for_key(id)
+    end
+
+    def storage
+      @hive.storage
+    end
+
+    def delete
+      storage.delete(storage_id)
+      self
+    end
+
+    def save
+      if new? || changed?
+        @id ||= Swarm::Support.uuid_with_timestamp
+        storage[storage_id] = to_hash
+      end
+      self
+    end
+
+    def attributes
+      self.class.columns.each_with_object({}) { |col_name, hsh|
+        hsh[col_name.to_sym] = send(:"#{col_name}")
+      }
+    end
+
+    def to_hash
+      hsh = {
+        :id => id,
+        :type => self.class.name
+      }
+      hsh.merge(attributes)
+    end
+
+    def reload!
+      hsh = hive.storage[storage_id]
+      self.class.columns.each do |column|
+        instance_variable_set(:"@#{column}", hsh[column.to_s])
+      end
+      self.class.associations.each do |type|
+        instance_variable_set(:"@#{type}", nil)
+      end
+      @changed_attributes = {}
+      self
+    end
+
+    class << self
+      include Enumerable
+
+      attr_reader :columns, :associations
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@columns, [])
+        subclass.instance_variable_set(:@associations, [])
+      end
+
+      def set_columns(*args)
+        attr_reader *args
+        args.each do |arg|
+          define_method("#{arg}=") { |value|
+            change_attribute(arg, value)
+          }
+        end
+        @columns = @columns | args
+      end
+
+      def many_to_one(type, class_name: nil)
+        define_method(type) do
+          memo = instance_variable_get(:"@#{type}")
+          memo || begin
+            key = self.send(:"#{type}_id")
+            return nil unless key
+            klass = Swarm::Support.constantize("#{class_name || type}")
+            instance_variable_set(:"@#{type}", klass.fetch(key, :hive => hive))
+          end
+        end
+        @associations << type
+      end
+
+      def create(hive: Hive.default, **args)
+        new(hive: hive, **args).save
+      end
+
+      def storage_type
+        name.split("::").last
+      end
+
+      def storage_id_for_key(key)
+        if key.match(/^#{storage_type}\:/)
+          key
+        else
+          "#{storage_type}:#{key}"
+        end
+      end
+
+      def new_from_storage(**args)
+        id = args.delete(:id)
+        new(**args).tap { |instance|
+          instance.instance_variable_set(:@id, id)
+        }
+      end
+
+      def fetch(key, hive: Hive.default)
+        hsh = hive.storage[storage_id_for_key(key)].dup
+        hive.reify_from_hash(hsh)
+      end
+
+      def ids(hive: Hive.default)
+        hive.storage.ids_for_type(storage_type)
+      end
+
+      def each(hive: Hive.default, subtypes: true, &block)
+        return to_enum(__method__, hive: hive, subtypes: subtypes) unless block_given?
+        ids(hive: hive).each do |id|
+          object = fetch(id, hive: hive)
+          if (subtypes && object.is_a?(self)) || object.class == self
+            yield object
+          end
+        end
+      end
+
+      def all(hive: Hive.default, subtypes: true)
+        to_a(hive: hive, subtypes: subtypes)
+      end
+    end
+  end
+end

data/lib/swarm/observers/base.rb

@@ -0,0 +1,17 @@
+module Swarm
+  module Observers
+    class Base
+      extend Forwardable
+
+      def_delegators :command, :action, :metadata, :object
+      attr_reader :command
+
+      def initialize(command)
+        @command = command
+      end
+
+      def before_action; end
+      def after_action; end
+    end
+  end
+end

data/lib/swarm/participant.rb

@@ -0,0 +1,18 @@
+module Swarm
+  class Participant
+    attr_reader :hive, :expression
+
+    def initialize(hive: Hive.default, expression:)
+      @hive = hive
+      @expression = expression
+    end
+
+    def workitem
+      expression.workitem
+    end
+
+    def arguments
+      expression.arguments
+    end
+  end
+end

data/lib/swarm/participants/storage_participant.rb

@@ -0,0 +1,12 @@
+require_relative "../participant"
+
+module Swarm
+  class StorageParticipant < Participant
+    def work
+      StoredWorkitem.create({
+        :hive => hive,
+        :expression_id => expression.id
+      })
+    end
+  end
+end

data/lib/swarm/participants/trace_participant.rb

@@ -0,0 +1,27 @@
+require_relative "../participant"
+
+module Swarm
+  class TraceParticipant < Participant
+    def work
+      if text
+        append_to_workitem_trace
+        append_to_hive_trace
+      end
+      expression.reply
+    end
+
+    def text
+      @text ||= arguments.fetch("text", nil)
+    end
+
+    def append_to_workitem_trace
+      traced = workitem["traced"] || []
+      traced << text
+      expression.workitem = workitem.merge("traced" => traced)
+    end
+
+    def append_to_hive_trace
+      hive.trace(text)
+    end
+  end
+end

data/lib/swarm/pollen/parser.rb

@@ -0,0 +1,95 @@
+require "parslet"
+
+module Swarm
+  module Pollen
+    class Parser < Parslet::Parser
+      def optionally_spaced(atom)
+        spaces? >> atom >> spaces?
+      end
+
+      rule(:eol) { (optionally_spaced(match['\n'])).repeat(1) }
+      rule(:whitespace) { match('\s').repeat(0) }
+      rule(:spaces) { match[' \t'].repeat(1) }
+      rule(:spaces?) { spaces.maybe }
+      rule(:comma) { optionally_spaced(str(',')) }
+
+      rule(:integer) {
+        match['0-9'].repeat(1).as(:integer)
+      }
+
+      rule(:float) {
+        (match['0-9'].repeat(1) >> str('.') >> match['0-9'].repeat(1)).as(:float)
+      }
+
+      rule(:line) {
+        (match['\n'].absent? >> any).repeat(1).as(:line)
+      }
+
+      rule(:string) {
+        (str("'") | str('"')).capture(:q) >>
+          (str('\\') >> any |
+            dynamic { |s,c| str(c.captures[:q]) }.absent? >> any
+          ).repeat.as(:string) >> dynamic { |s,c| str(c.captures[:q]) }
+      }
+
+      rule(:colon_pair) {
+        token.as(:key) >> str(':') >> spaces? >> string.as(:value)
+      }
+
+      rule(:symbol) { str(':') >> token.as(:symbol) }
+      rule(:token) { (match('[a-z_]') >> match('[a-zA-Z0-9_]').repeat(0)).as(:token) }
+
+      rule(:rocket_pair) {
+        (symbol | string).as(:key) >> optionally_spaced(str('=>')) >> string.as(:value)
+      }
+
+      rule(:key_value_pair) { rocket_pair | colon_pair }
+
+      rule(:key_value_list) {
+        key_value_pair >> (comma >> key_value_pair).repeat(0)
+      }
+
+      rule(:arguments) {
+        key_value_list.as(:arguments) | string.as(:text_argument)
+      }
+
+      rule(:reserved_word) {
+        %w(if unless else end).map { |w| str(w) }.reduce(:|)
+      }
+
+      rule(:expression) {
+        reserved_word.absent? >> token.as(:command) >> (spaces >> arguments).maybe
+      }
+
+      rule(:tree) {
+        ((conditional_block | branch_block | expression) >> eol).repeat(0)
+      }
+
+      rule(:conditional_block) {
+        (str('if') | str('unless')).as(:conditional) >>
+          spaces >> string.as(:conditional_clause) >> eol >>
+          tree.as(:true_tree) >>
+          (str('else') >> eol >> tree.as(:false_tree)).maybe >>
+        str('end')
+      }
+
+      rule(:branch_block) {
+        expression >> spaces >> str('do') >> eol >>
+          tree.as(:tree) >>
+          str('end')
+      }
+
+      rule(:metadata_entry) {
+        token.as(:key) >> str(':') >> spaces? >>
+          (string | float | integer | line).as(:value)
+      }
+
+      rule(:metadata) {
+        str('---') >> eol >> (metadata_entry >> eol).repeat(0) >> str('---') >> eol
+      }
+
+      rule(:document) { whitespace >> metadata.maybe.as(:metadata) >> branch_block.as(:tree) >> whitespace }
+      root(:document)
+    end
+  end
+end

data/lib/swarm/pollen/reader.rb

@@ -0,0 +1,22 @@
+require_relative "parser"
+require_relative "transformer"
+
+module Swarm
+  module Pollen
+    class Reader
+      def initialize(pollen)
+        @pollen = pollen
+      end
+
+      def to_hash
+        Transformer.new.apply(
+          Parser.new.parse(@pollen, :reporter => Parslet::ErrorReporter::Deepest.new)
+        )
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+    end
+  end
+end

data/lib/swarm/pollen/transformer.rb

@@ -0,0 +1,66 @@
+require "parslet"
+
+module Swarm
+  module Pollen
+    class Transformer < Parslet::Transform
+      class << self
+        def transform_arguments(args)
+          if args.is_a?(Array) && !args.empty?
+            args.reduce(:merge)
+          else
+            args
+          end
+        end
+      end
+
+      rule(:symbol => simple(:sym)) { sym.to_s }
+      rule(:token => simple(:token)) { token.to_s }
+      rule(:string => simple(:st)) { st.to_s }
+      rule(:line => simple(:line)) { line.to_s }
+      rule(:float => simple(:float)) { float.to_f }
+      rule(:integer => simple(:int)) { int.to_i }
+
+      rule(:key => simple(:key), :value => simple(:value)) {
+        { key => value }
+      }
+      rule(:conditional => simple(:conditional), :conditional_clause => simple(:clause), :true_tree => subtree(:true_tree), :false_tree => subtree(:false_tree)) {
+        [conditional.to_s, { "condition" => clause }, {
+          "true" => [
+            ["sequence", {}, true_tree]
+          ],
+          "false" => [
+            ["sequence", {}, false_tree]
+          ],
+        }]
+      }
+
+      rule(:conditional => simple(:conditional), :conditional_clause => simple(:clause), :true_tree => subtree(:true_tree)) {
+        [conditional.to_s, { "condition" => clause }, {
+          "true" => [
+            ["sequence", {}, true_tree]
+          ]
+        }]
+      }
+
+      rule(:command => simple(:command)) {
+        [command.to_s, {}, []]
+      }
+      rule(:command => simple(:command), :tree => subtree(:tree)) {
+        [command.to_s, {}, tree]
+      }
+      rule(:command => simple(:command), :arguments => subtree(:args)) { |captures|
+        [captures[:command].to_s, transform_arguments(captures[:args]), []]
+      }
+      rule(:command => simple(:command), :arguments => subtree(:args), :tree => subtree(:tree)) { |captures|
+        [captures[:command].to_s, transform_arguments(captures[:args]), captures[:tree]]
+      }
+      rule(:command => simple(:command), :text_argument => simple(:ta)) {
+        [command.to_s, { "text" => ta }, []]
+      }
+      rule(:metadata => subtree(:metadata), :tree => subtree(:tree)) { |captures|
+        metadata = (captures[:metadata] || {}).reduce(:merge)
+        (metadata || {}).merge("definition" => captures[:tree])
+      }
+    end
+  end
+end