vorpal 0.0.6.rc2 → 0.0.6.rc3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZjNjZWQxNmI3MGUyNDY3ZGM1MTFlNzVlMTRhNTMwMjZkNDczNWIzNg==
+    NDJjYTFiMjk0N2U4NmYxYjI4NGIwMmY0N2VkOWZiYjRjZjI4OTFlOA==
   data.tar.gz: !binary |-
-    MDNmMmQ5OWZjNjQ3NGY5ZWY4ZDg1NzkwMGQyMWJhZThkYjBlMGY0ZQ==
+    OWJjZDM0Y2JiMGIzNGNlY2MxOWFmNDQwYWUyZTRiMDJiNDBkNmZmYw==
 SHA512:
   metadata.gz: !binary |-
-    OGU3YWE5MDdkYmY4NjIwMDA2ZDY5YWIwNGY1NzdkNjIyYzY0YzQ3ZGUwNDY5
-    ZmI5NGYyYjRlYzU4NWY2NTk1ZmY5NWQ5ODVhNzEwODJjY2I3YzZmZmE4ODg0
-    N2RmNGNkNjAzODIxZGIwN2NiYzcyZGE5MTM4ZmI5NDZiYjM4OWQ=
+    NmU3YTQ2OGNkYzZjNTM3ODMxODc5NjlhZjFhOWFlMmNkMjRmMzg1NGE0ZGRm
+    MGY3MWRlZjM0ZjFlOWFhNzI0N2Q2MzMwODMyYzFkODJlMzExZjBmZTAzNGE0
+    NmUzODFkMWU3M2IzN2NhODA3YzZhMDU1OTllZjEyNzJlY2Q0ODI=
   data.tar.gz: !binary |-
-    NDBjMzIzYTcwYmQyMzI2MDM2ZmJjYjY4NmUzNWU0NjhiYzVkMDkyYTA0Y2M4
-    OTQ2OTYyOWUxYWE2MDg1ZGI0MzUxNjYyMzEyMDJhZjNlNzk3MDIzMTVmMWEx
-    ZTc3YTg5MzAyNDMyNzEwMDc1NzY3N2I0YTJlMzJhNGRiNmNhOWY=
+    MWY5NzQ0N2Q2NjE5NDI4MmE4MzRmMDM4ZjI3M2M4NjQ1MTBhYzA4MWY3YTJm
+    YmQxNDI2MTcwOWRkYmRlNjcwYTNiN2E4N2I1ZWU4ZmZiYTZkMWU1ZDE2NmZh
+    NjA0OWJmMDg2Y2M4NDYzYzVhNjg5MTE0YTAzMTg4NDkzOTNmNTQ=

data/lib/vorpal/aggregate_repository.rb

@@ -6,8 +6,9 @@ require 'vorpal/db_driver'
 module Vorpal
 class AggregateRepository
   # @private
-  def initialize(class_configs)
-    configure(class_configs)
+  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
@@ -76,11 +77,11 @@ class AggregateRepository
   #   operation.
   # @return [[Object]] Entities with the given primary key values and type.
   def load_all(ids, domain_class, identity_map=IdentityMap.new)
-    db_objects = load_from_db(ids, domain_class).all_objects
-    deserialize(db_objects, identity_map)
-    set_associations(db_objects, identity_map)
+    loaded_db_objects = load_from_db(ids, domain_class)
+    objects = deserialize(loaded_db_objects, identity_map)
+    set_associations(loaded_db_objects, identity_map)
 
-    identity_map.map_raw(ids, @configs.config_for(domain_class).db_class)
+    objects.select { |obj| obj.class == domain_class }
   end
 
   # Removes an aggregate from the DB. Even if the aggregate contains unsaved
@@ -101,7 +102,7 @@ class AggregateRepository
     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|
-      DbDriver.destroy(config, db_objects)
+      @db_driver.destroy(config.db_class, db_objects)
     end
     roots
   end
@@ -113,62 +114,36 @@ class AggregateRepository
   end
 
   def load_from_db(ids, domain_class, only_owned=false)
-    DbLoader.new(@configs, only_owned).load_from_db(ids, domain_class)
+    DbLoader.new(@configs, only_owned, @db_driver).load_from_db(ids, domain_class)
   end
 
   def load_owned_from_db(ids, domain_class)
     load_from_db(ids, domain_class, true)
   end
 
