nobrainer 0.22.0 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c53755e5f9ec902612c417fcf053404cf114ca0b
-  data.tar.gz: 529fe4b627d366ba4813fd6ff750192caf0df316
+  metadata.gz: 8406e0c14de6dc8379b7047aa6d7254675e1b1fb
+  data.tar.gz: 0d9906ef55e4f74e5317a6d2377d4c1f19ac9799
 SHA512:
-  metadata.gz: 920d6b1c7bec9acd28b4a0e7f54a9967d068a01d31174396ca961eaf8cbfec31e3b8397ab2242ac87c73b9ca3789e80b47c8ca4b809d7a71b5fa80aeedb81f4b
-  data.tar.gz: 92144b91eb03ac14d2a01ea5244480b215286228691e5406a9f7bcf218499853ecfb0d1313f1380f62d509d97dc2bb1dac65ae8e97c0c2c3cc2b7b4c3835e1c2
+  metadata.gz: fdcbf5021c15bad13546e7b346eb73fb7f6d0b62ab861578110b0ab81aafda8c364a4b6fe9b282d0f8f8c6d732ebd8dcc3f5be9aada980b79d34d93b0fed6fea
+  data.tar.gz: afa546845837919bb06b01c7ba4168626b74263244986d4d9d3a7428b9b68b24faa968572f110546fb5afb9c4b57dbb236d5c48556b9ae691d271deea62ff816

data/lib/no_brainer/autoload.rb

@@ -14,7 +14,7 @@ module NoBrainer::Autoload
   end
 
   def autoload_and_include(*constants)
-    constants.each { |constant| autoload constant }
+    autoload(*constants)
     constants.each { |constant| include const_get(constant) }
   end
 end

data/lib/no_brainer/config.rb

