nobrainer 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 572e2605dd72110fd1289cd62b1faa0bf34ae8ef
-  data.tar.gz: 55e77059966a3a7cd4d7e95925572304421b20cc
+  metadata.gz: ea32475119089388850bb55326aab70d4a3dbc16
+  data.tar.gz: dfbef7c1a239b75cb3b45d32b593026ef4d8df93
 SHA512:
-  metadata.gz: f55312ff9a9617ac05f987a27b4318fe6b039f71e3d52025079c8649d1d41517ed3b3e24023ae29c3f0dc2f16402c9f5d5e5075fdc6553d8184de64c614c0a42
-  data.tar.gz: 5337d0ae57e1de9303483df505b02c708ac06e735f44ff794a9c72ac0a8b06e972599ba15735744a82e9286942a9de7ae137c99d6b358c3285bf4f6651a5576d
+  metadata.gz: d83f20ced889fba1ba1048e6ad41f4c7a6a1ae02562c8bf230580a66e64306d9a064eb179a500b61b230f026bbc93a8bf8876f4b4edbf2e21c1a2140decb743d
+  data.tar.gz: a9a671db853f43d369550c7b1031a3a9ad17b9d5307aee6aea659e3808364c6d3d77b0ecfe9d2354a08efb99df7f44f085566d36d2f787a3e1d7469ec915ba52

data/lib/no_brainer/config.rb

@@ -2,9 +2,7 @@ module NoBrainer::Config
   class << self
     mattr_accessor :rethinkdb_url, :logger, :warn_on_active_record,
                    :auto_create_databases, :auto_create_tables,
-                   :cache_documents, :auto_include_timestamps,
-                   :max_reconnection_tries, :include_root_in_json,
-                   :durability, :colorize_logger
+                   :max_reconnection_tries, :durability, :colorize_logger
 
     def apply_defaults
       self.rethinkdb_url           = default_rethinkdb_url
@@ -12,10 +10,7 @@ module NoBrainer::Config
       self.warn_on_active_record   = true
       self.auto_create_databases   = true
       self.auto_create_tables      = true
-      self.cache_documents         = true
-      self.auto_include_timestamps = true
       self.max_reconnection_tries  = 10
-      self.include_root_in_json    = false
       self.durability              = default_durability
       self.colorize_logger         = true
     end
@@ -38,16 +33,14 @@ module NoBrainer::Config
     end
 
     def default_rethinkdb_url
-      return ENV['RETHINKDB_URL'] if ENV['RETHINKDB_URL']
-
-      if defined?(Rails)
-        host = ENV['RETHINKDB_HOST'] || 'localhost'
-        port = ENV['RETHINKDB_PORT']
-        auth = ENV['RETHINKDB_AUTH']
-        db_name = "#{Rails.application.class.parent_name.underscore}_#{Rails.env}"
-
-        "rethinkdb://#{":#{auth}@" if auth}#{host}#{":#{port}" if port}/#{db_name}"
-      end
+      db = ENV['RETHINKDB_DB'] || ENV['RDB_DB']
+      db ||= "#{Rails.application.class.parent_name.underscore}_#{Rails.env}" if defined?(Rails)
+      host = ENV['RETHINKDB_HOST'] || ENV['RDB_HOST'] || 'localhost'
+      port = ENV['RETHINKDB_PORT'] || ENV['RDB_PORT']
+      auth = ENV['RETHINKDB_AUTH'] || ENV['RDB_AUTH']
+      url = ENV['RETHINKDB_URL'] || ENV['RDB_URL']
+      url ||= "rethinkdb://#{":#{auth}@" if auth}#{host}#{":#{port}" if port}/#{db}" if db
+      url
     end
 
     def default_logger

data/lib/no_brainer/connection.rb

@@ -1,24 +1,38 @@
 require 'rethinkdb'
 
 class NoBrainer::Connection
-  # A connection is bound to a specific database.
-
-  attr_accessor :uri, :host, :port, :database_name, :auth_key
+  attr_accessor :uri
 
   def initialize(uri)
     self.uri = uri
