nobrainer 0.8.0 → 0.9.0

data/lib/no_brainer/criteria/termination/cache.rb

@@ -17,21 +17,25 @@ module NoBrainer::Criteria::Termination::Cache
     msg
   end
 
-  def merge!(criteria)
+  def merge!(criteria, options={})
     super
     self._with_cache = criteria._with_cache unless criteria._with_cache.nil?
-    self.reload
+    self.reload unless options[:keep_cache]
     self
   end
 
   def with_cache?
-    @_with_cache.nil? ?  NoBrainer::Config.cache_documents : @_with_cache
+    @_with_cache != false
   end
 
   def reload
     @cache = nil
   end
 
+  def cached?
+    !!@cache
+  end
+
   def each(options={}, &block)
     return super unless with_cache? && !options[:no_cache] && block
     return @cache.each(&block) if @cache
@@ -41,7 +45,7 @@ module NoBrainer::Criteria::Termination::Cache
       block.call(instance)
       cache << instance
     end
-    @cache = cache
+    @cache = cache.freeze
     self
   end
 
@@ -49,19 +53,19 @@ module NoBrainer::Criteria::Termination::Cache
     @cache = cache
   end
 
-  def self.reload_on(*methods)
+  def self.use_cache_for(*methods)
     methods.each do |method|
       define_method(method) do |*args, &block|
-        reload
-        super(*args, &block).tap { reload }
+        @cache ? @cache.__send__(method, *args, &block) : super(*args, &block)
       end
     end
   end
 
-  def self.use_cache_for(*methods)
+  def self.reload_on(*methods)
     methods.each do |method|
       define_method(method) do |*args, &block|
-        @cache ?  @cache.__send__(method, *args, &block) : super(*args, &block)
+        reload
+        super(*args, &block).tap { reload }
       end
     end
   end

data/lib/no_brainer/criteria/termination/eager_loading.rb

@@ -9,13 +9,17 @@ module NoBrainer::Criteria::Termination::EagerLoading
   end
 
   def includes(*values)
-    raise "Please enable caching with NoBrainer::Config.cache_documents = true" unless NoBrainer::Config.cache_documents
-    chain { |criteria| criteria._includes = values }
+    chain(:keep_cache => true) { |criteria| criteria._includes = values }
   end
 
-  def merge!(criteria)
+  def merge!(criteria, options={})
     super
     self._includes = self._includes + criteria._includes
+
+    # XXX Not pretty hack
+    if criteria._includes.present? && cached?
+      perform_eager_loading(@cache)
+    end
   end
 
   def each(options={}, &block)
@@ -23,7 +27,7 @@ module NoBrainer::Criteria::Termination::EagerLoading
 
     docs = []
     super(options.merge(:no_eager_loading => true)) { |doc| docs << doc }
-    eager_load(docs, self._includes)
+    perform_eager_loading(docs)
     docs.each(&block)
     self
   end
@@ -35,30 +39,12 @@ module NoBrainer::Criteria::Termination::EagerLoading
   end
 
   def get_one(criteria)
-    super.tap { |doc| eager_load([doc], self._includes) if should_eager_load? }
+    super.tap { |doc| perform_eager_loading([doc]) }
   end
 
-  def eager_load_association(docs, association_name, criteria=nil)
-    docs = docs.compact
-    return if docs.empty?
-    association = docs.first.root_class.association_metadata[association_name.to_sym]
-    raise "Unknown association #{association_name}" unless association
-    association.eager_load(docs, criteria)
-  end
-
-  def eager_load(docs, includes)
-    case includes
-    when Hash  then includes.each do |k,v|
-      if v.is_a?(NoBrainer::Criteria)
-        v = v.dup
-        nested_includes, v._includes = v._includes, []
-        eager_load(eager_load_association(docs, k, v), nested_includes)
-      else
-        eager_load(eager_load_association(docs, k), v)
-      end
-    end
-    when Array then includes.each { |v| eager_load(docs, v) }
-    else eager_load_association(docs, includes)
+  def perform_eager_loading(docs)
+    if should_eager_load? && docs.present?
+      NoBrainer::Document::Association::EagerLoader.new.eager_load(docs, self._includes)
     end
   end
 end

data/lib/no_brainer/document.rb

@@ -6,13 +6,9 @@ module NoBrainer::Document
 
   autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Persistance, :Dirty,
                        :Id, :Association, :Serialization, :Criteria, :Validation,