-  def deserialize(db_objects, identity_map)
-    db_objects.each do |db_object|
-      # TODO: There is probably a bug here when you have something in the IdentityMap that is stale.
-      identity_map.get_and_set(db_object) { @configs.config_for_db(db_object.class).deserialize(db_object) }
-    end
-  end
-
-  def set_associations(db_objects, identity_map)
-    db_objects.each do |db_object|
-      config = @configs.config_for_db(db_object.class)
-      config.has_manys.each do |has_many_config|
-        db_children = find_associated(db_object, has_many_config, db_objects)
-        associate_one_to_many(db_object, db_children, has_many_config, identity_map)
-      end
-
-      config.has_ones.each do |has_one_config|
-        db_children = find_associated(db_object, has_one_config, db_objects)
-        associate_one_to_one(db_object, db_children.first, has_one_config, identity_map)
-      end
-
-      config.belongs_tos.each do |belongs_to_config|
-        db_children = find_associated(db_object, belongs_to_config, db_objects)
-        associate_one_to_one(db_object, db_children.first, belongs_to_config, identity_map)
+  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 find_associated(db_object, association_config, db_objects)
-    db_objects.find_all do |db_child|
-      association_config.associated?(db_object, db_child)
+  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 associate_one_to_many(db_object, db_children, one_to_many, identity_map)
-    parent = identity_map.get(db_object)
-    children = identity_map.map(db_children)
-    one_to_many.set_children(parent, children)
-  end
-
-  def associate_one_to_one(db_parent, db_child, one_to_one_config, identity_map)
-    parent = identity_map.get(db_parent)
-    child = identity_map.get(db_child)
-    one_to_one_config.set_child(parent, child)
-  end
-
-  def configure(class_configs)
-    @configs = MasterConfig.new(class_configs)
-  end
-
   def serialize(owned_objects, mapping, loaded_db_objects)
     owned_objects.each do |config, objects|
       objects.each do |object|
@@ -184,7 +159,7 @@ class AggregateRepository
       if object.id.nil?
         config.build_db_object(attributes)
       else
-        db_object = loaded_db_objects.find_by_id(object, config)
+        db_object = loaded_db_objects.find_by_id(config, object.id)
         config.set_db_object_attributes(db_object, attributes)
         db_object
       end
@@ -196,7 +171,7 @@ class AggregateRepository
   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 = DbDriver.get_primary_keys(config, in_need_of_primary_keys.length)
+      primary_keys = @db_driver.get_primary_keys(config.db_class, 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
@@ -237,11 +212,11 @@ class AggregateRepository
     owned_objects.each do |config, objects|
       objects_to_insert = grouped_new_objects[config] || []
       db_objects_to_insert = objects_to_insert.map { |obj| mapping[obj] }
-      DbDriver.insert(config, db_objects_to_insert)
+      @db_driver.insert(config.db_class, db_objects_to_insert)
 
       objects_to_update = objects - objects_to_insert
       db_objects_to_update = objects_to_update.map { |obj| mapping[obj] }
-      DbDriver.update(config, db_objects_to_update)
+      @db_driver.update(config.db_class, db_objects_to_update)
     end
   end
 
@@ -249,9 +224,9 @@ class AggregateRepository
     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(o.class) }
+    grouped_orphans = all_orphans.group_by { |o| @configs.config_for_db_object(o) }
     grouped_orphans.each do |config, orphans|
-      DbDriver.destroy(config, orphans)
+      @db_driver.destroy(config.db_class, orphans)
     end
   end
 

data/lib/vorpal/configs.rb

@@ -2,268 +2,278 @@ require 'vorpal/util/hash_initialization'
 require 'equalizer'
 
 module Vorpal
+  # @private
+  class MasterConfig
+    def initialize(class_configs)
+      @class_configs = class_configs
+      initialize_association_configs
+    end
 
-# @private
-class MasterConfig
-  def initialize(class_configs)
-    @class_configs = class_configs
-    initialize_association_configs
-  end
-
-  def config_for(clazz)
-    @class_configs.detect { |conf| conf.domain_class == clazz }
-  end
+    def config_for(clazz)
+      @class_configs.detect { |conf| conf.domain_class == clazz }
+    end
 
-  def config_for_db(clazz)
-    @class_configs.detect { |conf| conf.db_class == clazz }
-  end
+    def config_for_db_object(db_object)
+      @class_configs.detect { |conf| conf.db_class == db_object.class }
+    end
 
