swarm 0.2.0 → 0.4.0

data/lib/swarm/hive_dweller.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module Swarm
   class HiveDweller
+    class MissingTypeError < StandardError; end
     class RecordNotFoundError < StandardError; end
 
     attr_reader :hive, :id
@@ -23,6 +26,7 @@ module Swarm
       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
@@ -55,7 +59,7 @@ module Swarm
     def save
       if new? || changed?
         @id ||= Swarm::Support.uuid_with_timestamp
-        storage[storage_id] = to_hash.merge(:updated_at => Time.now)
+        storage[storage_id] = to_hash.merge(updated_at: Time.now)
         reload!
       end
       self
@@ -69,8 +73,8 @@ module Swarm
 
     def to_hash
       hsh = {
-        :id => id,
-        :type => self.class.name
+        id: id,
+        type: self.class.name
       }
       hsh.merge(attributes)
     end
@@ -80,8 +84,8 @@ module Swarm
       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)
+      self.class.associations.each_key do |name|
+        instance_variable_set(:"@#{name}", nil)
       end
       @changed_attributes = {}
       self
@@ -95,38 +99,70 @@ module Swarm
       def inherited(subclass)
         super
         subclass.instance_variable_set(:@columns, [])
-        subclass.instance_variable_set(:@associations, [])
+        subclass.instance_variable_set(:@associations, {})
         subclass.set_columns :updated_at, :created_at
       end
 
       def set_columns(*args)
         args.each do |arg|
-          define_method("#{arg}=") { |value|
-            change_attribute(arg, value)
-          }
-
-          define_method(arg) {
-            val = instance_variable_get(:"@#{arg}")
-            if /_at$/.match(arg) && val.is_a?(String)
-              val = Time.parse(val)
-            end
-            val
-          }
+          define_setter(arg)
+          define_getter(arg)
+        end
+        @columns |= args
+      end
+
+      def define_setter(arg)
+        define_method("#{arg}=") do |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}")
+      def define_getter(arg)
+        define_method(arg) {
+          val = instance_variable_get(:"@#{arg}")
+          if /_at$/.match(arg) && val.is_a?(String)
+            val = Time.parse(val)
+          end
+          val
+        }
+      end
+
+      def one_to_many(association_name, class_name: nil, foreign_key: nil)
+        define_method(association_name) do
+          memo = instance_variable_get(:"@#{association_name}")
           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))
+            associations = hive.storage.load_associations(
+              association_name, owner: self, class_name: class_name || association_name, foreign_key: foreign_key
+            )
+            entities = associations.map { |association| self.class.reify_from_hash(association, hive: hive) }
+            instance_variable_set(:"@#{association_name}", entities)
           end
         end
-        @associations << type
+        define_method(:"add_to_#{association_name}") do |associated|
+          hive.storage.add_association(
+            association_name, associated, owner: self, class_name: class_name || association_name, foreign_key: foreign_key
+          )
+        end
+        @associations[association_name] = {
+          type: :one_to_many, class_name: class_name || association_name, foreign_key: foreign_key
+        }
+      end
+
+      def many_to_one(association_name, class_name: nil, key: nil)
+        define_method(association_name) do
+          memo = instance_variable_get(:"@#{association_name}")
+          memo || begin
+            key ||= :"#{association_name}_id"
+            associated_id = send(key)
+            return nil unless associated_id
+
+            klass = Swarm::Support.constantize((class_name || association_name).to_s)
+            instance_variable_set(:"@#{association_name}", klass.fetch(associated_id, hive: hive))
+          end
+        end
+        @associations[association_name] = {
+          type: :many_to_one, class_name: class_name || association_name, key: key
+        }
       end
 
       def create(hive: Hive.default, **args)
@@ -138,7 +174,7 @@ module Swarm
       end
 
       def storage_id_for_key(key)