-                       :Polymorphic, :Index
+                       :Polymorphic, :Index, :Timestamps
 
-  autoload :DynamicAttributes, :Timestamps
-
-  included do
-    include Timestamps if NoBrainer::Config.auto_include_timestamps
-  end
+  autoload :DynamicAttributes
 
   singleton_class.delegate :all, :to => Core
 end

data/lib/no_brainer/document/association.rb

@@ -1,17 +1,16 @@
 module NoBrainer::Document::Association
   extend NoBrainer::Autoload
-  autoload :Core, :BelongsTo, :HasMany
+  autoload :Core, :BelongsTo, :HasMany, :HasManyThrough, :HasOne, :HasOneThrough, :EagerLoader
 
   extend ActiveSupport::Concern
 
   included do
-    class << self; attr_accessor :association_metadata; end
+    singleton_class.send(:attr_accessor, :association_metadata)
     self.association_metadata = {}
   end
 
-  def association(metadata)
-    @associations ||= {}
-    @associations[metadata] ||= metadata.new(self)
+  def associations
+    @associations ||= Hash.new { |h, metadata| h[metadata] = metadata.new(self) }
   end
 
   module ClassMethods
@@ -20,14 +19,16 @@ module NoBrainer::Document::Association
       subclass.association_metadata = self.association_metadata.dup
     end
 
-    [:belongs_to, :has_many].each do |association|
+    [:belongs_to, :has_many, :has_one].each do |association|
       define_method(association) do |target, options={}|
         target = target.to_sym
 
         if r = self.association_metadata[target]
+          raise "Cannot change the :through option" unless r.options[:through] == options[:through]
           r.options.merge!(options)
         else
-          metadata_klass = NoBrainer::Document::Association.const_get(association.to_s.camelize).const_get(:Metadata)
+          klass_name = (options[:through] ? "#{association}_through" : association.to_s).camelize
+          metadata_klass = NoBrainer::Document::Association.const_get(klass_name).const_get(:Metadata)
           r = metadata_klass.new(self, target, options)
           ([self] + descendants).each do |klass|
             klass.association_metadata[target] = r

data/lib/no_brainer/document/association/belongs_to.rb

@@ -2,8 +2,9 @@ class NoBrainer::Document::Association::BelongsTo
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_BELONGS_TO_OPTIONS = [:foreign_key, :class_name, :index]
+    VALID_OPTIONS = [:foreign_key, :class_name, :index]
     include NoBrainer::Document::Association::Core::Metadata
+    extend NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
       # TODO test :foreign_key
@@ -17,47 +18,51 @@ class NoBrainer::Document::Association::BelongsTo
 
     def hook
       super
-      options.assert_valid_keys(*VALID_BELONGS_TO_OPTIONS)
 
       owner_klass.field foreign_key, :index => options[:index]
       delegate("#{foreign_key}=", :assign_foreign_key, :call_super => true)
       add_callback_for(:after_validation)
+      # TODO test if we are not overstepping on another foreign_key
     end
 
-    def eager_load(docs, criteria=nil)
-      target_criteria = target_klass.all
-      target_criteria = target_criteria.merge(criteria) if criteria
-      docs_fks = Hash[docs.map { |doc| [doc, doc.read_attribute(foreign_key)] }]
-      fks = docs_fks.values.compact.uniq
-      fk_targets = Hash[target_criteria.where(:id.in => fks).map { |doc| [doc.id, doc] }]
-      docs_fks.each { |doc, fk| doc.association(self)._write(fk_targets[fk]) if fk_targets[fk] }
-      fk_targets.values
-    end
+    eager_load_with :owner_key => ->{ foreign_key }, :target_key => ->{ :id },
+                    :unscoped => true
   end
 
+  # Note:
+  # @target_container is an array to distinguish the following cases:
+  # * target is not loaded, but perhaps present in the db.
+  # * we already tried to load target, but it wasn't present in the db.
+
   def assign_foreign_key(value)
-    @target = nil
+    @target_container = nil
   end
 
   def read
-    return @target if @target && NoBrainer::Config.cache_documents
-    if fk = instance.read_attribute(foreign_key)
-      @target = target_klass.find(fk)
-    end
-  end
+    return @target_container.first if loaded?
 
-  def _write(target)
-    @target = target
+    if fk = owner.read_attribute(foreign_key)
+      preload(target_klass.find(fk))
+    end
   end
 
   def write(target)
     assert_target_type(target)
