vorpal 0.0.6.rc4 → 0.0.6

data/lib/vorpal/configuration.rb

@@ -2,49 +2,52 @@ require 'vorpal/aggregate_repository'
 require 'vorpal/config_builder'
 
 module Vorpal
+  module Configuration
 
-module Configuration
+    # Configures and creates a {Vorpal::AggregateRepository} 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}.
+    #
+    # @return [Vorpal::AggregateRepository] Repository instance.
+    def define(options={}, &block)
+      master_config = build_config(&block)
+      db_driver = options.fetch(:db_driver, DbDriver.new)
+      AggregateRepository.new(db_driver, master_config)
+    end
 
-  # Configures and creates a {Vorpal::AggregateRepository} 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.
-  #
-  # @return [Vorpal::AggregateRepository] Repository instance.
-  def define(options={}, &block)
-    master_config = build_config(&block)
-    db_driver = options.fetch(:db_driver, DbDriver.new)
-    AggregateRepository.new(db_driver, master_config)
-  end
-
-  # Maps a domain class to a relational table.
-  #
-  # @param domain_class [Class] Type of the domain model to be mapped
-  # @param options [Hash] Configure how to map the domain model
-  # @option options [String] :to (Class with the same name as the domain class with a 'DB' appended.)
-  #   Class of the ActiveRecord object that will map this domain class to the DB.
-  # @option options [Object] :serializer (map the {ConfigBuilder#fields} directly)
-  #   Object that will convert the domain objects into a hash.
-  #
-  #   Must have a `(Hash) serialize(Object)` method.
-  # @option options [Object] :deserializer (map the {ConfigBuilder#fields} directly)
-  #   Object that will set a hash of attribute_names->values onto a new domain
-  #   object.
-  #
-  #   Must have a `(Object) deserialize(Object, Hash)` method.
-  def map(domain_class, options={}, &block)
-    builder = ConfigBuilder.new(domain_class, options)
-    builder.instance_exec(&block) if block_given?
+    # Maps a domain class to a relational table.
+    #
+    # @param domain_class [Class] Type of the domain model to be mapped
+    # @param options [Hash] Configure how to map the domain model
+    # @option options [String] :to (Class with the same name as the domain class with a 'DB' appended.)
+    #   Class of the ActiveRecord object that will map this domain class to the DB.
+    # @option options [Object] :serializer (map the {ConfigBuilder#fields} directly)
+    #   Object that will convert the domain objects into a hash.
+    #
+    #   Must have a `(Hash) serialize(Object)` method.
+    # @option options [Object] :deserializer (map the {ConfigBuilder#fields} directly)
+    #   Object that will set a hash of attribute_names->values onto a new domain
+    #   object.
+    #
+    #   Must have a `(Object) deserialize(Object, Hash)` method.
+    def map(domain_class, options={}, &block)
+      @class_configs << build_class_config(domain_class, options, &block)
+    end
 
-    @class_configs << builder.build
-  end
+    # @private
+    def build_class_config(domain_class, options={}, &block)
+      builder = ConfigBuilder.new(domain_class, options)
+      builder.instance_exec(&block) if block_given?
+      builder.build
+    end
 
-  # @private
-  def build_config(&block)
-    @class_configs = []
-    self.instance_exec(&block)
-    MasterConfig.new(@class_configs)
+    # @private
+    def build_config(&block)
+      @class_configs = []
+      self.instance_exec(&block)
+      MasterConfig.new(@class_configs)
+    end
   end
 end
-end

data/lib/vorpal/db_driver.rb

@@ -1,4 +1,7 @@
 module Vorpal
+  # Interfaces between the database and Vorpal
+  #
+  # Currently only works for PostgreSQL.
   class DbDriver
     def initialize
       @sequence_names = {}
@@ -20,20 +23,29 @@ module Vorpal
       end
     end
 
-    def destroy(class_config, db_objects)
-      class_config.db_class.delete_all(id: db_objects.map(&:id))
+    def destroy(class_config, ids)
+      class_config.db_class.delete_all(id: ids)
     end
 
+    # Loads instances of the given class by primary key.
+    #
+    # @return [[Object]] An array of entities.
     def load_by_id(class_config, ids)
       class_config.db_class.where(id: ids)
     end
 
