swarm 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c08aee506af8648cba7e34c9bf1a0f6771da43fb
-  data.tar.gz: fa7e78cf7ccb4c0f134623f8001a8782af141164
+  metadata.gz: e4410067eb9ac5847b4add5e8a31f9c78f3a6f18
+  data.tar.gz: fdf564f1018be4d4ffdd837777c4fd25d1a1664d
 SHA512:
-  metadata.gz: 57e8b887897b7b94f34f0ddec8e90a5ef6024ba9e03deeb03ddb05ca7d802a1e438fcf1b657b750a38020112f7dcfb2fd41ea1b5f9dfbcde4bdc20b00bc0a6e4
-  data.tar.gz: 3cea3598a30320cc93a15d41e827714980b2c2f82bec4e4fe196f7989470be9560662ca6a09f9513ebb67715c83e38b305bf63192c4307084518f9502150c44a
+  metadata.gz: 02303d2b8f04002bad616eddbd69ecec4e49f33cd44b4b3785802147c4815ad4f52e318c267a4f7f2de5be8451de48567b01a0ccdb277cfac7b88c140b716a94
+  data.tar.gz: ab727019332409f4e5954f8c23c34b62c1b445497b107b60f58d1c12d6fb76e5bc35c1195c0241983dabe9002ef2db007862ebbf24420a87f45dd3cc90fb4b01

data/lib/swarm/expression.rb

@@ -13,8 +13,10 @@ module Swarm
       end
     end
 
-    set_columns :parent_id, :position, :workitem, :child_ids, :milestones, :process_id
+    set_columns :parent_id, :position, :workitem, :children_ids, :milestones, :process_id
     many_to_one :process, :class_name => "Swarm::Process"
+    many_to_one :parent, :class_name => "Swarm::Expression", :key => :parent_id
+    one_to_many :children, :class_name => "Swarm::Expression", :foreign_key => :parent_id
 
     def branch_position
       @branch_position ||= position.last

data/lib/swarm/expressions/branch_expression.rb

@@ -4,12 +4,6 @@ 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)
@@ -26,7 +20,7 @@ module Swarm
       node = tree[at_position]
       raise InvalidPositionError unless node
       expression = create_child_expression(node: node, at_position: at_position)
-      (self.child_ids ||= []) << expression.id
+      (self.children_ids ||= []) << expression.id
       expression
     end
 

data/lib/swarm/hive.rb

@@ -40,11 +40,11 @@ module Swarm
     end
 
     def traced
-      storage["trace"] ||= []
+      storage.trace ||= []
     end
 
     def trace(new_element)
-      storage["trace"] = traced + [new_element]
+      storage.trace = traced + [new_element]
     end
 
     def queue(action, object)

data/lib/swarm/hive_dweller.rb

@@ -116,14 +116,29 @@ module Swarm
         @columns = @columns | args
       end
 
-      def many_to_one(type, class_name: nil)
+      def one_to_many(type, class_name: nil, foreign_key: nil)
         define_method(type) do
           memo = instance_variable_get(:"@#{type}")
           memo || begin
-            key = self.send(:"#{type}_id")
-            return nil unless key
+            associations = hive.storage.load_associations(
+              type, owner: self, type: class_name || type, foreign_key: foreign_key
+            )
+            entities = associations.map { |association| hive.reify_from_hash(association) }
+            instance_variable_set(:"@#{type}", entities)
+          end
+        end
+        @associations << type
+      end
+
+      def many_to_one(type, class_name: nil, key: nil)
+        define_method(type) do
+          memo = instance_variable_get(:"@#{type}")
+          memo || begin
+            key ||= :"#{type}_id"
+            associated_id = self.send(key)
+            return nil unless associated_id
             klass = Swarm::Support.constantize("#{class_name || type}")
-            instance_variable_set(:"@#{type}", klass.fetch(key, :hive => hive))
+            instance_variable_set(:"@#{type}", klass.fetch(associated_id, :hive => hive))
           end
         end
         @associations << type
@@ -172,7 +187,9 @@ module Swarm
       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|
+          hive.reify_from_hash(hsh.dup)
+        }
       end
     end
   end

data/lib/swarm/process.rb

@@ -5,6 +5,8 @@ module Swarm
     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 :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,28 +18,20 @@ module Swarm
     end
 
     def _launch
-      root_expression = SequenceExpression.create(
+      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?
+      reload!
       root_expression && root_expression.replied?
     end
 

data/lib/swarm/process_definition.rb

@@ -5,6 +5,7 @@ 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)

data/lib/swarm/storage/hash_storage.rb

@@ -8,6 +8,13 @@ module Swarm
         keys.map { |key| key.gsub(regex_for_type(type), '\1') }
       end
 
+      def all_of_type(type, subtypes: true)
+        store.select { |key, value|
+          key.match(regex_for_type(type)) &&
+            (subtypes || value["type"] == type)
+        }.values
+      end
+
       def delete(key)
         store.delete(key)
       end

data/lib/swarm/storage/key_value_storage.rb

@@ -7,6 +7,14 @@ module Swarm
         @store = store
       end
 
+      def trace
+        self["trace"]
+      end
+
+      def trace=(traced)
+        self["trace"] = traced
+      end
+
       def regex_for_type(type)
         /^#{type}\:(.*)/
       end
@@ -15,6 +23,21 @@ module Swarm
         raise "Not implemented yet!"
       end
 
+      def all_of_type(type)
+        raise "Not implemented yet!"
+      end
+
+      def load_associations(association_name, owner:, type:, foreign_key: nil)
+        type = type.split("::").last
+        local_association_ids = :"#{association_name}_ids"
+        if owner.respond_to?(local_association_ids)
+          ids = owner.send(local_association_ids) || []
+          ids.map { |id|
+            self["#{type}:#{id}"]
+          }.compact
+        end
+      end
+
       def serialize(value)
         return nil if value.nil?
         value.to_json

data/lib/swarm/storage/redis_storage.rb

@@ -8,6 +8,15 @@ module Swarm
         store.keys("#{type}:*").map { |key| key.gsub(regex_for_type(type), '\1') }
       end
 
+      def all_of_type(type, subtypes: true)
+        hsh = store.mapped_mget(*store.keys("#{type}:*"))
+        if subtypes
+          hsh.values
+        else
+          hsh.select { |key, value| value["type"] == type }.values
+        end
+      end
+
       def delete(key)
         store.del(key)
       end

data/lib/swarm/support.rb

@@ -43,6 +43,14 @@ module Swarm
         "#{Time.now.strftime("%Y%m%d-%H%M%S")}-#{SecureRandom.uuid}"
       end
 
+      def tokenize(string)
+        return nil if string.nil?
+        string = string.to_s.gsub(/&/, ' and ').
+          gsub(/[ \/]+/, '_').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          downcase
+      end
+
       def camelize(string)
         string = string.sub(/^[a-z\d]*/) { $&.capitalize }
         string = string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')

data/lib/swarm/version.rb

@@ -1,3 +1,3 @@
 module Swarm
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swarm
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Ravi Gadad
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-17 00:00:00.000000000 Z
+date: 2016-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis