vorpal 0.0.6.rc2 → 0.0.6.rc3

data/lib/vorpal/configuration.rb

@@ -7,11 +7,15 @@ 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(&block)
-    @class_configs = []
-    self.instance_exec(&block)
-    AggregateRepository.new(@class_configs)
+  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.
@@ -35,5 +39,12 @@ module Configuration
 
     @class_configs << builder.build
   end
+
+  # @private
+  def build_config(&block)
+    @class_configs = []
+    self.instance_exec(&block)
+    MasterConfig.new(@class_configs)
+  end
 end
 end

data/lib/vorpal/db_driver.rb

@@ -1,50 +1,48 @@
 module Vorpal
-module DbDriver
-  extend self
+  class DbDriver
+    def insert(db_class, db_objects)
+      if defined? ActiveRecord::Import
+        db_class.import(db_objects, validate: false)
+      else
+        db_objects.each do |db_object|
+          db_object.save!(validate: false)
+        end
+      end
+    end
 
-  def insert(config, db_objects)
-    if defined? ActiveRecord::Import
-      config.db_class.import db_objects
-    else
+    def update(db_class, db_objects)
       db_objects.each do |db_object|
-        db_object.save!
+        db_object.save!(validate: false)
       end
     end
-  end
 
-  def update(config, db_objects)
-    db_objects.each do |db_object|
-      db_object.save!
+    def destroy(db_class, db_objects)
+      db_class.delete_all(id: db_objects.map(&:id))
     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_id(db_class, ids)
+      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 load_by_foreign_key(db_class, 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 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
+    def get_primary_keys(db_class, count)
+      result = execute("select nextval('#{sequence_name(db_class)}') from generate_series(1,#{count});")
+      result.column_values(0).map(&:to_i)
+    end
 
-  private
+    private
 
-  def execute(sql)
-    ActiveRecord::Base.connection.execute(sql)
-  end
+    def execute(sql)
+      ActiveRecord::Base.connection.execute(sql)
+    end
 
-  def sequence_name(config)
-    "#{config.table_name}_id_seq"
+    def sequence_name(db_class)
+      "#{db_class.table_name}_id_seq"
+    end
   end
-end
 end

data/lib/vorpal/db_loader.rb

@@ -4,11 +4,14 @@ require 'vorpal/db_driver'
 
 module Vorpal
 
+# Handles loading of objects from the database.
+#
 # @private
 class DbLoader
-  def initialize(configs, only_owned)
+  def initialize(configs, only_owned, driver)
     @configs = configs
     @only_owned = only_owned
+    @driver = driver
   end
 
   def load_from_db(ids, domain_class)
@@ -19,7 +22,7 @@ class DbLoader
 
     until @lookup_instructions.empty?
       lookup = @lookup_instructions.next_lookup
-      new_objects = lookup.load_all
+      new_objects = lookup.load_all(@driver)
       @loaded_objects.add(lookup.config, new_objects)
       explore_objects(new_objects)
     end
@@ -31,7 +34,7 @@ class DbLoader
 
   def explore_objects(objects_to_explore)
     objects_to_explore.each do |db_object|
-      config = @configs.config_for_db(db_object.class)
+      config = @configs.config_for_db_object(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
@@ -57,11 +60,10 @@ class DbLoader
     @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
+  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
-    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
@@ -84,19 +86,29 @@ class LookupInstructions
 
   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)
+      pop_fk_lookup
     else
-      config = @lookup_by_id.first.first
-      ids = @lookup_by_id.delete(config)
-      LookupById.new(config, ids)
+      pop_id_lookup
     end
   end
 
   def empty?
     @lookup_by_id.empty? && @lookup_by_fk.empty?
   end
+
+  private
+
+  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)
+  end
 end
 
 # @private
@@ -107,9 +119,9 @@ class LookupById
     @ids = ids
   end
 
-  def load_all
+  def load_all(driver)
     return [] if @ids.empty?
-    DbDriver.load_by_id(@config, @ids)
+    driver.load_by_id(@config.db_class, @ids)
   end
 end
 
@@ -122,9 +134,9 @@ class LookupByFk
     @fk_values = fk_values
   end
 
-  def load_all
+  def load_all(driver)
     return [] if @fk_values.empty?
-    DbDriver.load_by_foreign_key(@config, @fk_values, @fk_info)
+    driver.load_by_foreign_key(@config.db_class, @fk_values, @fk_info)
   end
 end
 

data/lib/vorpal/identity_map.rb

@@ -23,10 +23,6 @@ class IdentityMap
     key_objects.map { |k| @entities[key(k)] }
   end
 
-  def map_raw(key_ids, key_class)
-    key_ids.map { |key_id| @entities[[key_id, key_class.name]] }
-  end
-
   private
 
   def key(key_object)

data/lib/vorpal/loaded_objects.rb

@@ -14,40 +14,27 @@ class LoadedObjects
 
   def initialize
     @objects = Hash.new([])
+    @objects_by_id = Hash.new
   end
 
   def add(config, objects)
     add_to_hash(@objects, config, objects)
-  end
 
