vorpal 0.0.5.1 → 0.0.6.rc1

data/lib/vorpal/aggregate_traversal.rb

@@ -0,0 +1,50 @@
+module Vorpal
+# @private
+class AggregateTraversal
+  def initialize(configs)
+    @configs = configs
+  end
+
+  # Traversal should always begin with an object that is known to be
+  # able to reach all other objects in the aggregate (like the root!)
+  def accept(object, visitor, already_visited=[])
+    return if object.nil?
+
+    config = @configs.config_for(object.class)
+    return if config.nil?
+
+    return if already_visited.include?(object)
+    already_visited << object
+
+    visitor.visit_object(object, config)
+
+    config.belongs_tos.each do |belongs_to_config|
+      child = belongs_to_config.get_child(object)
+      accept(child, visitor, already_visited) if visitor.continue_traversal?(belongs_to_config)
+    end
+
+    config.has_ones.each do |has_one_config|
+      child = has_one_config.get_child(object)
+      accept(child, visitor, already_visited) if visitor.continue_traversal?(has_one_config)
+    end
+
+    config.has_manys.each do |has_many_config|
+      children = has_many_config.get_children(object)
+      children.each do |child|
+        accept(child, visitor, already_visited) if visitor.continue_traversal?(has_many_config)
+      end
+    end
+  end
+end
+
+# @private
+module AggregateVisitorTemplate
+  def visit_object(object, config)
+    # override me!
+  end
+
+  def continue_traversal?(association_config)
+    true
+  end
+end
+end

data/lib/vorpal/aggregate_utils.rb

@@ -0,0 +1,37 @@
+require 'vorpal/aggregate_traversal'
+
+module Vorpal
+  module AggregateUtils
+    extend self
+
+    def group_by_type(roots, configs)
+      traversal = AggregateTraversal.new(configs)
+
+      all = roots.flat_map do |root|
+        owned_object_visitor = OwnedObjectVisitor.new
+        traversal.accept(root, owned_object_visitor)
+        owned_object_visitor.owned_objects
+      end
+
+      all.group_by { |obj| configs.config_for(obj.class) }
+    end
+  end
+
+  # @private
+  class OwnedObjectVisitor
+    include AggregateVisitorTemplate
+    attr_reader :owned_objects
+
+    def initialize
+      @owned_objects = []
+    end
+
+    def visit_object(object, config)
+      @owned_objects << object
+    end
+
+    def continue_traversal?(association_config)
+      association_config.owned
+    end
+  end
+end

data/lib/vorpal/config_builder.rb

@@ -135,13 +135,13 @@ class ConfigBuilder
 
   def serializer(attrs)
     Class.new(SimpleSerializer::Serializer) do
-      hash_attributes *attrs
+      attributes *attrs
     end
   end
 
   def deserializer(attrs)
     Class.new(SimpleSerializer::Deserializer) do
-      object_attributes *attrs
+      data_attributes *attrs
     end
   end
 end

data/lib/vorpal/configs.rb

@@ -1,4 +1,5 @@
-require 'vorpal/hash_initialization'
+require 'vorpal/util/hash_initialization'
+require 'equalizer'
 
 module Vorpal
 
@@ -39,6 +40,7 @@ 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
 
@@ -52,33 +54,6 @@ class ClassConfig
     end
   end
 
-  def get_primary_keys(count)
-    result = ActiveRecord::Base.connection.execute("select nextval('#{sequence_name}') from generate_series(1,#{count});")
-    result.column_values(0).map(&:to_i)
-  end
-
-  def find_in_db(object)
-    load_by_id(object.id)
-  end
-
-  def load_by_id(id)
-    db_class.where(id: id).first
-  end
-
-  def load_by_foreign_key(id, foreign_key_info)
-    arel = db_class.where(foreign_key_info.fk_column => id)
-    arel = arel.where(foreign_key_info.fk_type_column => foreign_key_info.fk_type) if foreign_key_info.polymorphic?
-    arel.order(:id).all
-  end
-
-  def destroy(db_object)
-    db_object.destroy
-  end
-
-  def save(db_object)
-    db_object.save!
-  end
-
   def build_db_object(attributes)
     db_class.new(attributes)
   end
@@ -112,15 +87,15 @@ class ClassConfig
     db_object.send(field)
   end
 
-  private
-
-  def sequence_name
-    "#{db_class.table_name}_id_seq"
+  def table_name
+    db_class.table_name
   end
 end
 
 # @private
 class ForeignKeyInfo