-    instance.write_attribute(foreign_key, target.try(:id))
-    _write(target)
+    owner.write_attribute(foreign_key, target.try(:id))
+    preload(target)
+  end
+
+  def preload(target)
+    @target_container = [*target] # the * is for the generic eager loading code
+    @target_container.first
+  end
+
+  def loaded?
+    !@target_container.nil?
   end
 
   def after_validation_callback
-    if @target && !@target.persisted?
+    if loaded? && @target_container.first && !@target_container.first.persisted?
       raise NoBrainer::Error::AssociationNotSaved.new("#{target_name} must be saved first")
     end
   end

data/lib/no_brainer/document/association/core.rb

@@ -16,8 +16,8 @@ module NoBrainer::Document::Association::Core
       @association_klass ||= self.class.name.deconstantize.constantize
     end
 
-    def new(instance)
-      association_klass.new(self, instance)
+    def new(owner)
+      association_klass.new(self, owner)
     end
 
     def delegate(method_name, target, options={})
@@ -25,12 +25,13 @@ module NoBrainer::Document::Association::Core
       owner_klass.inject_in_layer :associations do
         define_method(method_name) do |*args, &block|
           super(*args, &block) if options[:call_super]
-          association(metadata).__send__(target, *args, &block)
+          associations[metadata].__send__(target, *args, &block)
         end
       end
     end
 
     def hook
+      options.assert_valid_keys(*self.class.const_get(:VALID_OPTIONS))
       delegate("#{target_name}=", :write)
       delegate("#{target_name}", :read)
     end
@@ -39,20 +40,19 @@ module NoBrainer::Document::Association::Core
       instance_eval <<-RUBY, __FILE__, __LINE__+1
         if !@added_#{what}
           metadata = self
-          owner_klass.#{what} { association(metadata).#{what}_callback }
+          owner_klass.#{what} { associations[metadata].#{what}_callback }
           @added_#{what} = true
         end
       RUBY
     end
   end
 
-  included { attr_accessor :metadata, :instance }
+  included { attr_accessor :metadata, :owner }
 
   delegate :foreign_key, :target_name, :target_klass, :to => :metadata
 
-  def initialize(metadata, instance)
-    @metadata = metadata
-    @instance = instance
+  def initialize(metadata, owner)
+    @metadata, @owner = metadata, owner
   end
 
   def assert_target_type(value)

data/lib/no_brainer/document/association/eager_loader.rb

@@ -0,0 +1,57 @@
+class NoBrainer::Document::Association::EagerLoader
+  module Generic
+    # Used in associations to declare generic eager loading capabilities
+    # The association should implement loaded? and preload.
+    def eager_load_with(options={})
+      define_method(:eager_load) do |docs, additional_criteria=nil|
+        owner_key  = instance_exec(&options[:owner_key])
+        target_key = instance_exec(&options[:target_key])
+
+        criteria = target_klass.all
+        criteria = criteria.merge(additional_criteria) if additional_criteria
+        criteria = criteria.unscoped if options[:unscoped]
+
+        unloaded_docs = docs.reject { |doc| doc.associations[self].loaded? }
+
+        owner_keys = unloaded_docs.map(&owner_key).compact.uniq
+        if owner_keys.present?
+          targets = criteria.where(target_key.in => owner_keys)
+                            .map { |target| [target.read_attribute(target_key), target] }
+                            .reduce(Hash.new { |k,v| k[v] = [] }) { |h,(k,v)| h[k] << v; h }
+
+          unloaded_docs.each do |doc|
+            doc_targets = targets[doc.read_attribute(owner_key)]
+            doc.associations[self].preload(doc_targets)
+          end
+        end
+
+        docs.map { |doc| doc.associations[self].read }.flatten.compact.uniq
+      end
+    end
+  end
+
+  def eager_load_association(docs, association_name, criteria=nil)
+    docs = docs.compact
+    return [] if docs.empty?
+    association = docs.first.root_class.association_metadata[association_name.to_sym]
+    raise "Unknown association #{association_name}" unless association
+    association.eager_load(docs, criteria)
+  end
+
+  def eager_load(docs, includes)
+    case includes
+    when Hash  then includes.each do |k,v|
+      if v.is_a?(NoBrainer::Criteria)
+        v = v.dup
+        nested_includes, v._includes = v._includes, []
+        eager_load(eager_load_association(docs, k, v), nested_includes)
+      else
+        eager_load(eager_load_association(docs, k), v)
+      end
+    end
+    when Array then includes.each { |v| eager_load(docs, v) }
+    else eager_load_association(docs, includes)
+    end
+    true
+  end
+end