-        if key.match(/^#{storage_type}\:/)
+        if key.match(/^#{storage_type}:/)
           key
         else
           "#{storage_type}:#{key}"
@@ -154,25 +190,37 @@ module Swarm
 
       def fetch(key, hive: Hive.default)
         hsh = hive.storage[storage_id_for_key(key)].dup
-        hive.reify_from_hash(hsh)
+        reify_from_hash(hsh, hive: hive)
       end
 
       def ids(hive: Hive.default)
         hive.storage.ids_for_type(storage_type)
       end
 
-      def each(hive: Hive.default, subtypes: true, &block)
+      def each(hive: Hive.default, subtypes: true)
         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
+          if (subtypes && object.is_a?(self)) || object.instance_of?(self)
             yield object
           end
         end
       end
 
       def all(hive: Hive.default, subtypes: true)
-        to_a(hive: hive, subtypes: subtypes)
+        hive.storage.all_of_type(storage_type, subtypes: subtypes).map { |hsh|
+          reify_from_hash(hsh.dup, hive: hive)
+        }
+      end
+
+      def reify_from_hash(hsh, hive: Hive.default)
+        Support.symbolize_keys!(hsh)
+        raise MissingTypeError, hsh.inspect unless hsh[:type]
+
+        Swarm::Support.constantize(hsh.delete(:type)).new_from_storage(
+          **hsh.merge(hive: hive)
+        )
       end
     end
   end

data/lib/swarm/observers/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Swarm
   module Observers
     class Base
@@ -14,4 +16,4 @@ module Swarm
       def after_action; end
     end
   end
-end
+end

data/lib/swarm/observers/logger.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Swarm
+  module Observers
+    class Logger < Base
+      attr_reader :initial_workitem
+
+      def before_action
+        return unless object
+
+        @initial_workitem = object.workitem
+      end
+
+      def log_entry
+        "[#{Time.now}]: #{action}; #{object_string}"
+      end
+
+      def after_action
+        puts log_entry
+      end
+
+      def object_string
+        return "No object" unless object
+
+        object.reload!
+        string = if object.is_a?(Swarm::Expression)
+          "#{object.position}: #{object.command} #{object.arguments}"
+        elsif object.is_a?(Swarm::Process)
+          object.process_definition_name.to_s
+        end
+        if object.workitem != initial_workitem
+          string += "; #{object.workitem}"
+        end
+        string
+      end
+    end
+  end
+end

data/lib/swarm/participant.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Swarm
   class Participant
     attr_reader :hive, :expression
 
-    def initialize(hive: Hive.default, expression:)
+    def initialize(expression:, hive: Hive.default)
       @hive = hive
       @expression = expression
     end

data/lib/swarm/participants/storage_participant.rb

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

data/lib/swarm/participants/trace_participant.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../participant"
 
 module Swarm

data/lib/swarm/pollen/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "parslet"
 
 module Swarm
@@ -7,88 +9,90 @@ module Swarm
         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(:eol) do optionally_spaced(match['\n']).repeat(1) end
+      rule(:whitespace) do match('\s').repeat(0) end
+      rule(:spaces) do match[' \t'].repeat(1) end
+      rule(:spaces?) do spaces.maybe end
+      rule(:comma) do optionally_spaced(str(',')) end
 
-      rule(:integer) {
+      rule(:integer) do
         match['0-9'].repeat(1).as(:integer)
-      }
+      end
 
-      rule(:float) {
+      rule(:float) do
         (match['0-9'].repeat(1) >> str('.') >> match['0-9'].repeat(1)).as(:float)
-      }
+      end
 
-      rule(:line) {
+      rule(:line) do
         (match['\n'].absent? >> any).repeat(1).as(:line)
-      }
+      end
 
-      rule(:string) {
+      rule(:string) do
         (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]) }
-      }
+            dynamic { |_s, c| str(c.captures[:q]) }.absent? >> any
+          ).repeat.as(:string) >> dynamic { |_s, c| str(c.captures[:q]) }
+      end
 
-      rule(:colon_pair) {
+      rule(:colon_pair) do
         token.as(:key) >> str(':') >> spaces? >> string.as(:value)
-      }
+      end
 
-      rule(:symbol) { str(':') >> token.as(:symbol) }
-      rule(:token) { (match('[a-z_]') >> match('[a-zA-Z0-9_]').repeat(0)).as(:token) }
+      rule(:symbol) do str(':') >> token.as(:symbol) end
+      rule(:token) do (match('[a-z_]') >> match('[a-zA-Z0-9_]').repeat(0)).as(:token) end
 
-      rule(:rocket_pair) {
+      rule(:rocket_pair) do
         (symbol | string).as(:key) >> optionally_spaced(str('=>')) >> string.as(:value)
-      }
+      end
 
-      rule(:key_value_pair) { rocket_pair | colon_pair }
+      rule(:key_value_pair) do rocket_pair | colon_pair end
 
-      rule(:key_value_list) {
+      rule(:key_value_list) do
         key_value_pair >> (comma >> key_value_pair).repeat(0)
-      }
+      end
 
-      rule(:arguments) {
-        key_value_list.as(:arguments) | string.as(:text_argument)
-      }
+      rule(:arguments) do
+        key_value_list.as(:arguments) | (
+          string.as(:text_argument) >> (comma >> key_value_list.as(:arguments)).maybe
+        )
+      end
 
