vorpal 0.0.7.rc1 → 0.0.7.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce7c3ca0efe5dbcd1f9aa75bcbf4465a0ffa9c8b
-  data.tar.gz: 01a2dad313199961079b71ac522f441d9e68e79b
+  metadata.gz: 8b6b4c26a538b1aeac920b566ce3b80e0b04e4fe
+  data.tar.gz: 88d0f3a57930e3a8587d89d085293ac9d032fc58
 SHA512:
-  metadata.gz: c54780e9bfdaab538b32c2f7a545c1f2182cca2a7ae4f23dce23fb5aeee97947e430961d56d8007c902b7833f38c5057590f4eb78e4613f100d9978602c89f7c
-  data.tar.gz: 16db095201901d03d70a7c75120195a529e9b1548ce1bccf059d86f2544a9c495b5ed52d76f9d27f2e3755d8f12c45498bae0107a1c67a030609f812d8c2cef8
+  metadata.gz: f0190b9231a1ecce12aec8c62a92345e62ae98470f488401f8e0947ddf37bba7573263a9b78b79635958d85614b9249ab952526542cfe48a081c1d6de179ff3d
+  data.tar.gz: 32e2963bc4cb79a56de8499fff09b439475f0371d6b4d6f2cfaa8bb87d5b431070965adfcf708e45546db846063418abcabd5e9e64ed8af4054e9c45fbe37be7

data/CHANGELOG.md

@@ -0,0 +1 @@
+Please see https://github.com/nulogy/vorpal/releases

data/README.md

@@ -109,7 +109,7 @@ require 'vorpal'
 module TreeRepository
   extend self
 
-  @repository = Vorpal.define do
+  engine = Vorpal.define do
     map Tree do
       attributes :name
       belongs_to :gardener, owned: false
@@ -123,9 +123,10 @@ module TreeRepository
       belongs_to :tree
     end
   end
+  @repository = engine.repository_for(Tree)
 
-  def find(id)
-    @repository.load(id, Tree)
+  def find(tree_id)
+    @repository.load_one(@repository.db_class.where(id: tree_id).first)
   end
 
   def save(tree)
@@ -137,7 +138,7 @@ module TreeRepository
   end
 
   def destroy_by_id(tree_id)