data/lib/no_brainer/document/association/has_many.rb

@@ -2,12 +2,13 @@ class NoBrainer::Document::Association::HasMany
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_HAS_MANY_OPTIONS = [:foreign_key, :class_name, :dependent]
+    VALID_OPTIONS = [:foreign_key, :class_name, :dependent]
     include NoBrainer::Document::Association::Core::Metadata
+    extend NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
       # TODO test :foreign_key
-      options[:foreign_key].try(:to_sym) || :"#{owner_klass.name.underscore}_id"
+      options[:foreign_key].try(:to_sym) || owner_klass.name.foreign_key.to_sym
     end
 
     def target_klass
@@ -15,47 +16,69 @@ class NoBrainer::Document::Association::HasMany
       (options[:class_name] || target_name.to_s.singularize.camelize).constantize
     end
 
+    def inverses
+      # We can always infer the inverse association of a has_many relationship,
+      # because a belongs_to association cannot have a scope applied on the
+      # selector.
+      # XXX Without caching, this is going to get CPU intensive quickly, but
+      # caching is hard (rails console reload, etc.).
+      target_klass.association_metadata.values.select do |assoc|
+        assoc.is_a?(NoBrainer::Document::Association::BelongsTo::Metadata) and
+        assoc.foreign_key == self.foreign_key                              and
+        assoc.target_klass.root_class == owner_klass.root_class
+      end
+    end
+
     def hook
       super
-      options.assert_valid_keys(*VALID_HAS_MANY_OPTIONS)
-      add_callback_for(:before_destroy)
+      add_callback_for(:before_destroy) if options[:dependent]
     end
 
-    def eager_load(docs, criteria=nil)
-      target_criteria = target_klass.all
-      target_criteria = target_criteria.merge(criteria) if criteria
-      docs_ids = Hash[docs.map { |doc| [doc, doc.id] }]
-      fk_targets = target_criteria
-        .where(foreign_key.in => docs_ids.values)
-        .reduce({}) do |hash, doc|
-          fk = doc.read_attribute(foreign_key)
-          hash[fk] ||= []
-          hash[fk] << doc
-          hash
-        end
-      docs_ids.each { |doc, id| doc.association(self)._write(fk_targets[id]) if fk_targets[id] }
-      fk_targets.values.flatten(1)
-    end
+    eager_load_with :owner_key => ->{ :id }, :target_key => ->{ foreign_key }
   end
 
-  def children_criteria
-    @children_criteria ||= target_klass.where(foreign_key => instance.id)
+  def target_criteria
+    @target_criteria ||= target_klass.where(foreign_key => owner.id)
+                                     ._after_instantiate(set_inverse_proc)
   end
 
   def read
-    children_criteria
+    target_criteria
   end
 
   def write(new_children)
-    raise "You can't assign the array of #{target_name}. Instead, you must modify delete and create #{target_klass} manually."
+    raise "You can't assign #{target_name}. " +
+          "Instead, you must modify delete and create #{target_klass} manually."
+  end
+
+  def loaded?
+    target_criteria.cached?
+  end
+
+  def preload(new_targets)
+    set_inverses_of(new_targets)
+    target_criteria._override_cache(new_targets)
+  end
+
+  def set_inverses_of(new_targets)
+    @inverses ||= metadata.inverses
+    return if @inverses.blank?
+
+    new_targets.each do |target|
+      # We don't care if target is a parent class where the inverse association
+      # is defined, we set the association regardless.
+      # The user won't be able to access it since the association accessors are
+      # not defined on the parent class.
+      @inverses.each { |inverse| target.associations[inverse].preload(self.owner) }
+    end
   end
 
-  def _write(new_children)
-    children_criteria._override_cache(new_children)
+  def set_inverse_proc
+    lambda { |target| set_inverses_of([target]) if target.is_a?(NoBrainer::Document) }
   end
 
   def before_destroy_callback
-    criteria = children_criteria.unscoped
+    criteria = target_criteria.unscoped.without_cache
     case metadata.options[:dependent]
     when nil       then
     when :destroy  then criteria.destroy_all