-    parse_uri
+    parsed_uri # just to raise an exception if there is a problem.
+  end
+
+  def parsed_uri
+    require 'uri'
+    uri = URI.parse(self.uri)
+
+    if uri.scheme != 'rethinkdb'
+      raise NoBrainer::Error::Connection,
+        "Invalid URI. Expecting something like rethinkdb://host:port/database. Got #{uri}"
+    end
+
+    { :auth_key => uri.password,
+      :host     => uri.host,
+      :port     => uri.port || 28015,
+      :db       => uri.path.gsub(/^\//, ''),
+    }.tap { |result| raise "No database specified in #{uri}" unless result[:db].present? }
   end
 
   def raw
-    @raw ||= RethinkDB::Connection.new(:host => host, :port => port, :db => database_name, :auth_key => auth_key)
+    @raw ||= RethinkDB::Connection.new(parsed_uri)
   end
 
   delegate :reconnect, :close, :run, :to => :raw
   alias_method :connect, :raw
   alias_method :disconnect, :close
 
-  [:db_create, :db_drop, :db_list].each do |cmd|
+  [: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) }
@@ -26,28 +40,20 @@ class NoBrainer::Connection
     RUBY
   end
 
-  def database
-    @database ||= NoBrainer::Database.new(self)
+  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
   end
 
-  private
-
-  def parse_uri
-    require 'uri'
-    parsed_uri = URI.parse(uri)
-
-    if parsed_uri.scheme != 'rethinkdb'
-      raise NoBrainer::Error::Connection,
-        "Invalid URI. Expecting something like rethinkdb://host:port/database. Got #{uri}"
+  # Note that truncating each table (purge) is much faster than dropping the
+  # database (drop)
+  def purge!(options={})
+    table_list.each do |table_name|
+      NoBrainer.run { |r| r.table(table_name).delete }
     end