-  private
+    private
+
+    def initialize_association_configs
+      association_configs = {}
+      @class_configs.each do |config|
+        (config.has_ones + config.has_manys).each do |association_end_config|
+          child_config = config_for(association_end_config.child_class)
+          association_end_config.set_parent_class_config(config)
+
+          association_config = build_association_config(association_configs, child_config, association_end_config.fk, association_end_config.fk_type)
+          association_config.remote_end_config = association_end_config
+          association_config.add_remote_class_config(config)
+          association_end_config.association_config = association_config
+        end
+
+        config.belongs_tos.each do |association_end_config|
+          child_configs = association_end_config.child_classes.map(&method(:config_for))
+
+          association_config = build_association_config(association_configs, config, association_end_config.fk, association_end_config.fk_type)
+          association_config.local_end_config = association_end_config
+          association_config.add_remote_class_config(child_configs)
+          association_end_config.association_config = association_config
+        end
+      end
 
-  def initialize_association_configs
-    @class_configs.each do |config|
-      (config.has_ones + config.has_manys).each do |association_config|
-        association_config.init_relational_association(
-          config_for(association_config.child_class),
-          config
-        )
+      association_configs.values.each do |association_config|
+        association_config.local_class_config.local_association_configs << association_config
       end
-      config.belongs_tos.each do |association_config|
-        association_config.init_relational_association(
-          association_config.child_classes.map(&method(:config_for)),
-          config
-        )
+    end
+
+    def build_association_config(association_configs, local_config, fk, fk_type)
+      association_config = AssociationConfig.new(local_config, fk, fk_type)
+      if association_configs[association_config]
+        association_config = association_configs[association_config]
+      else
+        association_configs[association_config] = association_config
       end
+      association_config
     end
   end
-end
-
-# @private
-class ClassConfig
-  include Equalizer.new(:domain_class, :db_class)
-  attr_reader :serializer, :deserializer, :domain_class, :db_class
-  attr_accessor :has_manys, :belongs_tos, :has_ones
 
-  def initialize(attrs)
-    @has_manys = []
-    @belongs_tos = []
-    @has_ones = []
-
-    attrs.each do |k,v|
-      instance_variable_set("@#{k}", v)
+  # @private
+  # Object associations:
+  # - All object associations are uni-directional
+  # - The end that holds the association is the 'Parent' and the end that
+  #   is referred to is the 'Child' or 'Children'
+  #
+  # Relational associations:
+  # - Local end: has FK
+  # - Remote end: has no FK
+  #
+  class AssociationConfig
+    include Equalizer.new(:local_class_config, :fk)
+
+    attr_reader :local_class_config, :remote_class_configs, :fk
+
+    # Only one of these two fields needs to be specified
+    # If one is specified, then the association is uni-directional.
+    # If both are specified, then the association is bi-directional.
+    attr_accessor :local_end_config, :remote_end_config
+
+    def initialize(local_class_config, fk, fk_type)
+      @local_class_config = local_class_config
+      @remote_class_configs = {}
+      @fk = fk
+      @fk_type = fk_type
     end
-  end
 
-  def build_db_object(attributes)
-    db_class.new(attributes)
-  end
+    def fk_value(local_db_object)
+      local_db_object.send(fk)
+    end
 
-  def set_db_object_attributes(db_object, attributes)
-    db_object.attributes = attributes
-  end
+    def associate(local_object, remote_object)
+      local_end_config.associate(local_object, remote_object) if local_end_config && local_object
+      remote_end_config.associate(remote_object, local_object) if remote_end_config && remote_object
+    end
 
-  def get_db_object_attributes(db_object)
-    db_object.attributes.symbolize_keys
-  end
+    def add_remote_class_config(remote_class_configs)
+      Array(remote_class_configs).each do |remote_class_config|
+        @remote_class_configs[remote_class_config.domain_class.name] = remote_class_config
+      end
+    end
 
-  def serialization_required?
-    !(domain_class < ActiveRecord::Base)
-  end
+    def remote_class_config(local_db_object)
+      if polymorphic?
+        fk_type_value = local_db_object.send(@fk_type)
+        @remote_class_configs[fk_type_value]
+      else
+        @remote_class_configs.values.first
+      end
+    end
 
-  def serialize(object)
-    serializer.serialize(object)
-  end
+    def polymorphic?
+      !@fk_type.nil?
+    end
 
-  def deserialize(db_object)
-    attributes = get_db_object_attributes(db_object)
-    serialization_required? ? deserializer.deserialize(domain_class.new, attributes) : db_object
-  end
+    def set_foreign_key(local_db_object, remote_object)
+      local_class_config.set_field(local_db_object, @fk, remote_object.try(:id))
+      local_class_config.set_field(local_db_object, @fk_type, remote_object.class.name) if polymorphic?
+    end
 
