vorpal 0.0.6.rc4 → 0.0.6

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OGZhMWQ2MGM3ZWZlZTJhZjkxOGVlMmZiYTkzODk4NTljNzk5NjU0MA==
+    MzY2ZTAwNWJiYmFlY2Y5NGZkZjg4ZTUyMGU4M2U4NjNiNzkxNzdkMg==
   data.tar.gz: !binary |-
-    ZDMxYTEyMzI5OTQ0YmJkNDJmNjg3OGZjNzc5NDE2ZGUyNjc0M2Y4ZA==
+    YTQ0OGZiZGIwOTdmMjcyYmRjZTVmOWRjZGI0ODgzOWRkZTI5OWUxNQ==
 SHA512:
   metadata.gz: !binary |-
-    M2QxM2JlYWQ0NGE5Njg3YWZhYmI4MjdmNmVlZjVhZGIzOTA1YTZjMDYzYzVj
-    ZGViNjM3ZDI2YTY5MGNkZGRhZmNkMmI2YjUxZDYwYTVjYmI1ZjA5ZmVmNTgx
-    ZGIxZTZjZTQzYTQ2NzQ4ZWMxNWM2OThmYzIzNjAzMjYxNTVkMTE=
+    ZDBiYjBhZDk0ZjY3MjJmMWRjZDcwMWQ3YzAxMGRhYzNiNjkzZjZlMzk5MmIz
+    ZWVmY2M1YjBiY2NhY2IyZmEyOThkMjA5MGI5YzUzZGJkMTU3Mzg0NWU4NGY5
+    Zjc3OGVhMmE1ZTExMzg1YWI1MjhlMjU2NjI2MTdjNzQzZGY1MzU=
   data.tar.gz: !binary |-
-    ZmExNTU3NGNiYmM1YjIxZjg3M2VlNjU0ODJmY2NjNmZlYTRkMDcyZTYzZTNm
-    YTkyZDUxMTI2NGI4MzhjYzg5NjBiMWNmNGUwOTI1ZWIzZDc5MDRiM2RmMmQx
-    MzEzYmI0ZWRmYzYyZjgyYjFmOTI5NDA3YTYzMzJlYmZkMzc1YzU=
+    NTNlMTA1NjRiYzc1ODVhNGU5MGNlODIyYTNmOGY0YTQxNTBiMTYzN2UwMzdm
+    YTk0MTIyNTAxZmNhMzY3MTk5YjEyM2M1ZmIzNTIzMzU2M2FlZWQ2YjM4OGZj
+    MTU4YjU5ZTlkZmIzZTMzMjAzMWMxNWQ2OGY5YTI5MGZiZTQ3Y2Q=

data/README.md

@@ -72,7 +72,7 @@ class Tree
 end
 ```
 
-In this aggregate, the Tree is the root and the Branches are inside the aggregate boundary. The Gardener is not technically part of the aggregate but is required for the aggregate to make sense so we say that it is on the aggregate boundary.
+In this aggregate, the Tree is the root and the Branches are inside the aggregate boundary. The Gardener is not technically part of the aggregate but is required for the aggregate to make sense so we say that it is on the aggregate boundary. Only objects that are inside the aggregate boundary will be saved, updated, or destroyed by Vorpal.
 
 POROs must have setters and getters for all fields and associations that are to be persisted. They must also provide a no argument constructor.
 
@@ -143,6 +143,10 @@ module TreeRepository
   def destroy(tree)
     @repository.destroy(tree)
   end
+
+  def destroy_by_id(tree_id)
+    @repository.destroy_by_id(tree_id, Tree)
+  end
 end
 ```
 
@@ -162,6 +166,9 @@ small_tree = TreeRepository.find(small_tree_id)
 # Destroys the given Tree as well as all Branches referenced by it,
 # but not Gardeners.
 TreeRepository.destroy(dead_tree)