+    # Loads instances of the given class whose foreign key has the given value.
+    #
+    # @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)
       arel = arel.where(foreign_key_info.fk_type_column => foreign_key_info.fk_type) if foreign_key_info.polymorphic?
       arel.order(:id).all
     end
 
+    # Fetches primary key values to be used for new entities.
+    #
+    # @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])
       result.rows.map(&:first).map(&:to_i)

data/lib/vorpal/db_loader.rb

@@ -3,138 +3,136 @@ require 'vorpal/util/array_hash'
 require 'vorpal/db_driver'
 
 module Vorpal
+  # Handles loading of objects from the database.
+  #
+  # @private
+  class DbLoader
+    def initialize(only_owned, db_driver)
+      @only_owned = only_owned
+      @db_driver = db_driver
+    end
 
-# Handles loading of objects from the database.
-#
-# @private
-class DbLoader
-  def initialize(only_owned, db_driver)
-    @only_owned = only_owned
-    @db_driver = db_driver
-  end
+    def load_from_db(ids, config)
+      @loaded_objects = LoadedObjects.new
+      @lookup_instructions = LookupInstructions.new
+      @lookup_instructions.lookup_by_id(config, ids)
 
-  def load_from_db(ids, config)
-    @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(@db_driver)
+        @loaded_objects.add(lookup.config, new_objects)
+        explore_objects(lookup.config, new_objects)
+      end
 
-    until @lookup_instructions.empty?
-      lookup = @lookup_instructions.next_lookup
-      new_objects = lookup.load_all(@db_driver)
-      @loaded_objects.add(lookup.config, new_objects)
-      explore_objects(lookup.config, new_objects)
+      @loaded_objects
     end
 
-    @loaded_objects
-  end
-
-  private
+    private
 
-  def explore_objects(config, objects_to_explore)
-    objects_to_explore.each do |db_object|
-      config.has_manys.each do |has_many_config|
-        lookup_by_fk(db_object, has_many_config) if explore_association?(has_many_config)
-      end
+    def explore_objects(config, objects_to_explore)
+      objects_to_explore.each do |db_object|
+        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.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)
+        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
-  end
 
-  def explore_association?(association_config)
-    !@only_owned || association_config.owned == true
-  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_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 id.nil? || @loaded_objects.already_loaded?(child_config, id)
+      @lookup_instructions.lookup_by_id(child_config, id)
+    end
 
-  def lookup_by_fk(db_object, has_some_config)
-    child_config = has_some_config.child_config
-    fk_info = has_some_config.foreign_key_info
-    fk_value = db_object.id
-    @lookup_instructions.lookup_by_fk(child_config, fk_info, fk_value)
+    def lookup_by_fk(db_object, has_some_config)
+      child_config = has_some_config.child_config
+      fk_info = has_some_config.foreign_key_info
+      fk_value = db_object.id
+      @lookup_instructions.lookup_by_fk(child_config, fk_info, fk_value)
+    end
   end
-end
 
-# @private
-class LookupInstructions
-  include ArrayHash
-  def initialize
-    @lookup_by_id = {}
-    @lookup_by_fk = {}
-  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_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 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?
-      pop_fk_lookup
-    else
-      pop_id_lookup
+    def next_lookup
+      if @lookup_by_id.empty?
+        pop_fk_lookup
+      else
+        pop_id_lookup
+      end
     end
-  end
 
-  def empty?
-    @lookup_by_id.empty? && @lookup_by_fk.empty?
-  end
+    def empty?
+      @lookup_by_id.empty? && @lookup_by_fk.empty?
+    end
 
-  private
+    private
 
-  def pop_id_lookup
-    config, ids = pop(@lookup_by_id)
-    LookupById.new(config, ids)
-  end
+    def pop_id_lookup
+      config, ids = pop(@lookup_by_id)
+      LookupById.new(config, ids)
+    end
 
-  def pop_fk_lookup
-    key, fk_values = pop(@lookup_by_fk)
-    config = key.first
-    fk_info = key.last
-    LookupByFk.new(config, fk_info, fk_values)
+    def pop_fk_lookup
+      key, fk_values = pop(@lookup_by_fk)
+      config = key.first
+      fk_info = key.last
+      LookupByFk.new(config, fk_info, fk_values)
+    end
   end