-    @repository.destroy_by_id(tree_id, Tree)
+    @repository.destroy_by_id(tree_id)
   end
 end
 ```

data/lib/vorpal/aggregate_repository.rb

@@ -1,286 +1,92 @@
 require 'vorpal/identity_map'
-require 'vorpal/aggregate_utils'
-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
+    def initialize(domain_class, engine)
+      @domain_class = domain_class
+      @engine = engine
     end
 
-    # Saves an aggregate to the DB. Inserts objects that are new to the
+    # Saves a collection of aggregates to the DB. Inserts objects that are new to an
     # 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
+    # Objects that are on the boundary of an 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.
+    # objects (provided they are stored within an 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.
+    # @param roots [[Object]] array of aggregate roots to be saved. Will also accept a
+    #   single aggregate.
     # @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
+    # @raise [InvalidAggregateRoot] When any of the roots are nil.
+    def persist(roots)
+      @engine.persist(roots)
     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
+    # @param db_root [Object] DB representation of the root of the aggregate to be
+    #   loaded. This can be nil.
+    # @param identity_map [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
+    # @return [Object] Aggregate root corresponding to the given DB representation.
+    def load_one(db_root, identity_map=IdentityMap.new)
+      @engine.load_one(db_root, @domain_class, identity_map)
     end
 
-    # Like {#load} but operates on multiple ids.
+    # Like {#load_one} but operates on multiple aggregate roots.
     #
-    # @param ids [[Integer]] Array of primary key values of the roots of the
+    # @param db_roots [[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
+    # @param identity_map [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?)
-
-      loaded_db_objects = load_from_db(ids, domain_class)
-      objects = deserialize(loaded_db_objects, identity_map)
-      set_associations(loaded_db_objects, identity_map)
-
-      sorted_roots(ids, objects, domain_class)
-    end
-
-    # 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
+    # @return [[Object]] Aggregate roots corresponding to the given DB representations.
+    # @raise [InvalidAggregateRoot] When any of the db_roots are nil.
+    def load_many(db_roots, identity_map=IdentityMap.new)
+      @engine.load_many(db_roots, @domain_class, identity_map)
     end
 
-    # Like {#destroy} but operates on multiple aggregates. Roots must
-    # be of the same type.
+    # Removes a collection of aggregates from the DB. Even if an aggregate
+    # contains unsaved changes this method will correctly remove everything.
     #
-    # @param roots [[Object]] Array of roots of the aggregates to be destroyed.
+    # @param roots [[Object]] Roots of the aggregates to be destroyed. Also accepts a
+    #   single root.
     # @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?)
-
-      destroy_all_by_id(roots.map(&:id), roots.first.class)
-      roots
+    # @raise [InvalidAggregateRoot] When any of the roots are nil.
+    def destroy(roots)
+      @engine.destroy(roots)
     end
 
-    # Removes an aggregate from the DB given its primary key.
+    # Removes a collection of aggregates from the DB given their primary keys.
     #
-    # @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
-
-    # 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
+    # @param ids [[Integer]] Ids of roots of the aggregates to be destroyed. Also
+    #   accepts a single id.
+    # @raise [InvalidPrimaryKeyValue] When any of the ids are nil.
+    def destroy_by_id(ids)
+      @engine.destroy_by_id(ids, @domain_class)
     end
 
     # Returns the DB Class (e.g. ActiveRecord::Base class) that is responsible
     # for accessing the associated data in the DB.
-    def db_class(domain_class)
-      @configs.config_for(domain_class).db_class
-    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
-
-    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
-
-    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
-
-    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
-        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
-        end
-      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)
-              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)
-            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)
-          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)
-
-        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
+    def db_class
+      @engine.db_class(@domain_class)
     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
-
-    def get_unsaved_objects(objects)
-      objects.find_all { |object| object.id.nil? }
+    # Access to the underlying mapping {Engine}. Provided in case access to another aggregate
+    # or another db_class is required.
+    #
+    # @return [Engine] Mapping interface not specific to a particular aggregate root.
+    def engine
+      @engine
     end
 
-    def nil_out_object_ids(objects)
-      objects ||= []
-      objects.each { |object| object.id = nil }
+    def query
+      # db_class.unscoped.extending(ArelQueryMethods.new(self))
+      @engine.query(@domain_class)
     end
   end
-
-  class InvalidPrimaryKeyValue < StandardError
-  end
-  class InvalidAggregateRoot < StandardError
-  end
 end

data/lib/vorpal/configuration.rb

@@ -1,20 +1,20 @@
-require 'vorpal/aggregate_repository'
+require 'vorpal/engine'
 require 'vorpal/config_builder'
 
 module Vorpal
   module Configuration
 
-    # Configures and creates a {Vorpal::AggregateRepository} instance.
+    # Configures and creates a {Engine} instance.
     #
     # @param options [Hash] Global configuration options for the repository instance.
     # @option options [Object] :db_driver (Object that will be used to interact with the DB.)
-    #  Must be duck-type compatible with {Vorpal::DbDriver}.
+    #  Must be duck-type compatible with {DbDriver}.
     #
-    # @return [Vorpal::AggregateRepository] Repository instance.
+    # @return [Engine] Instance of the mapping engine.
     def define(options={}, &block)
       master_config = build_config(&block)
       db_driver = options.fetch(:db_driver, DbDriver.new)
-      AggregateRepository.new(db_driver, master_config)
+      Engine.new(db_driver, master_config)
     end
 
     # Maps a domain class to a relational table.

data/lib/vorpal/db_driver.rb

@@ -1,7 +1,7 @@
 module Vorpal
-  # Interfaces between the database and Vorpal
+  # Interface between the database and Vorpal
   #
-  # Currently only works for PostgreSQL.
+  # Currently only works for PostgreSQL via ActiveRecord.
   class DbDriver
     def initialize
       @sequence_names = {}
@@ -29,13 +29,16 @@ module Vorpal
 
     # Loads instances of the given class by primary key.
     #
+    # @param class_config [ClassConfig]
     # @return [[Object]] An array of entities.
     def load_by_id(class_config, ids)
-      class_config.db_class.where(id: ids)
+      class_config.db_class.where(id: ids).all
     end
 
     # Loads instances of the given class whose foreign key has the given value.
     #
+    # @param class_config [ClassConfig]
+    # @param foreign_key_info [ForeignKeyInfo]
     # @return [[Object]] An array of entities.
     def load_by_foreign_key(class_config, id, foreign_key_info)
       arel = class_config.db_class.where(foreign_key_info.fk_column => id)
@@ -45,6 +48,7 @@ module Vorpal
 
     # Fetches primary key values to be used for new entities.
     #
+    # @param class_config [ClassConfig] Config of the entity whose primary keys are being fetched.
     # @return [[Integer]] An array of unused primary keys.
     def get_primary_keys(class_config, count)
       result = execute("select nextval($1) from generate_series(1,$2);", [sequence_name(class_config), count])
@@ -53,6 +57,7 @@ module Vorpal
 
     # Builds an ORM Class for accessing data in the given DB table.
     #
+    # @param table_name [String] Name of the DB table the DB class should interface with.
     # @return [Class] ActiveRecord::Base Class
     def build_db_class(table_name)
       db_class = Class.new(ActiveRecord::Base)
@@ -60,6 +65,13 @@ module Vorpal
       db_class
     end
 
+    # Builds a composable query object (e.g. ActiveRecord::Relation) with Vorpal methods mixed in.
+    #
+    # @param class_config [ClassConfig] Config of the entity whose db representations should be returned.
+    def query(class_config)
+      class_config.db_class.unscoped.extending(ArelQueryMethods.new(self))
+    end
+
     private
 
     def sequence_name(class_config)
@@ -74,4 +86,33 @@ module Vorpal
       ActiveRecord::Base.connection.exec_query(sql, 'SQL', binds)
     end
   end
+
+  class ArelQueryMethods < Module
+    def initialize(repository)
+      @repository = repository
+    end
+
+    def extended(descendant)
+      super
+      descendant.extend(Methods)
+      descendant.vorpal_aggregate_repository = @repository
+    end
+
+    # Methods in this module will appear on any composable
+    module Methods
+      attr_writer :vorpal_aggregate_repository
+
+      # See {AggregateRepository#load_many}.
+      def load_many
+        db_roots = self.all
+        @vorpal_aggregate_repository.load_many(db_roots)
+      end
+
+      # See {AggregateRepository#load_one}.
+      def load_one
+        db_root = self.first
+        @vorpal_aggregate_repository.load_one(db_root)
+      end
+    end
+  end
 end

data/lib/vorpal/db_loader.rb

@@ -13,9 +13,15 @@ module Vorpal
     end
 
     def load_from_db(ids, config)
+      db_roots = @db_driver.load_by_id(config, ids)
+      load_from_db_objects(db_roots, config)
+    end
+
+    def load_from_db_objects(db_roots, config)
       @loaded_objects = LoadedObjects.new
+      @loaded_objects.add(config, db_roots)
       @lookup_instructions = LookupInstructions.new
-      @lookup_instructions.lookup_by_id(config, ids)
+      explore_objects(config, db_roots)
 
       until @lookup_instructions.empty?
         lookup = @lookup_instructions.next_lookup