-  def find_by_id(object, config)
-    @objects[config].detect { |obj| obj.id == object.id }
+    objects.each do |object|
+      @objects_by_id[[config.domain_class.name, object.id]] = object
+    end
   end
 
-  def loaded_ids(config)
-    @objects[config].map(&:id)
-  end
-
-  def loaded_fk_values(config, fk_info)
-    if fk_info.polymorphic?
-      @objects[config].
-        find_all { |db_object| fk_info.matches_polymorphic_type?(db_object) }.
-        map(&(fk_info.fk_column.to_sym))
-    else
-      @objects[config].map(&(fk_info.fk_column.to_sym))
-    end
+  def find_by_id(config, id)
+    @objects_by_id[[config.domain_class.name, id]]
   end
 
   def all_objects
-    @objects.values.flatten
+    @objects_by_id.values
   end
 
   def id_lookup_done?(config, id)
-    loaded_ids(config).include?(id)
-  end
-
-  def fk_lookup_done?(config, fk_info, fk_value)
-    loaded_fk_values(config, fk_info).include?(fk_value)
+    !find_by_id(config, id).nil?
   end
 end
 end

data/lib/vorpal/util/array_hash.rb

@@ -2,11 +2,17 @@ module Vorpal
 
 # @private
 module ArrayHash
-  def add_to_hash(h, key, values)
-    if h[key].nil? || h[key].empty?
-      h[key] = []
+  def add_to_hash(array_hash, key, values)
+    if array_hash[key].nil? || array_hash[key].empty?
+      array_hash[key] = []
     end
-    h[key].concat(Array(values))
+    array_hash[key].concat(Array(values))
+  end
+
+  def pop(array_hash)
+    key = array_hash.first.first
+    values = array_hash.delete(key)
+    [key, values]
   end
 end
 

data/lib/vorpal/version.rb

@@ -1,3 +1,3 @@
 module Vorpal
-  VERSION = "0.0.6.rc2"
+  VERSION = "0.0.6.rc3"
 end

data/spec/helpers/db_helpers.rb

@@ -0,0 +1,18 @@
+module DbHelpers
+  # when you change a table's columns, set force to true to re-generate the table in the DB
+  def define_table(table_name, columns, force)
+    if !ActiveRecord::Base.connection.table_exists?(table_name) || force
+      ActiveRecord::Base.connection.create_table(table_name, force: true) do |t|
+        columns.each do |name, type|
+          t.send(type, name)
+        end
+      end
+    end
+  end
+
+  def defineAr(table_name)
+    Class.new(ActiveRecord::Base) do
+      self.table_name = table_name
+    end
+  end
+end

data/spec/integration_spec_helper.rb

@@ -12,7 +12,11 @@ ActiveRecord::Base.establish_connection(
   min_messages: 'error'
 )
 
+require 'helpers/db_helpers'
+
 RSpec.configure do |config|
+  config.include DbHelpers
+
   # implements `use_transactional_fixtures = true`
   # from lib/active_record/fixtures.rb
   # works with Rails 3.2. Probably not with Rails 4

data/spec/vorpal/aggregate_repository_spec.rb

@@ -104,11 +104,12 @@ describe 'Aggregate Repository' do
 
   describe 'on error' do
     it 'nils ids of new objects' do
-      test_repository = configure
+      db_driver = Vorpal::DbDriver.new
+      test_repository = configure(db_driver: db_driver)
 
       tree_db = TreeDB.create!
 
-      expect(Vorpal::DbDriver).to receive(:update).and_raise('not so good')
+      expect(db_driver).to receive(:update).and_raise('not so good')
 
       fissure = Fissure.new
       tree = Tree.new(id: tree_db.id, fissures: [fissure])
@@ -580,72 +581,6 @@ describe 'Aggregate Repository' do
     end
   end
 
-  describe 'lots of data' do
-    it 'avoids N+1s on load' do
-      test_repository = Vorpal.define do
-        map Tree do
-          fields :name
-          belongs_to :trunk
-          # has_many :fissures
-          has_many :branches
-        end
-
-        map Trunk do
-          fields :length
-          has_one :tree
-          has_many :bugs, fk: :lives_on_id, fk_type: :lives_on_type
-        end
-
-        map Branch do
-          fields :length
-          belongs_to :tree
-          has_many :bugs, fk: :lives_on_id, fk_type: :lives_on_type
-          has_many :branches
-        end
-
-        map Bug do
-          fields :name
-          belongs_to :lives_on, fk: :lives_on_id, fk_type: :lives_on_type, child_classes: [Trunk, Branch]
-        end
-        # map Fissure, to: Fissure
-      end
-
-      ids = (1..3).map do
-        trunk_db = TrunkDB.create!
-        tree_db = TreeDB.create!(trunk_id: trunk_db.id)
-        branch_db1 = BranchDB.create!(tree_id: tree_db.id)
-        branch_db2 = BranchDB.create!(tree_id: tree_db.id)
-        branch_db3 = BranchDB.create!(branch_id: branch_db2.id)
-        BugDB.create!(name: 'trunk bug', lives_on_id: trunk_db.id, lives_on_type: Trunk.name)
-        BugDB.create!(name: 'branch bug!', lives_on_id: branch_db1.id, lives_on_type: Branch.name)
-        tree_db.id
-      end
-
-      puts '*************************'
-      puts '*************************'
-      puts '*************************'
-      puts '*************************'
-      test_repository.load_all(ids, Tree)
-    end
-  end
-
-  # when you change a table's columns, set force to true to re-generate the table in the DB
-  def define_table(table_name, columns, force)
-    if !ActiveRecord::Base.connection.table_exists?(table_name) || force
-      ActiveRecord::Base.connection.create_table(table_name, force: true) do |t|
-        columns.each do |name, type|
-          t.send(type, name)
-        end
-      end
-    end
-  end
-
-  def defineAr(table_name)
-    Class.new(ActiveRecord::Base) do
-      self.table_name = table_name
-    end
-  end
-
 private
 
   def configure_polymorphic_has_many