+  include Equalizer.new(:fk_column, :fk_type_column, :fk_type)
+
   attr_reader :fk_column, :fk_type_column, :fk_type, :polymorphic
 
   def initialize(fk_column, fk_type_column, fk_type, polymorphic)
@@ -133,6 +108,10 @@ class ForeignKeyInfo
   def polymorphic?
     @polymorphic
   end
+
+  def matches_polymorphic_type?(db_object)
+    db_object.send(fk_type_column) == fk_type
+  end
 end
 
 # @private
@@ -157,33 +136,20 @@ class RelationalAssociation
     local_config.set_field(local_db_model, fk_type, remote_model.class.name) if polymorphic?
   end
 
-  def load_locals(remote_db_model)
-    id = remote_db_model.id
-    # TODO: this method should probably be able to determine the config for the remote models
-    raise "Only supports having one remote configuration when navigating from the remote side to the local side of an association." if remote_configs.size != 1
-    remote_config = remote_configs.first
-    local_config.load_by_foreign_key(id, foreign_key_info(remote_config))
-  end
-
-  def load_remote(local_db_model)
-    remote_config = polymorphic? ? remote_config_for_local_db_object(local_db_model) : remote_configs.first
-    remote_config.load_by_id(get_foreign_key(local_db_model))
+  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
 
-  private
-
   def polymorphic?
     !fk_type.nil?
   end
 
-  def foreign_key_info(class_config)
-    ForeignKeyInfo.new(fk, fk_type, class_config.domain_class.name, polymorphic?)
+  def foreign_key_info(remote_class_config)
+    ForeignKeyInfo.new(fk, fk_type, remote_class_config.domain_class.name, polymorphic?)
   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
+  private
 
   def get_foreign_key(local_db_model)
     local_config.get_field(local_db_model, fk)
@@ -196,6 +162,7 @@ class HasManyConfig
   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
 
@@ -211,36 +178,57 @@ class HasManyConfig
     @relational_association.set_foreign_key(db_child, parent)
   end
 
-  def load_children(db_parent)
-    @relational_association.load_locals(db_parent)
+  def associated?(db_parent, db_child)
+    return false if child_config.db_class != db_child.class
+    db_child.send(fk) == db_parent.id
   end
-end
 
-# @private
-class BelongsToConfig
-  include HashInitialization
-  attr_reader :name, :owned, :fk, :fk_type, :child_classes
-
-  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 child_config
+    @relational_association.local_config
   end
 
-  def get_child(parent)
-    parent.send(name)
+  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_child(parent, child)
-    parent.send("#{name}=", 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)
+    end
 
-  def set_foreign_key(db_parent, child)
-    @relational_association.set_foreign_key(db_parent, child)
-  end
+    def get_child(parent)
+      parent.send(name)
+    end
+
+    def set_child(parent, child)
+      parent.send("#{name}=", child)
+    end
 
-  def load_child(db_parent)
-    @relational_association.load_remote(db_parent)
+    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
+    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
+      end
+    end
+
+    def fk_value(db_parent)
+      db_parent.send(fk)
+    end
   end
-end
 
 # @private
 class HasOneConfig
@@ -248,6 +236,7 @@ class HasOneConfig
   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
 
@@ -263,8 +252,18 @@ class HasOneConfig
     @relational_association.set_foreign_key(db_child, parent)
   end
 
-  def load_child(db_parent)
-    @relational_association.load_locals(db_parent).first
+  def associated?(db_parent, db_child)
+    return false if child_config.db_class != db_child.class
+    db_child.send(fk) == db_parent.id
+  end
+
+  def child_config
+    @relational_association.local_config
+  end
+
+  def foreign_key_info
+    @relational_association.foreign_key_info(@parent_config)
   end
 end
+
 end

data/lib/vorpal/db_driver.rb

@@ -0,0 +1,50 @@
+module Vorpal
+module DbDriver
+  extend self
+
+  def insert(config, db_objects)
+    if defined? ActiveRecord::Import
+      config.db_class.import db_objects
+    else
+      db_objects.each do |db_object|
+        db_object.save!
+      end
+    end
+  end
+
+  def update(config, db_objects)
+    db_objects.each do |db_object|
+      db_object.save!
+    end
+  end
+
+  def destroy(config, db_objects)
+    config.db_class.delete_all(id: db_objects.map(&:id))
+  end
+
+  def load_by_id(config, ids)
+    config.db_class.where(id: ids)
+  end
+
+  def load_by_foreign_key(config, id, foreign_key_info)
+    arel = config.db_class.where(foreign_key_info.fk_column => id)
+    arel = arel.where(foreign_key_info.fk_type_column => foreign_key_info.fk_type) if foreign_key_info.polymorphic?
+    arel.order(:id).all
+  end
+
+  def get_primary_keys(config, count)
+    result = execute("select nextval('#{sequence_name(config)}') from generate_series(1,#{count});")
+    result.column_values(0).map(&:to_i)
+  end
+
+  private
+
+  def execute(sql)
+    ActiveRecord::Base.connection.execute(sql)
+  end
+
+  def sequence_name(config)
+    "#{config.table_name}_id_seq"
+  end
+end
+end