-      rule(:reserved_word) {
-        %w(if unless else end).map { |w| str(w) }.reduce(:|)
-      }
+      rule(:reserved_word) do
+        %w[if unless else end].map { |w| str(w) }.reduce(:|)
+      end
 
-      rule(:expression) {
+      rule(:expression) do
         reserved_word.absent? >> token.as(:command) >> (spaces >> arguments).maybe
-      }
+      end
 
-      rule(:tree) {
+      rule(:tree) do
         ((conditional_block | branch_block | expression) >> eol).repeat(0)
-      }
+      end
 
-      rule(:conditional_block) {
+      rule(:conditional_block) do
         (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')
-      }
+          str('end')
+      end
 
-      rule(:branch_block) {
+      rule(:branch_block) do
         expression >> spaces >> str('do') >> eol >>
           tree.as(:tree) >>
           str('end')
-      }
+      end
 
-      rule(:metadata_entry) {
+      rule(:metadata_entry) do
         token.as(:key) >> str(':') >> spaces? >>
           (string | float | integer | line).as(:value)
-      }
+      end
 
-      rule(:metadata) {
+      rule(:metadata) do
         str('---') >> eol >> (metadata_entry >> eol).repeat(0) >> str('---') >> eol
-      }
+      end
 
-      rule(:document) { whitespace >> metadata.maybe.as(:metadata) >> branch_block.as(:tree) >> whitespace }
+      rule(:document) do whitespace >> metadata.maybe.as(:metadata) >> branch_block.as(:tree) >> whitespace end
       root(:document)
     end
   end

data/lib/swarm/pollen/reader.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "parser"
 require_relative "transformer"
 
@@ -10,13 +12,13 @@ module Swarm
 
       def to_hash
         Transformer.new.apply(
-          Parser.new.parse(@pollen, :reporter => Parslet::ErrorReporter::Deepest.new)
+          Parser.new.parse(@pollen, reporter: Parslet::ErrorReporter::Deepest.new)
         )
       end
 
-      def to_json
+      def to_json(*_args)
         to_hash.to_json
       end
     end
   end
-end
+end

data/lib/swarm/pollen/transformer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "parslet"
 
 module Swarm
@@ -13,51 +15,55 @@ module Swarm
         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(symbol: simple(:sym)) do sym.to_s end
+      rule(token: simple(:token)) do token.to_s end
+      rule(string: simple(:st)) do st.to_s end
+      rule(line: simple(:line)) do line.to_s end
+      rule(float: simple(:float)) do float.to_f end
+      rule(integer: simple(:int)) do int.to_i end
 
-      rule(:key => simple(:key), :value => simple(:value)) {
+      rule(key: simple(:key), value: simple(:value)) do
         { key => value }
-      }
-      rule(:conditional => simple(:conditional), :conditional_clause => simple(:clause), :true_tree => subtree(:true_tree), :false_tree => subtree(:false_tree)) {
+      end
+      rule(conditional: simple(:conditional), conditional_clause: simple(:clause), true_tree: subtree(:true_tree),
+           false_tree: subtree(:false_tree)) do
         [conditional.to_s, { "condition" => clause }, {
           "true" => [
             ["sequence", {}, true_tree]
           ],
           "false" => [
             ["sequence", {}, false_tree]
-          ],
+          ]
         }]
-      }
+      end
 
-      rule(:conditional => simple(:conditional), :conditional_clause => simple(:clause), :true_tree => subtree(:true_tree)) {
+      rule(conditional: simple(:conditional), conditional_clause: simple(:clause), true_tree: subtree(:true_tree)) do
         [conditional.to_s, { "condition" => clause }, {
           "true" => [
             ["sequence", {}, true_tree]
           ]
         }]
-      }
+      end
 