-
-    apply_connection_settings!(parsed_uri)
-  end
-
-  def apply_connection_settings!(uri)
-    self.host = uri.host
-    self.port = uri.port || 28015
-    self.database_name = uri.path.gsub(/^\//, '')
-    self.auth_key = uri.password
+    true
+  rescue RuntimeError => e
+    raise e unless e.message =~ /No entry with that name/
   end
 end

data/lib/no_brainer/criteria/chainable/core.rb

@@ -1,18 +1,18 @@
 module NoBrainer::Criteria::Chainable::Core
   extend ActiveSupport::Concern
 
-  included { attr_accessor :options }
+  included { attr_accessor :init_options }
 
   def initialize(options={})
-    self.options = options
+    self.init_options = options
   end
 
   def klass
-    options[:klass]
+    init_options[:klass]
   end
 
   def to_rql
-    compile_criteria.__send__(:compile_rql)
+    with_default_scope_applied.__send__(:compile_rql_pass2)
   end
 
   def inspect
@@ -29,39 +29,36 @@ module NoBrainer::Criteria::Chainable::Core
     NoBrainer.run(rql || to_rql)
   end
 
-  def merge!(criteria)
-    self.options = self.options.merge(criteria.options)
+  def merge!(criteria, options={})
+    self.init_options = self.init_options.merge(criteria.init_options)
     self
   end
 
-  def merge(criteria)
-    dup.tap { |new_criteria| new_criteria.merge!(criteria) }
+  def merge(criteria, options={})
+    dup.tap { |new_criteria| new_criteria.merge!(criteria, options) }
   end
 
   def ==(other)
-    return super if other.is_a?(NoBrainer::Criteria)
-    return to_a == other if other.is_a?(Enumerable) && other.first.is_a?(NoBrainer::Document)
+    return to_a == other if other.is_a?(Array)
     super
   end
 
   private
 
-  def chain(&block)
-    tmp = self.class.new(options) # we might want to optimize that thing
+  def chain(options={}, &block)
+    tmp = self.class.new(self.init_options) # we might want to optimize that thing
     block.call(tmp)
-    merge(tmp)
+    merge(tmp, options)
   end
 
-  def compile_criteria
+  def compile_rql_pass1
     # This method is overriden by other modules.
-    # compile_criteria returns a criteria that will be used to generate the RQL.
-    # This is useful to apply the class default scope at the very end of the chain.
-    self
+    raise "Criteria not bound to a class" unless klass
+    klass.rql_table
   end
 
-  def compile_rql
+  def compile_rql_pass2
     # This method is overriden by other modules.
-    raise "Criteria not bound to a class" unless klass
-    klass.rql_table
+    compile_rql_pass1
   end
 end

data/lib/no_brainer/criteria/chainable/limit.rb

@@ -13,7 +13,7 @@ module NoBrainer::Criteria::Chainable::Limit
   end
   alias_method :offset, :skip
 
-  def merge!(criteria)
+  def merge!(criteria, options={})
     super
     self._skip = criteria._skip if criteria._skip
     self._limit = criteria._limit if criteria._limit
@@ -22,7 +22,7 @@ module NoBrainer::Criteria::Chainable::Limit
 
   private
 
-  def compile_rql
+  def compile_rql_pass2
     rql = super
     rql = rql.skip(_skip) if _skip
     rql = rql.limit(_limit) if _limit

data/lib/no_brainer/criteria/chainable/order_by.rb

@@ -28,7 +28,7 @@ module NoBrainer::Criteria::Chainable::OrderBy
     end
   end
 
-  def merge!(criteria)
+  def merge!(criteria, options={})
     super
     # The latest order_by() wins
     self.order = criteria.order if criteria.order.present?
@@ -43,14 +43,16 @@ module NoBrainer::Criteria::Chainable::OrderBy
   private
 
   def effective_order
-    self.order.present? ? self.order : {:id => :asc}
+    self.order.presence || {:id => :asc}
   end
 
   def reverse_order?
     !!self._reverse_order
   end
 
-  def compile_rql
+  def compile_rql_pass1
+    rql = super
+
     rql_rules = effective_order.map do |k,v|
       case v
       when :asc  then reverse_order? ? RethinkDB::RQL.new.desc(k) : RethinkDB::RQL.new.asc(k)
@@ -58,16 +60,31 @@ module NoBrainer::Criteria::Chainable::OrderBy
       end
     end
 
-    options = {}
-    unless without_index?
+    # We can only apply an index order_by on a table() term.
+    # We are going to try to go so and if we cannot, we'll simply apply
+    # the ordering in pass2, which will happen after a potential filter().
+
+    if rql.body.type == Term::TermType::TABLE && !without_index?
+      options = {}
       first_key = effective_order.first[0]
-      first_key = nil if first_key == :id # FIXME For some reason, using the id index doesn't work.
       if (first_key.is_a?(Symbol) || first_key.is_a?(String)) && klass.has_index?(first_key)
         options[:index] = rql_rules.shift
       end
+
+      rql = rql.order_by(*rql_rules, options)
+    else
+      # Stashing @rql_rules for pass2, which is a pretty gross hack.
+      # We should really use more of a middleware pattern to build the RQL.
+      @rql_rules_pass2 = rql_rules
     end
 
-    super.order_by(*rql_rules, options)
+    rql
+  end
+
+  def compile_rql_pass2
+    rql = super
+    rql = rql.order_by(*@rql_rules_pass2) if @rql_rules_pass2
+    rql
   end
 
   def raise_bad_rule(rule)

data/lib/no_brainer/criteria/chainable/raw.rb

@@ -1,15 +1,22 @@
 module NoBrainer::Criteria::Chainable::Raw
   extend ActiveSupport::Concern
 
-  included { attr_accessor :_raw }
+  included { attr_accessor :_raw, :__after_instantiate }
 
   def raw
     chain { |criteria| criteria._raw = true }
   end
 
-  def merge!(criteria)
+  def _after_instantiate(block)
+    # Just some helper for the has_many association to set the inverses on the
+    # related belongs_to. A bit hackish.
+    chain { |criteria| criteria.__after_instantiate = block }
+  end
+
+  def merge!(criteria, options={})
     super
     self._raw = criteria._raw unless criteria._raw.nil?
+    self.__after_instantiate ||= criteria.__after_instantiate
     self
   end
 
@@ -20,6 +27,7 @@ module NoBrainer::Criteria::Chainable::Raw
   end
 
   def instantiate_doc(attrs)
-    raw? ? attrs : klass.new_from_db(attrs)
+    (raw? ? attrs : klass.new_from_db(attrs))
+      .tap { |doc| __after_instantiate.call(doc) if __after_instantiate }
   end
 end

data/lib/no_brainer/criteria/chainable/scope.rb

@@ -11,7 +11,7 @@ module NoBrainer::Criteria::Chainable::Scope
     chain { |criteria| criteria.use_default_scope = false }
   end
 
-  def merge!(criteria)
+  def merge!(criteria, options={})
     super
     self.use_default_scope = criteria.use_default_scope unless criteria.use_default_scope.nil?
     self
@@ -30,12 +30,16 @@ module NoBrainer::Criteria::Chainable::Scope
 
   private
 
-  def compile_criteria
-    criteria = super
-    if klass.default_scope_proc && use_default_scope != false
-      criteria = klass.default_scope_proc.call.merge(criteria)
-      # XXX If default_scope.class != criteria.class, oops
+  def should_apply_default_scope?
+    klass.default_scope_proc && use_default_scope != false
+  end
+
+  def with_default_scope_applied
+    if should_apply_default_scope?
+      # XXX If default_scope.class != self.class, oops
+      klass.default_scope_proc.call.merge(self).unscoped
+    else
+      self
     end
-    criteria
   end
 end

data/lib/no_brainer/criteria/chainable/where.rb

@@ -1,8 +1,6 @@
 module NoBrainer::Criteria::Chainable::Where
   extend ActiveSupport::Concern
 
-  RESERVED_FIELDS = [:index, :default, :and, :or] + NoBrainer::DecoratedSymbol::MODIFIERS.keys
-
   included { attr_accessor :where_ast, :with_index_name }
 
   def initialize(options={})
@@ -23,14 +21,14 @@ module NoBrainer::Criteria::Chainable::Where
   end
 
   def used_index
-    IndexFinder.new(compile_criteria).tap { |finder| finder.find_index }.index_name
+    index_finder.index_name
   end
 
   def indexed?
-    !!used_index
+    index_finder.could_find_index?
   end
 
-  def merge!(criteria)
+  def merge!(criteria, options={})
     super
     clauses = self.where_ast.clauses + criteria.where_ast.clauses
     self.where_ast = MultiOperator.new(:and, clauses).simplify
@@ -58,6 +56,7 @@ module NoBrainer::Criteria::Chainable::Where
 
   class BinaryOperator < Struct.new(:key, :op, :value)
     def simplify
+      # TODO Simplify the in uniq
       self
     end
 
@@ -132,6 +131,17 @@ module NoBrainer::Criteria::Chainable::Where
   end
 
   class IndexFinder < Struct.new(:criteria, :index_name, :indexed_values, :ast)
+    def initialize(*args)
+      super
+      find_index
+    end
+
+    def could_find_index?
+      !!self.index_name
+    end
+
+    private
+
     def get_candidate_clauses(*types)
       Hash[criteria.where_ast.clauses
         .select { |c| c.is_a?(BinaryOperator) && types.include?(c.op) }
@@ -175,23 +185,30 @@ module NoBrainer::Criteria::Chainable::Where
     end
 
     def find_index
-      return false if criteria.__send__(:without_index?)
-      could_find_index = find_index_canonical || find_index_compound
-      if criteria.with_index_name && !could_find_index
+      return if criteria.__send__(:without_index?)
+      find_index_canonical || find_index_compound
+      if criteria.with_index_name && !could_find_index?
         raise NoBrainer::Error::CannotUseIndex.new("Cannot use index #{criteria.with_index_name}")
       end
-      !!could_find_index
     end
   end
 
-  def compile_rql
+  def index_finder
+    return with_default_scope_applied.__send__(:index_finder) if should_apply_default_scope?
+    @index_finder ||= IndexFinder.new(self)
+  end
+
+  def compile_rql_pass1
     rql = super
-    ast = self.where_ast
-    finder = IndexFinder.new(self)
-    if finder.find_index
-      ast = finder.ast
-      rql = rql.get_all(*finder.indexed_values, :index => finder.index_name)
+    if index_finder.could_find_index?
+      rql = rql.get_all(*index_finder.indexed_values, :index => index_finder.index_name)
     end
+    rql
+  end
+
+  def compile_rql_pass2
+    rql = super
+    ast = index_finder.could_find_index? ? index_finder.ast : self.where_ast
     rql = rql.filter { |doc| ast.to_rql(doc) } if ast.clauses.present?
     rql
   end