-  def set_field(db_object, field, value)
-    db_object.send("#{field}=", value)
+    def foreign_key_info(remote_class_config)
+      ForeignKeyInfo.new(@fk, @fk_type, remote_class_config.domain_class.name, polymorphic?)
+    end
   end
 
-  def get_field(db_object, field)
-    db_object.send(field)
-  end
+  # @private
+  class ClassConfig
+    include Equalizer.new(:domain_class, :db_class)
+    attr_reader :serializer, :deserializer, :domain_class, :db_class, :local_association_configs
+    attr_accessor :has_manys, :belongs_tos, :has_ones
 
-  def table_name
-    db_class.table_name
-  end
-end
+    def initialize(attrs)
+      @has_manys = []
+      @belongs_tos = []
+      @has_ones = []
+      @local_association_configs = []
 
-# @private
-class ForeignKeyInfo
-  include Equalizer.new(:fk_column, :fk_type_column, :fk_type)
+      attrs.each do |k,v|
+        instance_variable_set("@#{k}", v)
+      end
+    end
 
-  attr_reader :fk_column, :fk_type_column, :fk_type, :polymorphic
+    def build_db_object(attributes)
+      db_class.new(attributes)
+    end
 
-  def initialize(fk_column, fk_type_column, fk_type, polymorphic)
-    @fk_column = fk_column
-    @fk_type_column = fk_type_column
-    @fk_type = fk_type
-    @polymorphic = polymorphic
-  end
+    def set_db_object_attributes(db_object, attributes)
+      db_object.attributes = attributes
+    end
 
-  def polymorphic?
-    @polymorphic
-  end
+    def get_db_object_attributes(db_object)
+      db_object.attributes.symbolize_keys
+    end
 
-  def matches_polymorphic_type?(db_object)
-    db_object.send(fk_type_column) == fk_type
-  end
-end
+    def serialization_required?
+      !(domain_class < ActiveRecord::Base)
+    end
 
-# @private
-# Object associations:
-# - All object associations are uni-directional
-# - The end that holds the association is the 'Parent' and the end that
-#   is referred to is the 'Child' or 'Children'
-#
-# Relational associations:
-# - Local end: has FK
-# - Remote end: has no FK
-#
-class RelationalAssociation
-  include HashInitialization
-  attr_reader :fk, :fk_type, :local_config, :remote_configs
-
-  # Can't pass in a remote db model for last param because when saving we only have
-  # a db model if the model is part of the aggregate and not just referenced by the
-  # aggregate
-  def set_foreign_key(local_db_model, remote_model)
-    local_config.set_field(local_db_model, fk, remote_model.try(:id))
-    local_config.set_field(local_db_model, fk_type, remote_model.class.name) if polymorphic?
-  end
+    def serialize(object)
+      serializer.serialize(object)
+    end
 
-  def remote_config_for_local_db_object(local_db_model)
-    class_name = local_config.get_field(local_db_model, fk_type)
-    remote_configs.detect { |config| config.domain_class.name == class_name }
-  end
+    def deserialize(db_object)
+      attributes = get_db_object_attributes(db_object)
+      serialization_required? ? deserializer.deserialize(domain_class.new, attributes) : db_object
+    end
 
-  def polymorphic?
-    !fk_type.nil?
-  end
+    def set_field(db_object, field, value)
+      db_object.send("#{field}=", value)
+    end
 
-  def foreign_key_info(remote_class_config)
-    ForeignKeyInfo.new(fk, fk_type, remote_class_config.domain_class.name, polymorphic?)
+    def get_field(db_object, field)
+      db_object.send(field)
+    end
   end
 
-  private
+  # @private
+  class ForeignKeyInfo
+    include Equalizer.new(:fk_column, :fk_type_column, :fk_type)
 
-  def get_foreign_key(local_db_model)
-    local_config.get_field(local_db_model, fk)
-  end
-end
+    attr_reader :fk_column, :fk_type_column, :fk_type, :polymorphic
 
-# @private
-class HasManyConfig
-  include HashInitialization
-  attr_reader :name, :owned, :fk, :fk_type, :child_class
+    def initialize(fk_column, fk_type_column, fk_type, polymorphic)
+      @fk_column = fk_column
+      @fk_type_column = fk_type_column
+      @fk_type = fk_type
+      @polymorphic = polymorphic
+    end
 