@@ -4,18 +4,21 @@ module NoBrainer::Config
   SETTINGS = {
     :app_name               => { :default => ->{ default_app_name } },
     :environment            => { :default => ->{ default_environment } },
-    :rethinkdb_url          => { :default => ->{ default_rethinkdb_url } },
+    :rethinkdb_urls         => { :default => ->{ [default_rethinkdb_url] } },
+    :ssl_options            => { :default => ->{ nil } },
     :logger                 => { :default => ->{ default_logger } },
     :colorize_logger        => { :default => ->{ true }, :valid_values => [true, false] },
     :warn_on_active_record  => { :default => ->{ true }, :valid_values => [true, false] },
     :max_retries_on_connection_failure => { :default => ->{ default_max_retries_on_connection_failure } },
     :durability             => { :default => ->{ default_durability }, :valid_values => [:hard, :soft] },
-    :max_string_length      => { :default => -> { 255 } },
+    :table_options          => { :default => ->{ {:shards => 1, :replicas => 1, :write_acks => :majority} },
+                                 :valid_keys => [:shards, :replicas, :primary_replica_tag, :write_acks, :durability] },
+    :max_string_length      => { :default => ->{ 255 } },
     :user_timezone          => { :default => ->{ :local }, :valid_values => [:unchanged, :utc, :local] },
     :db_timezone            => { :default => ->{ :utc }, :valid_values => [:unchanged, :utc, :local] },
     :geo_options            => { :default => ->{ {:geo_system => 'WGS84', :unit => 'm'} } },
-    :distributed_lock_class => { :default => ->{ NoBrainer::Lock } },
-    :lock_options           => { :default => ->{ { :expire => 60, :timeout => 10 } } },
+    :distributed_lock_class => { :default => ->{ "NoBrainer::Lock" } },
+    :lock_options           => { :default => ->{ { :expire => 60, :timeout => 10 } }, :valid_keys => [:expire, :timeout] },
     :per_thread_connection  => { :default => ->{ false }, :valid_values => [true, false] },
     :machine_id             => { :default => ->{ default_machine_id } },
     :criteria_cache_max_entries => { :default => -> { 10_000 } },
@@ -44,7 +47,12 @@ module NoBrainer::Config
     end
 
     def assert_valid_options
-      SETTINGS.each { |k,v| assert_array_in(k, v[:valid_values]) if v[:valid_values] }
+      SETTINGS.each do |k,v|
+        assert_value_in(k, v[:valid_values]) if v[:valid_values]
+        assert_hash_keys_in(k, v[:valid_keys]) if v[:valid_keys]
+      end
+
+      validate_urls
     end
 
     def reset!
@@ -52,22 +60,31 @@ module NoBrainer::Config
     end
 
     def configure(&block)
-      @applied_defaults_for.to_a.each { |k| remove_instance_variable("@#{k}") }
+      @applied_defaults_for.to_a.each do |k|
+        remove_instance_variable("@#{k}") if instance_variable_defined?("@#{k}")
+      end
       block.call(self) if block
       apply_defaults
       assert_valid_options
       @configured = true
 
-      NoBrainer::ConnectionManager.disconnect_if_url_changed
+      NoBrainer::ConnectionManager.notify_url_change
     end
 
     def configured?
       !!@configured
     end
 
-    def assert_array_in(name, values)
-      unless __send__(name).in?(values)
-        raise ArgumentError.new("Unknown configuration for #{name}: #{__send__(name)}. Valid values are: #{values.inspect}")
+    def assert_value_in(name, valid_values)
+      unless __send__(name).in?(valid_values)
+        raise ArgumentError.new("Invalid configuration for #{name}: #{__send__(name)}. Valid values are: #{valid_values.inspect}")
+      end
+    end
+
+    def assert_hash_keys_in(name, valid_keys)
+      extra_keys = __send__(name).keys - valid_keys
+      unless extra_keys.empty?
+        raise ArgumentError.new("Invalid configuration for  #{name}: #{__send__(name)}. Valid keys are: #{valid_keys.inspect}")
       end
     end
 
@@ -84,6 +101,10 @@ module NoBrainer::Config
       ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || :production
     end
 
+    def rethinkdb_url=(value)
+      self.rethinkdb_urls = [*value]
+    end
+
     def default_rethinkdb_url
       db = ENV['RETHINKDB_DB'] || ENV['RDB_DB']
       db ||= "#{self.app_name}_#{self.environment}" if self.app_name && self.environment
@@ -95,6 +116,13 @@ module NoBrainer::Config
       url
     end
 
+    def validate_urls
+      # This is not connecting, just validating the format.
+      dbs = rethinkdb_urls.compact.map { |url| NoBrainer::Connection.new(url).parsed_uri[:db] }.uniq
+      raise "Please specify at least one rethinkdb_url" if dbs.size == 0
+      raise "All the rethinkdb_urls must specify the same db name (instead of #{dbs.inspect})" if dbs.size != 1
+    end
+
     def default_logger
       defined?(Rails.logger) ? Rails.logger : Logger.new(STDERR).tap { |l| l.level = Logger::WARN }
     end
@@ -107,18 +135,23 @@ module NoBrainer::Config
       dev_mode? ? 1 : 15
     end
 
+    # XXX Not referencing NoBrainer::Document::PrimaryKey::Generator::MACHINE_ID_MASK
+    # because we don't want to load all the document code to speedup boot time.
+    MACHINE_ID_BITS = 24
+    MACHINE_ID_MASK = (1 << MACHINE_ID_BITS)-1
+
     def default_machine_id
+      return ENV['MACHINE_ID'] if ENV['MACHINE_ID']
+
       require 'socket'
       require 'digest/md5'
 
-      return ENV['MACHINE_ID'] if ENV['MACHINE_ID']
-
       host = Socket.gethostname
       if host.in? %w(127.0.0.1 localhost)
         raise "Please configure NoBrainer::Config.machine_id due to lack of appropriate hostname (Socket.gethostname = #{host})"
       end
 
-      Digest::MD5.digest(host).unpack("N")[0] & NoBrainer::Document::PrimaryKey::Generator::MACHINE_ID_MASK
+      Digest::MD5.digest(host).unpack("N")[0] & MACHINE_ID_MASK
     end
 
     def machine_id=(machine_id)
@@ -127,9 +160,16 @@ module NoBrainer::Config
         when /^[0-9]+$/ then machine_id.to_i
         else raise "Invalid machine_id"
       end
-      max_id = NoBrainer::Document::PrimaryKey::Generator::MACHINE_ID_MASK
+      max_id = MACHINE_ID_MASK
       raise "Invalid machine_id (must be between 0 and #{max_id})" unless machine_id.in?(0..max_id)
       @machine_id = machine_id
     end
+
+    def distributed_lock_class
+      if @distributed_lock_class.is_a?(String)
+        @distributed_lock_class = @distributed_lock_class.constantize
+      end
+      @distributed_lock_class
+    end
   end
 end

data/lib/no_brainer/connection.rb

@@ -1,17 +1,16 @@
 require 'rethinkdb'
+require 'uri'
 
 class NoBrainer::Connection
-  attr_accessor :uri, :parsed_uri
+  attr_accessor :parsed_uri
 
   def initialize(uri)
-    self.uri = uri
-    parsed_uri # just to raise an exception if there is a problem.
+    parse_uri(uri)
   end
 
-  def parsed_uri
-    @parsed_uri ||= begin
-      require 'uri'
-      uri = URI.parse(self.uri)
+  def parse_uri(uri)
+    @parsed_uri = begin
+      uri = URI.parse(uri)
 
       if uri.scheme != 'rethinkdb'
         raise NoBrainer::Error::Connection,
@@ -26,33 +25,37 @@ class NoBrainer::Connection
     end
   end
 
+  def uri
+    "rethinkdb://#{'****@' if parsed_uri[:auth_key]}#{parsed_uri[:host]}:#{parsed_uri[:port]}/#{parsed_uri[:db]}"
+  end
+
   def raw
-    @raw ||= RethinkDB::Connection.new(parsed_uri)
+    options = parsed_uri
+    options = options.merge(:ssl => NoBrainer::Config.ssl_options) if NoBrainer::Config.ssl_options
+    @raw ||= RethinkDB::Connection.new(options).tap { NoBrainer.logger.info("Connected to #{uri}") }
   end
 
   delegate :reconnect, :close, :run, :to => :raw
   alias_method :connect, :raw
   alias_method :disconnect, :close
 
-  [:db_create, :db_drop, :db_list, :table_create, :table_drop, :table_list].each do |cmd|
-    class_eval <<-RUBY, __FILE__, __LINE__ + 1
-      def #{cmd}(*args)
-        NoBrainer.run { |r| r.#{cmd}(*args) }
-      end
-    RUBY
+  def default_db
+    parsed_uri[:db]
+  end
+
+  def current_db
+    NoBrainer.current_run_options.try(:[], :db) || default_db
   end
 
   def drop!
-    # XXX Thread.current[:nobrainer_options] is set by NoBrainer::QueryRunner::RunOptions
-    db = (Thread.current[:nobrainer_options] || parsed_uri)[:db]
-    db_drop(db)['dropped'] == 1
+    NoBrainer.run { |r| r.db_drop(current_db) }
   end
 
-  # Note that truncating each table (purge) is much faster than dropping the
-  # database (drop)
+  # Note that truncating each table (purge!) is much faster than dropping the database (drop!)
   def purge!
-    table_list.each do |table_name|
-      next if table_name == 'nobrainer_index_meta' # keeping because indexes are not going away
+    NoBrainer.run { |r| r.table_list }.each do |table_name|
+      # keeping the index meta store because indexes are not going away when purging
+      next if table_name == NoBrainer::Document::Index::MetaStore.table_name
       NoBrainer.run { |r| r.table(table_name).delete }
     end
     true

data/lib/no_brainer/connection_manager.rb

@@ -4,17 +4,30 @@ module NoBrainer::ConnectionManager
   @lock = Mutex.new
 
   def synchronize(&block)
-    if NoBrainer::Config.per_thread_connection
-      block.call
-    else
-      @lock.synchronize { block.call }
+    @lock.synchronize { block.call }
+  end
+
+  def warn_for_other_orms
+    if defined?(ActiveRecord) && NoBrainer::Config.warn_on_active_record
+      STDERR.puts "[NoBrainer] ActiveRecord is loaded which is probably not what you want."
+      STDERR.puts "[NoBrainer] Follow the instructions on http://nobrainer.io/docs/configuration/#removing_activerecord"
+      STDERR.puts "[NoBrainer] Configure NoBrainer with 'config.warn_on_active_record = false' to disable with warning."
+    end
+
+    if defined?(Mongoid)
+      STDERR.puts "[NoBrainer] WARNING: Mongoid is loaded, and we conflict on the symbol decorations"
+      STDERR.puts "[NoBrainer] They are used in queries such as Model.where(:tags.in => ['fun', 'stuff'])"
+      STDERR.puts "[NoBrainer] This is a problem!"
     end
   end
 
   def get_new_connection
-    url = NoBrainer::Config.rethinkdb_url
-    raise "Please specify a database connection to RethinkDB" unless url
-    NoBrainer::Connection.new(url)
+    # We don't want to warn on "rails g nobrainer:install", but because it's
+    # hard to check when the generator is running because of spring as it wipes
+    # ARGV. So we check for other ORMs during the connection instantiation.
+    warn_for_other_orms
+
+    NoBrainer::Connection.new(get_next_url)
   end
 
   def current_connection
@@ -33,6 +46,12 @@ module NoBrainer::ConnectionManager
     end
   end
 
+  def get_next_url
+    @urls ||= NoBrainer::Config.rethinkdb_urls.shuffle
+    @cycle_index = (@cycle_index || 0) + 1
+    @urls[@cycle_index % @urls.size] # not using .cycle due to threading issues
+  end
+
   def connection
     c = self.current_connection
     return c if c
@@ -51,10 +70,11 @@ module NoBrainer::ConnectionManager
     synchronize { _disconnect }
   end
 
-  def disconnect_if_url_changed
+  def notify_url_change
     synchronize do
+      @urls = nil
       c = current_connection
-      _disconnect if c && c.uri != NoBrainer::Config.rethinkdb_url
+      _disconnect if c && !NoBrainer::Config.rethinkdb_urls.include?(c.uri)
     end
   end
 end

data/lib/no_brainer/criteria/cache.rb

@@ -77,4 +77,12 @@ module NoBrainer::Criteria::Cache
 
   use_cache_for :first, :last, :count, :empty?, :any?
   reload_on :update_all, :destroy_all, :delete_all
+
+  private
+
+  def apply_named_scope(name, args, block)
+    return super unless with_cache?
+    @scope_cache ||= {}
+    @scope_cache[[name, args, block]] ||= super
+  end
 end

data/lib/no_brainer/criteria/changes.rb

@@ -0,0 +1,16 @@
+module NoBrainer::Criteria::Changes
+  extend ActiveSupport::Concern
+
+  def changes(*args)
+    return finalized_criteria.changes(*args) unless finalized?
+
+    # We won't do any instantiations with attributes for now.
+    raise 'Please use .raw.changes()' unless raw?
+
+    # We can't have implicit sorting as eager streams are not
+    # supported by r.changes().
+    criteria = self
+    criteria = criteria.without_ordering if ordering_mode == :implicit
+    run { criteria.to_rql.changes(*args) }
+  end
+end

data/lib/no_brainer/criteria/core.rb

@@ -32,11 +32,6 @@ module NoBrainer::Criteria::Core
     to_rql.inspect rescue super
   end
 
-  def run(&block)
-    block ||= proc { to_rql }
-    NoBrainer.run(:criteria => self, &block)
-  end
-
   def merge!(criteria, options={})
     criteria.options.each do |k,v|
       merge_proc = self.class.options_definitions[k]
@@ -105,5 +100,9 @@ module NoBrainer::Criteria::Core
     def append_array(a, b)
       a ? a+b : b
     end
+
+    def merge_hash(a, b)
+      a ? a.merge(b) : b
+    end
   end
 end

data/lib/no_brainer/criteria/eager_load.rb

@@ -15,7 +15,7 @@ module NoBrainer::Criteria::EagerLoad
   def merge!(criteria, options={})
     super.tap do
       # If we already have some cached documents, and we need to so some eager
-      # loading, then we it now. It's easier than doing it lazily.
+      # loading, then we do it now. It's easier than doing it lazily.
       if self.cached? && criteria.options[:eager_load].present?
         perform_eager_load(@cache)
       end
@@ -45,7 +45,7 @@ module NoBrainer::Criteria::EagerLoad
 
   def perform_eager_load(docs)
     if should_eager_load? && docs.present?
-      NoBrainer::Document::Association::EagerLoader.new.eager_load(docs, @options[:eager_load])
+      NoBrainer.eager_load(docs, @options[:eager_load])
     end
   end
 end

data/lib/no_brainer/criteria/enumerable.rb

@@ -3,7 +3,7 @@ module NoBrainer::Criteria::Enumerable
 
   def each(options={}, &block)
     return enum_for(:each, options) unless block
-    self.run.each { |attrs| block.call(instantiate_doc(attrs)) }
+    run.each { |attrs| block.call(instantiate_doc(attrs)) }
     self
   end
 
@@ -21,4 +21,6 @@ module NoBrainer::Criteria::Enumerable
     return super unless [].respond_to?(name)
     to_a.__send__(name, *args, &block)
   end
+
+  delegate :as_json, :to => :each
 end

data/lib/no_brainer/criteria/find.rb

@@ -1,27 +1,24 @@
 module NoBrainer::Criteria::Find
   extend ActiveSupport::Concern
 
-  def find_by?(*args, &block)
-    where(*args, &block).first
-  end
-
   def find_by(*args, &block)
-    find_by?(*args, &block).tap { |doc| raise_not_found(args) unless doc }
+    raise "find_by() has unclear semantics. Please use where().first instead"
   end
   alias_method :find_by!, :find_by
+  alias_method :find_by?, :find_by
 
   def find?(pk)
-    without_ordering.find_by?(model.pk_name => pk)
+    without_ordering.where(model.pk_name => pk).first
   end
 
   def find(pk)
-    without_ordering.find_by(model.pk_name => pk)
+    find?(pk) || raise_not_found(pk)
   end
   alias_method :find!, :find
 
   private
 
-  def raise_not_found(args)
-    raise NoBrainer::Error::DocumentNotFound, "#{model} #{args.inspect.gsub(/\[{(.*)}\]/, '\1')} not found"
+  def raise_not_found(pk)
+    raise NoBrainer::Error::DocumentNotFound, "#{model} :#{model.pk_name}=>#{pk.inspect} not found"
   end
 end

data/lib/no_brainer/criteria/first.rb

@@ -10,11 +10,11 @@ module NoBrainer::Criteria::First
   end
 
   def first!
-    first.tap { |doc| raise NoBrainer::Error::DocumentNotFound unless doc }
+    first || (raise NoBrainer::Error::DocumentNotFound)
   end
 
   def last!
-    last.tap { |doc| raise NoBrainer::Error::DocumentNotFound unless doc }
+    last || (raise NoBrainer::Error::DocumentNotFound)
   end
 
   def sample(n=nil)
@@ -26,6 +26,6 @@ module NoBrainer::Criteria::First
   private
 
   def get_one(criteria)
-    instantiate_doc(criteria.limit(1).run.first)
+    instantiate_doc(criteria.limit(1).__send__(:run).first)
   end
 end

data/lib/no_brainer/criteria/first_or_create.rb

@@ -0,0 +1,114 @@
+module NoBrainer::Criteria::FirstOrCreate
+  extend ActiveSupport::Concern
+
+  def first_or_create(create_params={}, save_options={}, &block)
+    _first_or_create(create_params, save_options.merge(:save_method => :save?), &block)
+  end
+
+  def first_or_create!(create_params={}, save_options={}, &block)
+    _first_or_create(create_params, save_options.merge(:save_method => :save!), &block)
+  end
+
+  def upsert(attrs, save_options={})
+    _upsert(attrs, save_options.merge(:save_method => :save?))
+  end
+
+  def upsert!(attrs, save_options={})
+    _upsert(attrs, save_options.merge(:save_method => :save!))
+  end
+
+  private
+
+  def _upsert(attrs, save_options)
+    attrs = attrs.symbolize_keys
+    unique_keys = get_model_unique_fields.detect { |keys| keys & attrs.keys == keys }
+    raise "Could not find a uniqueness validator within `#{attrs.keys.inspect}'.\n" +
+           "Please add a corresponding uniqueness validator" unless unique_keys
+    where(attrs.slice(*unique_keys)).__send__(:_first_or_create, attrs, save_options)
+  end
+
+  def _first_or_create(create_params, save_options, &block)
+    raise "Cannot use .raw() with .first_or_create()" if raw?
+    raise "Use first_or_create() on the root class `#{model.root_class}'" unless model.is_root_class?
+
+    where_params = extract_where_params()
+
+    # Note that we are not matching a subset of the keys on the uniqueness
+    # validators; we need an exact match on the keys.
+    keys = where_params.keys
+    unless get_model_unique_fields.include?(keys.sort)
+      # We could do without a uniqueness validator, but it's much preferable to
+      # have it, so that we don't conflict with others create(), not just others
+      # first_or_create().
+      raise "Please add the following uniqueness validator for first_or_create():\n" +
+        "class #{model}\n" +
+          case keys.size
+          when 1 then "  field :#{keys.first}, :uniq => true"
+          when 2 then "  field :#{keys.first}, :uniq => {:scope => :#{keys.last}}"
+          else        "  field :#{keys.first}, :uniq => {:scope => #{keys[1..-1].inspect}}"
+          end +
+        "\nend"
+    end
+
+    # We don't want to access create_params yet, because invoking the block
+    # might be costly (the user might be doing some API call or w/e), and
+    # so we want to invoke the block only if necessary.
+    new_instance = model.new(where_params)
+    lock_key_name = model._uniqueness_key_name_from_params(where_params)
+    new_instance._lock_for_uniqueness_once(lock_key_name)
+
+    old_instance = self.first
+    return old_instance if old_instance
+
+    create_params = block.call if block
+    create_params = create_params.symbolize_keys
+
+    keys_in_conflict = create_params.keys & where_params.keys
+    keys_in_conflict = keys_in_conflict.reject { |k| create_params[k] == where_params[k] }
+    unless keys_in_conflict.empty?
+      raise "where() and first_or_create() were given conflicting values " +
+            "on the following keys: #{keys_in_conflict.inspect}"
+    end
+
+    if create_params[:_type]
+      # We have to recreate the instance because we are given a _type in
+      # create_params specifying a subclass. We'll have to transfert the lock
+      # ownership to that new instance.
+      new_instance = model.model_from_attrs(create_params).new(where_params).tap do |i|
+        i.locked_keys_for_uniqueness = new_instance.locked_keys_for_uniqueness
+      end
+    end
+
+    new_instance.assign_attributes(create_params)
+    save_method = save_options.delete(:save_method)
+    new_instance.__send__(save_method, save_options)
+    return new_instance
+  ensure
+    new_instance.try(:unlock_unique_fields)
+  end
+
+  def extract_where_params()
+    where_clauses = finalized_criteria.options[:where_ast]
+
+    unless where_clauses.is_a?(NoBrainer::Criteria::Where::MultiOperator) &&
+           where_clauses.op == :and && where_clauses.clauses.size > 0 &&
+           where_clauses.clauses.all? do |c|
+             c.is_a?(NoBrainer::Criteria::Where::BinaryOperator) &&
+             c.op == :eq && c.key_modifier == :scalar
+           end
+      raise "Please use a query of the form `.where(...).first_or_create(...)'"
+    end
+
+    Hash[where_clauses.clauses.map do |c|
+      raise "You may not use nested hash queries with first_or.create()" if c.key_path.size > 1
+      [c.key_path.first.to_sym, c.value]
+    end]
+  end
+
+  def get_model_unique_fields
+    [[model.pk_name]] +
+      model.unique_validators
+     .flat_map { |validator| validator.attributes.map { |attr| [attr, validator] } }
+     .map { |f, validator| [f, *validator.scope].map(&:to_sym).sort }
+  end
+end

data/lib/no_brainer/criteria/join.rb

@@ -0,0 +1,62 @@
+module NoBrainer::Criteria::Join
+  extend ActiveSupport::Concern
+
+  included { criteria_option :join, :merge_with => :append_array }
+
+  def join(*values)
+    chain(:join => values)
+  end
+
+  private
+
+  def _compile_join_ast(value)
+    case value
+    when Hash then
+      value.reduce({}) do |h, (k,v)|
+        association = model.association_metadata[k.to_sym]
+        raise "`#{k}' must be an association on `#{model}'" unless association
+        raise "join() does not support through associations" if association.options[:through]
+
+        criteria = association.base_criteria
+        criteria = case v
+          when NoBrainer::Criteria then criteria.merge(v)
+          when true then criteria
+          else criteria.join(v)
+        end
+        h.merge(association => criteria)
+      end
+    when Array then value.map { |v| _compile_join_ast(v) }.reduce({}, :merge)
+    else _compile_join_ast(value => true)
+    end
+  end
+
+  def join_ast
+    @join_ast ||= _compile_join_ast(@options[:join])
+  end
+
+  def _instantiate_model(attrs, options={})
+    return super unless @options[:join] && !raw?
+
+    associated_instances = join_ast.map do |association, criteria|
+      [association, criteria.send(:_instantiate_model, attrs.delete(association.target_name.to_s))]
+    end
+    super(attrs, options).tap do |instance|
+      associated_instances.each do |association, assoc_instance|
+        instance.associations[association].preload([assoc_instance])
+      end
+    end
+  end
+
+  def compile_rql_pass2
+    return super unless @options[:join]
+
+    join_ast.reduce(super) do |rql, (association, criteria)|
+      rql.concat_map do |doc|
+        key = doc[association.eager_load_owner_key]
+        criteria.where(association.eager_load_target_key => key).to_rql.map do |assoc_doc|
+          doc.merge(association.target_name => assoc_doc)
+        end
+      end
+    end
+  end
+end