+
+# Or
+TreeRepository.destroy_by_id(dead_tree_id)
 ```
 
 ## API Documentation
@@ -188,9 +195,9 @@ It also does not do some things that you might expect from other ORMs:
 * Support for other ORMs.
 * Value objects.
 * Remove dependency on ActiveRecord (optimistic locking? updated_at, created_at support? Data type conversions? TimeZone support?)
-* More efficient object loading and persisting (use fewer queries.)
+* More efficient updates (use fewer queries.)
 * Nicer DSL for specifying field that have different names in the domain model than in the DB.
- 
+
 ## FAQ
 
 **Q.** Why do I care about separating my persistence mechanism from my domain models?

data/lib/vorpal/aggregate_repository.rb

@@ -4,240 +4,277 @@ require 'vorpal/db_loader'
 require 'vorpal/db_driver'
 
 module Vorpal
-class AggregateRepository
-  # @private
-  def initialize(db_driver, master_config)
-    @db_driver = db_driver
-    @configs = master_config
-  end
+  class AggregateRepository
+    # @private
+    def initialize(db_driver, master_config)
+      @db_driver = db_driver
+      @configs = master_config
+    end
 
-  # Saves an aggregate to the DB. Inserts objects that are new to the
-  # aggregate, updates existing objects and deletes objects that are no longer
-  # present.
-  #
-  # Objects that are on the boundary of the aggregate (owned: false) will not
-  # be inserted, updated, or deleted. However, the relationships to these
-  # objects (provided they are stored within the aggregate) will be saved.
-  #
-  # @param root [Object] Root of the aggregate to be saved.
-  # @return [Object] Root of the aggregate.
-  def persist(root)
-    persist_all(Array(root)).first
-  end
+    # Saves an aggregate to the DB. Inserts objects that are new to the
+    # aggregate, updates existing objects and deletes objects that are no longer
+    # present.
+    #
+    # Objects that are on the boundary of the aggregate (owned: false) will not
+    # be inserted, updated, or deleted. However, the relationships to these
+    # objects (provided they are stored within the aggregate) will be saved.
+    #
+    # @param root [Object] Root of the aggregate to be saved.
+    # @return [Object] Root of the aggregate.
+    def persist(root)
+      persist_all([root]).first
+    end
 
-  # Like {#persist} but operates on multiple aggregates. Roots must
-  # be of the same type.
-  #
-  # @param roots [[Object]] array of aggregate roots to be saved.
-  # @return [[Object]] array of aggregate roots.
-  def persist_all(roots)
-    return roots if roots.empty?
-
-    all_owned_objects = all_owned_objects(roots)
-    mapping = {}
-    loaded_db_objects = load_owned_from_db(roots.map(&:id), roots.first.class)
-
-    serialize(all_owned_objects, mapping, loaded_db_objects)
-    new_objects = get_unsaved_objects(mapping.keys)
-    begin
-      set_primary_keys(all_owned_objects, mapping)
-      set_foreign_keys(all_owned_objects, mapping)
-      remove_orphans(mapping, loaded_db_objects)
-      save(all_owned_objects, new_objects, mapping)
-
-      return roots
-    rescue
-      nil_out_object_ids(new_objects)
-      raise
+    # Like {#persist} but operates on multiple aggregates. Roots must
+    # be of the same type.
+    #
+    # @param roots [[Object]] array of aggregate roots to be saved.
+    # @return [[Object]] array of aggregate roots.
+    def persist_all(roots)
+      return roots if roots.empty?
+      raise InvalidAggregateRoot, 'Nil aggregate roots are not allowed.' if roots.any?(&:nil?)
+
+      all_owned_objects = all_owned_objects(roots)
+      mapping = {}
+      loaded_db_objects = load_owned_from_db(roots.map(&:id).compact, roots.first.class)
+
+      serialize(all_owned_objects, mapping, loaded_db_objects)
+      new_objects = get_unsaved_objects(mapping.keys)
+      begin
+        set_primary_keys(all_owned_objects, mapping)
+        set_foreign_keys(all_owned_objects, mapping)
+        remove_orphans(mapping, loaded_db_objects)
+        save(all_owned_objects, new_objects, mapping)
+
+        return roots
+      rescue Exception
+        nil_out_object_ids(new_objects)
+        raise
+      end
     end
-  end
 
-  # Loads an aggregate from the DB. Will eagerly load all objects in the
-  # aggregate and on the boundary (owned: false).
-  #
-  # @param id [Integer] Primary key value of the root of the aggregate to be
-  #   loaded.
-  # @param domain_class [Class] Type of the root of the aggregate to
-  #   be loaded.
-  # @param identity_map [Vorpal::IdentityMap] Provide your own IdentityMap instance
-  #   if you want entity id - unique object mapping for a greater scope than one
-  #   operation.
-  # @return [Object] Entity with the given primary key value and type.
-  def load(id, domain_class, identity_map=IdentityMap.new)
-    load_all([id], domain_class, identity_map).first
-  end
+    # Loads an aggregate from the DB. Will eagerly load all objects in the
+    # aggregate and on the boundary (owned: false).
+    #
+    # @param id [Integer] Primary key value of the root of the aggregate to be
+    #   loaded.
+    # @param domain_class [Class] Type of the root of the aggregate to
+    #   be loaded.
+    # @param identity_map [Vorpal::IdentityMap] Provide your own IdentityMap instance
+    #   if you want entity id - unique object mapping for a greater scope than one
+    #   operation.
+    # @return [Object] Entity with the given primary key value and type.
+    def load(id, domain_class, identity_map=IdentityMap.new)
+      load_all([id], domain_class, identity_map).first
+    end
 
-  # Like {#load} but operates on multiple ids.
-  #
-  # @param ids [[Integer]] Array of primary key values of the roots of the
-  #   aggregates to be loaded.
-  # @param domain_class [Class] Type of the roots of the aggregate to be loaded.
-  # @param identity_map [Vorpal::IdentityMap] Provide your own IdentityMap instance
-  #   if you want entity id - unique object mapping for a greater scope than one
-  #   operation.
-  # @return [[Object]] Entities with the given primary key values and type.
-  def load_all(ids, domain_class, identity_map=IdentityMap.new)
-    loaded_db_objects = load_from_db(ids, domain_class)
-    objects = deserialize(loaded_db_objects, identity_map)
-    set_associations(loaded_db_objects, identity_map)
-
-    objects.select { |obj| obj.class == domain_class }
-  end
+    # Like {#load} but operates on multiple ids.
+    #
+    # @param ids [[Integer]] Array of primary key values of the roots of the
+    #   aggregates to be loaded.
+    # @param domain_class [Class] Type of the roots of the aggregate to be loaded.
+    # @param identity_map [Vorpal::IdentityMap] Provide your own IdentityMap instance
+    #   if you want entity id - unique object mapping for a greater scope than one
+    #   operation.
+    # @return [[Object]] Entities with the given primary key values and type.
+    def load_all(ids, domain_class, identity_map=IdentityMap.new)
+      raise InvalidPrimaryKeyValue, 'Nil primary key values are not allowed.' if ids.any?(&:nil?)
 
-  # Removes an aggregate from the DB. Even if the aggregate contains unsaved
-  # changes this method will correctly remove everything.
-  #
-  # @param root [Object] Root of the aggregate to be destroyed.
-  # @return [Object] Root that was passed in.
-  def destroy(root)
-    destroy_all(Array(root)).first
-  end
+      loaded_db_objects = load_from_db(ids, domain_class)
+      objects = deserialize(loaded_db_objects, identity_map)
+      set_associations(loaded_db_objects, identity_map)
 
-  # Like {#destroy} but operates on multiple aggregates. Roots must
-  # be of the same type.
-  #
-  # @param roots [[Object]] Array of roots of the aggregates to be destroyed.
-  # @return [[Object]] Roots that were passed in.
-  def destroy_all(roots)
-    return roots if roots.empty?
-    loaded_db_objects = load_owned_from_db(roots.map(&:id), roots.first.class)
-    loaded_db_objects.each do |config, db_objects|
-      @db_driver.destroy(config, db_objects)
-    end
-    roots
-  end
+      sorted_roots(ids, objects, domain_class)
+    end
 
-  private
+    # Removes an aggregate from the DB. Even if the aggregate contains unsaved
+    # changes this method will correctly remove everything.
+    #
+    # @param root [Object] Root of the aggregate to be destroyed.
+    # @return [Object] Root that was passed in.
+    def destroy(root)
+      destroy_all([root]).first
+    end
 
-  def all_owned_objects(roots)
-    AggregateUtils.group_by_type(roots, @configs)
-  end
+    # Like {#destroy} but operates on multiple aggregates. Roots must
+    # be of the same type.
+    #
+    # @param roots [[Object]] Array of roots of the aggregates to be destroyed.
+    # @return [[Object]] Roots that were passed in.
+    def destroy_all(roots)
+      return roots if roots.empty?
+      raise InvalidAggregateRoot, 'Nil aggregate roots are not allowed.' if roots.any?(&:nil?)
 
-  def load_from_db(ids, domain_class, only_owned=false)
-    DbLoader.new(only_owned, @db_driver).load_from_db(ids, @configs.config_for(domain_class))
-  end
+      destroy_all_by_id(roots.map(&:id), roots.first.class)
+      roots
+    end
 
-  def load_owned_from_db(ids, domain_class)
-    load_from_db(ids, domain_class, true)
-  end
+    # Removes an aggregate from the DB given its primary key.
+    #
+    # @param id [Integer] Id of root of the aggregate to be destroyed.
+    # @param domain_class [Class] Type of the root of the aggregate to
+    #   be destroyed.
+    def destroy_by_id(id, domain_class)
+      destroy_all_by_id([id], domain_class)
+    end
 
-  def deserialize(loaded_db_objects, identity_map)
-    loaded_db_objects.flat_map do |config, db_objects|
-      db_objects.map do |db_object|
-        # TODO: There is a bug here when you have something in the IdentityMap that is stale and needs to be updated.
-        identity_map.get_and_set(db_object) { config.deserialize(db_object) }
+    # Like {#destroy_by_id} but operates on multiple ids. Roots must
+    # be of the same type.
+    #
+    # @param ids [[Integer]] Ids of roots of the aggregates to be destroyed.
+    # @param domain_class [Class] Type of the roots of the aggregates to
+    #   be destroyed.
+    def destroy_all_by_id(ids, domain_class)
+      raise InvalidPrimaryKeyValue, 'Nil primary key values are not allowed.' if ids.any?(&:nil?)
+
+      loaded_db_objects = load_owned_from_db(ids, domain_class)
+      loaded_db_objects.each do |config, db_objects|
+        @db_driver.destroy(config, db_objects.map(&:id))
       end
+      ids
+    end
+
+    private
+
+    def all_owned_objects(roots)
+      AggregateUtils.group_by_type(roots, @configs)
+    end
+
+    def load_from_db(ids, domain_class, only_owned=false)
+      DbLoader.new(only_owned, @db_driver).load_from_db(ids, @configs.config_for(domain_class))
+    end
+
+    def load_owned_from_db(ids, domain_class)
+      load_from_db(ids, domain_class, true)
     end
-  end
 
-  def set_associations(loaded_db_objects, identity_map)
-    loaded_db_objects.each do |config, db_objects|
-      db_objects.each do |db_object|
-        config.local_association_configs.each do |association_config|
-          db_remote = loaded_db_objects.find_by_id(
-            association_config.remote_class_config(db_object),
-            association_config.fk_value(db_object)
-          )
-          association_config.associate(identity_map.get(db_object), identity_map.get(db_remote))
+    def deserialize(loaded_db_objects, identity_map)
+      loaded_db_objects.flat_map do |config, db_objects|
+        db_objects.map do |db_object|
+          # TODO: There is a bug here when you have something in the IdentityMap that is stale and needs to be updated.
+          identity_map.get_and_set(db_object) { config.deserialize(db_object) }
         end
       end
     end
-  end
 
-  def serialize(owned_objects, mapping, loaded_db_objects)
-    owned_objects.each do |config, objects|
-      objects.each do |object|
-        db_object = serialize_object(object, config, loaded_db_objects)
-        mapping[object] = db_object
+    def set_associations(loaded_db_objects, identity_map)
+      loaded_db_objects.each do |config, db_objects|
+        db_objects.each do |db_object|
+          config.local_association_configs.each do |association_config|
+            db_remote = loaded_db_objects.find_by_id(
+              association_config.remote_class_config(db_object),
+              association_config.fk_value(db_object)
+            )
+            association_config.associate(identity_map.get(db_object), identity_map.get(db_remote))
+          end
+        end
       end
     end
-  end
 
-  def serialize_object(object, config, loaded_db_objects)
-    if config.serialization_required?
-      attributes = config.serialize(object)
-      if object.id.nil?
-        config.build_db_object(attributes)
+    def sorted_roots(ids, objects, domain_class)
+      roots = objects.select { |obj| obj.class == domain_class }
+      roots_by_id = roots.reduce({}) { |h, root| h[root.id] = root; h }
+      ids.map { |id| roots_by_id[id] }.compact
+    end
+
+    def serialize(owned_objects, mapping, loaded_db_objects)
+      owned_objects.each do |config, objects|
+        objects.each do |object|
+          db_object = serialize_object(object, config, loaded_db_objects)
+          mapping[object] = db_object
+        end
+      end
+    end
+
+    def serialize_object(object, config, loaded_db_objects)
+      if config.serialization_required?
+        attributes = config.serialize(object)
+        if object.id.nil?
+          config.build_db_object(attributes)
+        else
+          db_object = loaded_db_objects.find_by_id(config, object.id)
+          config.set_db_object_attributes(db_object, attributes)
+          db_object
+        end
       else
-        db_object = loaded_db_objects.find_by_id(config, object.id)
-        config.set_db_object_attributes(db_object, attributes)
-        db_object
+        object
       end
-    else
-      object
     end
-  end
 
-  def set_primary_keys(owned_objects, mapping)
-    owned_objects.each do |config, objects|
-      in_need_of_primary_keys = objects.find_all { |obj| obj.id.nil? }
-      primary_keys = @db_driver.get_primary_keys(config, in_need_of_primary_keys.length)
-      in_need_of_primary_keys.zip(primary_keys).each do |object, primary_key|
-        mapping[object].id = primary_key
-        object.id = primary_key
+    def set_primary_keys(owned_objects, mapping)
+      owned_objects.each do |config, objects|
+        in_need_of_primary_keys = objects.find_all { |obj| obj.id.nil? }
+        primary_keys = @db_driver.get_primary_keys(config, in_need_of_primary_keys.length)
+        in_need_of_primary_keys.zip(primary_keys).each do |object, primary_key|
+          mapping[object].id = primary_key
+          object.id = primary_key
+        end
       end
+      mapping.rehash # needs to happen because setting the id on an AR::Base model changes its hash value
     end
-    mapping.rehash # needs to happen because setting the id on an AR::Base model changes its hash value
-  end
 
-  def set_foreign_keys(owned_objects, mapping)
-    owned_objects.each do |config, objects|
-      objects.each do |object|
-        config.has_manys.each do |has_many_config|
-          if has_many_config.owned
-            children = has_many_config.get_children(object)
-            children.each do |child|
-              has_many_config.set_foreign_key(mapping[child], object)
+    def set_foreign_keys(owned_objects, mapping)
+      owned_objects.each do |config, objects|
+        objects.each do |object|
+          config.has_manys.each do |has_many_config|
+            if has_many_config.owned
+              children = has_many_config.get_children(object)
+              children.each do |child|
+                has_many_config.set_foreign_key(mapping[child], object)
+              end
             end
           end
-        end
 
-        config.has_ones.each do |has_one_config|
-          if has_one_config.owned
-            child = has_one_config.get_child(object)
-            has_one_config.set_foreign_key(mapping[child], object)
+          config.has_ones.each do |has_one_config|
+            if has_one_config.owned
+              child = has_one_config.get_child(object)
+              has_one_config.set_foreign_key(mapping[child], object)
+            end
           end
-        end
 
-        config.belongs_tos.each do |belongs_to_config|
-          child = belongs_to_config.get_child(object)
-          belongs_to_config.set_foreign_key(mapping[object], child)
+          config.belongs_tos.each do |belongs_to_config|
+            child = belongs_to_config.get_child(object)
+            belongs_to_config.set_foreign_key(mapping[object], child)
+          end
         end
       end
     end
-  end
 
-  def save(owned_objects, new_objects, mapping)
-    grouped_new_objects = new_objects.group_by { |obj| @configs.config_for(obj.class) }
-    owned_objects.each do |config, objects|
-      objects_to_insert = grouped_new_objects[config] || []
-      db_objects_to_insert = objects_to_insert.map { |obj| mapping[obj] }
-      @db_driver.insert(config, db_objects_to_insert)
+    def save(owned_objects, new_objects, mapping)
+      grouped_new_objects = new_objects.group_by { |obj| @configs.config_for(obj.class) }
+      owned_objects.each do |config, objects|
+        objects_to_insert = grouped_new_objects[config] || []
+        db_objects_to_insert = objects_to_insert.map { |obj| mapping[obj] }
+        @db_driver.insert(config, db_objects_to_insert)
 
-      objects_to_update = objects - objects_to_insert
-      db_objects_to_update = objects_to_update.map { |obj| mapping[obj] }
-      @db_driver.update(config, db_objects_to_update)
+        objects_to_update = objects - objects_to_insert
+        db_objects_to_update = objects_to_update.map { |obj| mapping[obj] }
+        @db_driver.update(config, db_objects_to_update)
+      end
+    end
+
+    def remove_orphans(mapping, loaded_db_objects)
+      db_objects_in_aggregate = mapping.values
+      db_objects_in_db = loaded_db_objects.all_objects
+      all_orphans = db_objects_in_db - db_objects_in_aggregate
+      grouped_orphans = all_orphans.group_by { |o| @configs.config_for_db_object(o) }
+      grouped_orphans.each do |config, orphans|
+        @db_driver.destroy(config, orphans)
+      end
     end
-  end
 
-  def remove_orphans(mapping, loaded_db_objects)
-    db_objects_in_aggregate = mapping.values
-    db_objects_in_db = loaded_db_objects.all_objects
-    all_orphans = db_objects_in_db - db_objects_in_aggregate
-    grouped_orphans = all_orphans.group_by { |o| @configs.config_for_db_object(o) }
-    grouped_orphans.each do |config, orphans|
-      @db_driver.destroy(config, orphans)
+    def get_unsaved_objects(objects)
+      objects.find_all { |object| object.id.nil? }
     end
-  end
 
-  def get_unsaved_objects(objects)
-    objects.find_all { |object| object.id.nil? }
+    def nil_out_object_ids(objects)
+      objects ||= []
+      objects.each { |object| object.id = nil }
+    end
   end
 
-  def nil_out_object_ids(objects)
-    objects ||= []
-    objects.each { |object| object.id = nil }
+  class InvalidPrimaryKeyValue < StandardError
+  end
+  class InvalidAggregateRoot < StandardError
   end
-end
-
 end