@@ -763,8 +698,8 @@ private
     end
   end
   
-  def configure
-    Vorpal.define do
+  def configure(options={})
+    Vorpal.define(options) do
       map Tree do
         fields :name
         belongs_to :trunk

data/spec/vorpal/configs_spec.rb

@@ -0,0 +1,107 @@
+require 'unit_spec_helper'
+require 'vorpal/configs'
+
+describe Vorpal::MasterConfig do
+  class Post
+    attr_accessor :comments
+    attr_accessor :best_comment
+  end
+
+  class Comment
+    attr_accessor :post
+  end
+
+  let(:post_config) { Vorpal::ClassConfig.new(domain_class: Post) }
+  let(:comment_config) { Vorpal::ClassConfig.new(domain_class: Comment) }
+  let(:post_has_many_comments_config) { Vorpal::HasManyConfig.new(name: 'comments', fk: 'post_id', child_class: Comment) }
+  let(:post_has_one_comment_config) { Vorpal::HasOneConfig.new(name: 'best_comment', fk: 'post_id', child_class: Comment) }
+  let(:comment_belongs_to_post_config) { Vorpal::BelongsToConfig.new(name: 'post', fk: 'post_id', child_classes: [Post]) }
+
+  describe 'local_association_configs' do
+    it 'builds an association_config for a belongs_to' do
+      comment_config.belongs_tos << comment_belongs_to_post_config
+
+      Vorpal::MasterConfig.new([post_config, comment_config])
+
+      expect(comment_config.local_association_configs.size).to eq(1)
+      expect(post_config.local_association_configs.size).to eq(0)
+    end
+
+    it 'sets the association end configs' do
+      comment_config.belongs_tos << comment_belongs_to_post_config
+      post_config.has_manys << post_has_many_comments_config
+
+      Vorpal::MasterConfig.new([post_config, comment_config])
+
+      association_config = comment_config.local_association_configs.first
+
+      expect(association_config.remote_end_config).to eq(post_has_many_comments_config)
+      expect(association_config.local_end_config).to eq(comment_belongs_to_post_config)
+    end
+
+    it 'builds an association_config for a has_many' do
+      post_config.has_manys << post_has_many_comments_config
+
+      Vorpal::MasterConfig.new([post_config, comment_config])
+
+      expect(comment_config.local_association_configs.size).to eq(1)
+      expect(post_config.local_association_configs.size).to eq(0)
+    end
+  end
+
+  describe Vorpal::AssociationConfig do
+    describe 'associate' do
+      let(:post) { Post.new }
+      let(:comment) { Comment.new }
+
+      it 'sets both ends of a one-to-one association' do
+        config = Vorpal::AssociationConfig.new(comment_config, 'post_id', nil)
+        config.add_remote_class_config(post_config)
+
+        config.local_end_config = comment_belongs_to_post_config
+        config.remote_end_config = post_has_one_comment_config
+
+        config.associate(comment, post)
+
+        expect(comment.post).to eq(post)
+        expect(post.best_comment).to eq(comment)
+      end
+
+      it 'sets both ends of a one-to-many association' do
+        config = Vorpal::AssociationConfig.new(comment_config, 'post_id', nil)
+        config.add_remote_class_config(post_config)
+
+        config.local_end_config = comment_belongs_to_post_config
+        config.remote_end_config = post_has_many_comments_config
+
+        config.associate(comment, post)
+
+        expect(comment.post).to eq(post)
+        expect(post.comments).to eq([comment])
+      end
+    end
+
+    describe 'remote_class_config' do
+      it 'works with non-polymorphic associations' do
+        config = Vorpal::AssociationConfig.new(comment_config, 'post_id', nil)
+        config.add_remote_class_config(post_config)
+
+        post = Post.new
+        class_config = config.remote_class_config(post)
+
+        expect(class_config).to eq(post_config)
+      end
+
+      it 'works with polymorphic associations' do
+        config = Vorpal::AssociationConfig.new(comment_config, 'commented_upon_id', 'commented_upon_type')
+        config.add_remote_class_config(post_config)
+        config.add_remote_class_config(comment_config)
+
+        comment = double('comment', commented_upon_type: 'Comment')
+        class_config = config.remote_class_config(comment)
+
+        expect(class_config).to eq(comment_config)
+      end
+    end
+  end
+end