-      rule(:command => simple(:command)) {
+      rule(command: simple(:command)) do
         [command.to_s, {}, []]
-      }
-      rule(:command => simple(:command), :tree => subtree(:tree)) {
+      end
+      rule(command: simple(:command), tree: subtree(:tree)) do
         [command.to_s, {}, tree]
-      }
-      rule(:command => simple(:command), :arguments => subtree(:args)) { |captures|
+      end
+      rule(command: simple(:command), arguments: subtree(:args)) do |captures|
         [captures[:command].to_s, transform_arguments(captures[:args]), []]
-      }
-      rule(:command => simple(:command), :arguments => subtree(:args), :tree => subtree(:tree)) { |captures|
+      end
+      rule(command: simple(:command), text_argument: simple(:ta), arguments: subtree(:args)) do |captures|
+        [captures[:command].to_s, { "text" => captures[:ta] }.merge(transform_arguments(captures[:args])), []]
+      end
+      rule(command: simple(:command), arguments: subtree(:args), tree: subtree(:tree)) do |captures|
         [captures[:command].to_s, transform_arguments(captures[:args]), captures[:tree]]
-      }
-      rule(:command => simple(:command), :text_argument => simple(:ta)) {
+      end
+      rule(command: simple(:command), text_argument: simple(:ta)) do
         [command.to_s, { "text" => ta }, []]
-      }
-      rule(:metadata => subtree(:metadata), :tree => subtree(:tree)) { |captures|
+      end
+      rule(metadata: subtree(:metadata), tree: subtree(:tree)) { |captures|
         metadata = (captures[:metadata] || {}).reduce(:merge)
         (metadata || {}).merge("definition" => captures[:tree])
       }

data/lib/swarm/process.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 require "timeout"
 
 module Swarm
   class Process < HiveDweller
     set_columns :process_definition_id, :workitem, :root_expression_id, :parent_expression_id
-    many_to_one :process_definition, :class_name => "Swarm::ProcessDefinition"
-    many_to_one :parent_expression, :class_name => "Swarm::Expression"
+    many_to_one :process_definition, class_name: "Swarm::ProcessDefinition"
+    many_to_one :parent_expression, class_name: "Swarm::Expression"
+    many_to_one :root_expression, class_name: "Swarm::Expression"
+    one_to_many :expressions, class_name: "Swarm::Expression"
 
     def wait_until_finished(timeout: 5)
       Swarm::Support.wait_until(timeout: timeout) { finished? }
@@ -16,42 +20,39 @@ module Swarm
     end
 
     def _launch
-      root_expression = SequenceExpression.create(
-        :hive => hive,
-        :parent_id => id,
-        :position => [0],
-        :workitem => workitem,
-        :process_id => id
+      new_expression = SequenceExpression.create(
+        hive: hive,
+        parent_id: id,
+        position: [0],
+        workitem: workitem,
+        process_id: id
       )
-      root_expression.apply
-      self.root_expression_id = root_expression.id
+      new_expression.apply
+      self.root_expression_id = new_expression.id
       save
     end
 
-    def root_expression
-      @root_expression ||= begin
-        reload! unless root_expression_id
-        if root_expression_id
-          Expression.fetch(root_expression_id, hive: hive)
-        end
-      end
-    end
-
     def finished?
-      root_expression && root_expression.replied?
+      reload!
+      root_expression&.replied?
     end
 
     def node_at_position(position)
       raise ArgumentError unless position == 0
+
       process_definition.tree
     end
 
     def move_on_from(expression)
       self.workitem = expression.workitem
       save
-      if parent_expression
-        parent_expression.move_on_from(self)
-      end
+      return unless parent_expression
+
+      parent_expression.move_on_from(self)
+    end
+
+    def process_definition_name
+      process_definition.name
     end
   end
-end
+end

data/lib/swarm/process_definition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "json"
 
 module Swarm
@@ -5,10 +7,11 @@ module Swarm
     class NotYetPersistedError < StandardError; end
 
     set_columns :tree, :name, :version
+    one_to_many :processes, class_name: "Swarm::Process"
 
     class << self
       def create_from_json(json, hive: Hive.default)
-        create(**parse_json_definition(json).merge(:hive => hive))
+        create(**parse_json_definition(json).merge(hive: hive))
       end
 
       def create_from_pollen(pollen, hive: Hive.default)
@@ -19,12 +22,12 @@ module Swarm
       def parse_json_definition(json)
         parsed = JSON.parse(json)
         if parsed.is_a?(Array)
-          { :tree => parsed }
+          { tree: parsed }
         else
           {
-            :name => parsed["name"],
-            :version => parsed["version"],
-            :tree => parsed["definition"]
+            name: parsed["name"],
+            version: parsed["version"],
+            tree: parsed["definition"]
           }
         end
       end
@@ -36,10 +39,11 @@ module Swarm
 
     def create_process(workitem:, **args)
       raise NotYetPersistedError unless id
+
       Process.create(
-        args.merge({
-          :workitem => workitem,
-          :process_definition_id => id
+        **args.merge({
+          workitem: workitem,
+          process_definition_id: id
         })
       )
     end
@@ -49,4 +53,4 @@ module Swarm
       process.launch
     end
   end
-end
+end