-end
 
-# @private
-class LookupById
-  attr_reader :config
-  def initialize(config, ids)
-    @config = config
-    @ids = ids
-  end
+  # @private
+  class LookupById
+    attr_reader :config
+    def initialize(config, ids)
+      @config = config
+      @ids = ids
+    end
 
-  def load_all(db_driver)
-    return [] if @ids.empty?
-    db_driver.load_by_id(@config, @ids)
+    def load_all(db_driver)
+      return [] if @ids.empty?
+      db_driver.load_by_id(@config, @ids)
+    end
   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
+  # @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(db_driver)
-    return [] if @fk_values.empty?
-    db_driver.load_by_foreign_key(@config, @fk_values, @fk_info)
+    def load_all(db_driver)
+      return [] if @fk_values.empty?
+      db_driver.load_by_foreign_key(@config, @fk_values, @fk_info)
+    end
   end
 end
-
-end

data/lib/vorpal/identity_map.rb

@@ -1,34 +1,34 @@
 module Vorpal
-class IdentityMap
-  def initialize
-    @entities = {}
-  end
+  class IdentityMap
+    def initialize
+      @entities = {}
+    end
 
-  def get(key_object)
-    @entities[key(key_object)]
-  end
+    def get(key_object)
+      @entities[key(key_object)]
+    end
 
-  def set(key_object, object)
-    @entities[key(key_object)] = object
-  end
+    def set(key_object, object)
+      @entities[key(key_object)] = object
+    end
 
-  def get_and_set(key_object)
-    object = get(key_object)
-    object = yield if object.nil?
-    set(key_object, object)
-    object
-  end
+    def get_and_set(key_object)
+      object = get(key_object)
+      object = yield if object.nil?
+      set(key_object, object)
+      object
+    end
 
-  def map(key_objects)
-    key_objects.map { |k| @entities[key(k)] }
-  end
+    def map(key_objects)
+      key_objects.map { |k| @entities[key(k)] }
+    end
 
-  private
+    private
 
-  def key(key_object)
-    return nil unless key_object
-    raise "Cannot put entity '#{key_object.inspect}' into IdentityMap without an id." if key_object.id.nil?
-    [key_object.id, key_object.class.name]
+    def key(key_object)
+      return nil unless key_object
+      raise "Cannot put entity '#{key_object.inspect}' into IdentityMap without an id." if key_object.id.nil?
+      [key_object.id, key_object.class.name]
+    end
   end
 end
-end

data/lib/vorpal/loaded_objects.rb

@@ -3,38 +3,39 @@ require 'forwardable'
 
 module Vorpal
 
-# @private
-class LoadedObjects
-  include ArrayHash
-  extend Forwardable
-  include Enumerable
-
-  attr_reader :objects
-  def_delegators :objects, :each
-
-  def initialize
-    @objects = Hash.new([])
-    @objects_by_id = Hash.new
-  end
-
-  def add(config, objects)
-    add_to_hash(@objects, config, objects)
+  # @private
+  class LoadedObjects
+    include ArrayHash
+    extend Forwardable
+    include Enumerable
+
+    attr_reader :objects
+    def_delegators :objects, :each
+
+    def initialize
+      @objects = Hash.new([])
+      @objects_by_id = Hash.new
+    end
 
-    objects.each do |object|
-      @objects_by_id[[config.domain_class.name, object.id]] = object
+    def add(config, objects)
+      objects_to_add = objects.map do |object|
+        if !already_loaded?(config, object.id)
+          @objects_by_id[[config.domain_class.name, object.id]] = object
+        end
+      end
+      add_to_hash(@objects, config, objects_to_add.compact)
     end
-  end
 
-  def find_by_id(config, id)
-    @objects_by_id[[config.domain_class.name, id]]
-  end
+    def find_by_id(config, id)
+      @objects_by_id[[config.domain_class.name, id]]
+    end
 
-  def all_objects
-    @objects_by_id.values
-  end
+    def all_objects
+      @objects_by_id.values
+    end
 
-  def id_lookup_done?(config, id)
-    !find_by_id(config, id).nil?
+    def already_loaded?(config, id)
+      !find_by_id(config, id).nil?
+    end
   end
 end
-end