data/lib/vorpal/db_loader.rb

@@ -0,0 +1,131 @@
+require 'vorpal/loaded_objects'
+require 'vorpal/util/array_hash'
+require 'vorpal/db_driver'
+
+module Vorpal
+
+# @private
+class DbLoader
+  def initialize(configs, only_owned)
+    @configs = configs
+    @only_owned = only_owned
+  end
+
+  def load_from_db(ids, domain_class)
+    config = @configs.config_for(domain_class)
+    @loaded_objects = LoadedObjects.new
+    @lookup_instructions = LookupInstructions.new
+    @lookup_instructions.lookup_by_id(config, ids)
+
+    until @lookup_instructions.empty?
+      lookup = @lookup_instructions.next_lookup
+      new_objects = lookup.load_all
+      @loaded_objects.add(lookup.config, new_objects)
+      explore_objects(new_objects)
+    end
+
+    @loaded_objects
+  end
+
+  private
+
+  def explore_objects(objects_to_explore)
+    objects_to_explore.each do |db_object|
+      config = @configs.config_for_db(db_object.class)
+      config.has_manys.each do |has_many_config|
+        lookup_by_fk(db_object, has_many_config) if explore_association?(has_many_config)
+      end
+
+      config.has_ones.each do |has_one_config|
+        lookup_by_fk(db_object, has_one_config) if explore_association?(has_one_config)
+      end
+
+      config.belongs_tos.each do |belongs_to_config|
+        lookup_by_id(db_object, belongs_to_config) if explore_association?(belongs_to_config)
+      end
+    end
+  end
+
+  def explore_association?(association_config)
+    !@only_owned || association_config.owned == true
+  end
+
+  def lookup_by_id(db_object, belongs_to_config)
+    child_config = belongs_to_config.child_config(db_object)
+    id = belongs_to_config.fk_value(db_object)
+    return if @loaded_objects.id_lookup_done?(child_config, id)
+    @lookup_instructions.lookup_by_id(child_config, id)
+  end
+
+  def lookup_by_fk(db_object, has_many_config)
+    child_config = has_many_config.child_config
+    fk_info = has_many_config.foreign_key_info
+    fk_value = db_object.id
+    return if @loaded_objects.fk_lookup_done?(child_config, fk_info, fk_value)
+    @lookup_instructions.lookup_by_fk(child_config, fk_info, fk_value)
+  end
+end
+
+# @private
+class LookupInstructions
+  include ArrayHash
+  def initialize
+    @lookup_by_id = {}
+    @lookup_by_fk = {}
+  end
+
+  def lookup_by_id(config, ids)
+    add_to_hash(@lookup_by_id, config, Array(ids))
+  end
+
+  def lookup_by_fk(config, fk_info, fk_value)
+    add_to_hash(@lookup_by_fk, [config, fk_info], fk_value)
+  end
+
+  def next_lookup
+    if @lookup_by_id.empty?
+      config, fk_info = @lookup_by_fk.first.first
+      fk_values = @lookup_by_fk.delete([config, fk_info])
+      LookupByFk.new(config, fk_info, fk_values)
+    else
+      config = @lookup_by_id.first.first
+      ids = @lookup_by_id.delete(config)
+      LookupById.new(config, ids)
+    end
+  end
+
+  def empty?
+    @lookup_by_id.empty? && @lookup_by_fk.empty?
+  end
+end
+
+# @private
+class LookupById
+  attr_reader :config
+  def initialize(config, ids)
+    @config = config
+    @ids = ids
+  end
+
+  def load_all
+    return [] if @ids.empty?
+    DbDriver.load_by_id(@config, @ids)
+  end
+end
+
+# @private
+class LookupByFk
+  attr_reader :config
+  def initialize(config, fk_info, fk_values)
+    @config = config
+    @fk_info = fk_info
+    @fk_values = fk_values
+  end
+
+  def load_all
+    return [] if @fk_values.empty?
+    DbDriver.load_by_foreign_key(@config, @fk_values, @fk_info)
+  end
+end
+
+end