-  def init_relational_association(child_config, parent_config)
-    @parent_config = parent_config
-    @relational_association = RelationalAssociation.new(fk: fk, fk_type: fk_type, local_config: child_config, remote_configs: [parent_config])
+    def polymorphic?
+      @polymorphic
+    end
   end
 
-  def get_children(parent)
-    parent.send(name)
-  end
+  module RemoteEndConfig
+    def child_config
+      association_config.local_class_config
+    end
 
-  def set_children(parent, children)
-    parent.send("#{name}=", children)
-  end
+    def set_foreign_key(db_child, parent)
+      association_config.set_foreign_key(db_child, parent)
+    end
 
-  def set_foreign_key(db_child, parent)
-    @relational_association.set_foreign_key(db_child, parent)
-  end
+    def set_parent_class_config(parent_config)
+      @parent_config = parent_config
+    end
 
-  def associated?(db_parent, db_child)
-    return false if child_config.db_class != db_child.class
-    db_child.send(fk) == db_parent.id
+    def foreign_key_info
+      association_config.foreign_key_info(@parent_config)
+    end
   end
 
-  def child_config
-    @relational_association.local_config
-  end
+  module LocalEndConfig
+    def child_config(db_parent)
+      association_config.remote_class_config(db_parent)
+    end
 
-  def foreign_key_info
-    @relational_association.foreign_key_info(@parent_config)
-  end
-end
-# @private
-  class BelongsToConfig
-    include HashInitialization
-    attr_reader :name, :owned, :fk, :fk_type, :child_classes
+    def set_foreign_key(db_parent, child)
+      association_config.set_foreign_key(db_parent, child)
+    end
 
-    def init_relational_association(child_configs, parent_config)
-      @relational_association = RelationalAssociation.new(fk: fk, fk_type: fk_type, local_config: parent_config, remote_configs: child_configs)
+    def fk_value(db_parent)
+      db_parent.send(fk)
     end
+  end
 
+  module ToOneConfig
     def get_child(parent)
       parent.send(name)
     end
 
-    def set_child(parent, child)
+    def associate(parent, child)
       parent.send("#{name}=", child)
     end
+  end
 
-    def set_foreign_key(db_parent, child)
-      @relational_association.set_foreign_key(db_parent, child)
-    end
-
-    def associated?(db_parent, db_child)
-      return false if child_config(db_parent).db_class != db_child.class
-      fk_value(db_parent) == db_child.id
+  module ToManyConfig
+    def get_children(parent)
+      parent.send(name)
     end
 
-    def child_config(db_parent)
-      if @relational_association.polymorphic?
-        @relational_association.remote_config_for_local_db_object(db_parent)
-      else
-        @relational_association.remote_configs.first
+    def associate(parent, child)
+      if get_children(parent).nil?
+        parent.send("#{name}=", [])
       end
+      get_children(parent) << child
     end
-
-    def fk_value(db_parent)
-      db_parent.send(fk)
-    end
-  end
-
-# @private
-class HasOneConfig
-  include HashInitialization
-  attr_reader :name, :owned, :fk, :fk_type, :child_class
-
-  def init_relational_association(child_config, parent_config)
-    @parent_config = parent_config
-    @relational_association = RelationalAssociation.new(fk: fk, fk_type: fk_type, local_config: child_config, remote_configs: [parent_config])
   end
 
-  def get_child(parent)
-    parent.send(name)
-  end
+  # @private
+  class HasManyConfig
+    include HashInitialization
+    include RemoteEndConfig
+    include ToManyConfig
 
-  def set_child(parent, child)
-    parent.send("#{name}=", child)
+    attr_reader :name, :owned, :fk, :fk_type, :child_class
+    attr_accessor :association_config
   end
 
-  def set_foreign_key(db_child, parent)
-    @relational_association.set_foreign_key(db_child, parent)
-  end
+  # @private
+  class BelongsToConfig
+    include HashInitialization
+    include LocalEndConfig
+    include ToOneConfig
 
-  def associated?(db_parent, db_child)
-    return false if child_config.db_class != db_child.class
-    db_child.send(fk) == db_parent.id
+    attr_reader :name, :owned, :fk, :fk_type, :child_classes
+    attr_accessor :association_config
   end
 
-  def child_config
-    @relational_association.local_config
-  end
+  # @private
+  class HasOneConfig
+    include HashInitialization
+    include RemoteEndConfig
+    include ToOneConfig
 
-  def foreign_key_info
-    @relational_association.foreign_key_info(@parent_config)
+    attr_reader :name, :owned, :fk, :fk_type, :child_class
+    attr_accessor :association_config
   end
 end
-
-end