nobrainer 0.16.0 → 0.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe36d41b56c9780a4d16f3085d31de0361d34cae
-  data.tar.gz: 9f89b0da1f34d65c8861345307adc79f93a5593d
+  metadata.gz: 1d6a500e008eff372e800b011e917d121c07e00a
+  data.tar.gz: e43be89ac4963422c26559727c9a68011ee25f8a
 SHA512:
-  metadata.gz: 43e0cf6f767028a46068635713cb9c1d639a8e03de6503493a6af05179977dfe1ae01b5c6a49d93ec0f2e4012a24b0386b6f66d31c7dd274ec05f5f69b252ba3
-  data.tar.gz: e728763fc6095d493db2ed93a9141f72d7cfc927f35300993f0ca6272996a5bac120f6f9cbfc9a985d80329a78da88ec5d827d5af31ccce93c833704b3a17f0b
+  metadata.gz: 56015e819aba3537ab60ea5f039d4b391ec803cc61b5bf246e44da642787e62606e9c02339b17f05976d5428ec3e4fa0e335cb51694b840bd2ba7821b6d66b20
+  data.tar.gz: d4b78185fed14f5baa28165462a4088096da640d93c0dfb3f20c851e968deceb1f48f13602850075a7eea2408fa23e52c2694d140bea1c9a937d7d49d5084f53

data/lib/no_brainer/config.rb

@@ -1,60 +1,81 @@
 require 'logger'
 
 module NoBrainer::Config
+  SETTINGS = {
+    :app_name               => { :default => ->{ default_app_name } },
+    :environment            => { :default => ->{ default_environment } },
+    :rethinkdb_url          => { :default => ->{ default_rethinkdb_url } },
+    :logger                 => { :default => ->{ default_logger } },
+    :warn_on_active_record  => { :default => ->{ true }, :valid_values => [true, false] },
+    :auto_create_databases  => { :default => ->{ true }, :valid_values => [true, false] },
+    :auto_create_tables     => { :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] },
+    :user_timezone          => { :default => ->{ :local }, :valid_values => [:unchanged, :utc, :local] },
+    :db_timezone            => { :default => ->{ :utc }, :valid_values => [:unchanged, :utc, :local] },
+    :colorize_logger        => { :default => ->{ true }, :valid_values => [true, false] },
+    :distributed_lock_class => { :default => ->{ nil } },
+    :per_thread_connection  => { :default => ->{ false }, :valid_values => [true, false] },
+  }
+
   class << self
-    mattr_accessor :rethinkdb_url, :logger, :warn_on_active_record,
-                   :auto_create_databases, :auto_create_tables,
-                   :max_reconnection_tries, :durability,
-                   :user_timezone, :db_timezone, :colorize_logger,
-                   :distributed_lock_class
+    attr_accessor(*SETTINGS.keys)
+
+    def max_reconnection_tries=(value)
+      STDERR.puts "[NoBrainer] config.max_reconnection_tries is deprecated and will be removed"
+      STDERR.puts "[NoBrainer] use config.max_retries_on_connection_failure instead."
+      self.max_retries_on_connection_failure = value
+    end
 
     def apply_defaults
-      self.rethinkdb_url           = default_rethinkdb_url
-      self.logger                  = default_logger
-      self.warn_on_active_record   = true
-      self.auto_create_databases   = true
-      self.auto_create_tables      = true
-      self.max_reconnection_tries  = 10
-      self.durability              = default_durability
-      self.user_timezone           = :local
-      self.db_timezone             = :utc
-      self.colorize_logger         = true
-      self.distributed_lock_class  = nil
+      @applied_defaults_for = SETTINGS.keys.reject { |k| instance_variable_defined?("@#{k}") }
+      @applied_defaults_for.each { |k| __send__("#{k}=", SETTINGS[k][:default].call) }
+    end
+
+    def assert_valid_options!
+      SETTINGS.each { |k,v| assert_array_in(k, v[:valid_values]) if v[:valid_values] }
     end
 
     def reset!
-      @configured = false
-      apply_defaults
+      instance_variables.each { |ivar| remove_instance_variable(ivar) }
     end
 
     def configure(&block)
-      apply_defaults unless configured?
+      @applied_defaults_for.to_a.each { |k| remove_instance_variable("@#{k}") }
       block.call(self) if block
+      apply_defaults
       assert_valid_options!
       @configured = true
 
-      NoBrainer.disconnect_if_url_changed
+      NoBrainer::ConnectionManager.disconnect_if_url_changed
     end
 
     def configured?
       !!@configured
     end
 
-    def assert_valid_options!
-      assert_array_in :durability,    [:hard, :soft]
-      assert_array_in :user_timezone, [:unchanged, :utc, :local]
-      assert_array_in :db_timezone,   [:unchanged, :utc, :local]
-    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}")
       end
     end
 
+    def dev_mode?
+      self.environment.to_s.in? %w(development test)
+    end
+
+    def default_app_name
+      defined?(Rails) ? Rails.application.class.parent_name.underscore.presence : nil rescue nil
+    end
+
+    def default_environment
+      return Rails.env if defined?(Rails.env)
+      ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || :production
+    end
+
     def default_rethinkdb_url
       db = ENV['RETHINKDB_DB'] || ENV['RDB_DB']
-      db ||= "#{Rails.application.class.parent_name.underscore}_#{Rails.env}" rescue nil
+      db ||= "#{self.app_name}_#{self.environment}" if self.app_name && self.environment
       host = ENV['RETHINKDB_HOST'] || ENV['RDB_HOST'] || 'localhost'
       port = ENV['RETHINKDB_PORT'] || ENV['RDB_PORT']
       auth = ENV['RETHINKDB_AUTH'] || ENV['RDB_AUTH']
@@ -68,7 +89,11 @@ module NoBrainer::Config
     end
 
     def default_durability
-      (defined?(Rails.env) && (Rails.env.test? || Rails.env.development?)) ? :soft : :hard
+      dev_mode? ? :soft : :hard
+    end
+
+    def default_max_retries_on_connection_failure
+      dev_mode? ? 1 : 15
     end
   end
 end

data/lib/no_brainer/connection.rb

@@ -52,6 +52,7 @@ class NoBrainer::Connection
   # database (drop)
   def purge!(options={})
     table_list.each do |table_name|
+      next if table_name =~ /^nobrainer_/
       NoBrainer.run { |r| r.table(table_name).delete }
     end
     true

data/lib/no_brainer/connection_manager.rb

@@ -0,0 +1,60 @@
+module NoBrainer::ConnectionManager
+  extend self
+
+  @lock = Mutex.new
+
+  def synchronize(&block)
+    if NoBrainer::Config.per_thread_connection
+      block.call
+    else
+      @lock.synchronize { block.call }
+    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)
+  end
+
+  def current_connection
+    if NoBrainer::Config.per_thread_connection
+      Thread.current[:nobrainer_connection]
+    else
+      @connection
+    end
+  end
+
+  def current_connection=(value)
+    if NoBrainer::Config.per_thread_connection
+      Thread.current[:nobrainer_connection] = value
+    else
+      @connection = value
+    end
+  end
+
+  def connection
+    c = self.current_connection
+    return c if c
+
+    synchronize do
+      self.current_connection ||= get_new_connection
+    end
+  end
+
+  def _disconnect
+    self.current_connection.try(:close, :noreply_wait => false) rescue nil
+    self.current_connection = nil
+  end
+
+  def disconnect
+    synchronize { _disconnect }
+  end
+
+  def disconnect_if_url_changed
+    synchronize do
+      c = current_connection
+      _disconnect if c && c.uri != NoBrainer::Config.rethinkdb_url
+    end
+  end
+end

data/lib/no_brainer/criteria/after_find.rb

@@ -1,23 +1,15 @@
 module NoBrainer::Criteria::AfterFind
   extend ActiveSupport::Concern
 
-  included { attr_accessor :_after_find }
+  included { criteria_option :after_find, :merge_with => :append_array }
 
   def after_find(b=nil, &block)
-    chain { |criteria| criteria._after_find = [b || block] }
-  end
-
-  def merge!(criteria, options={})
-    super
-    if criteria._after_find.present?
-      self._after_find = (self._after_find || []) + criteria._after_find
-    end
-    self
+    chain(:after_find => [b, block].compact)
   end
 
   def _instantiate_doc(attrs)
     super.tap do |doc|
-      self._after_find.to_a.each { |block| block.call(doc) }
+      @options[:after_find].to_a.each { |block| block.call(doc) }
       doc.run_callbacks(:find) if doc.is_a?(NoBrainer::Document)
     end
   end

data/lib/no_brainer/criteria/aggregate.rb

@@ -2,24 +2,27 @@ module NoBrainer::Criteria::Aggregate
   extend ActiveSupport::Concern
 
   def min(*a, &b)
-    instantiate_doc NoBrainer.run { aggregate_rql(:min, *a, &b) }
+    instantiate_doc run { aggregate_rql(:min, *a, &b) }
   end
 
   def max(*a, &b)
-    instantiate_doc NoBrainer.run { aggregate_rql(:max, *a, &b) }
+    instantiate_doc run { aggregate_rql(:max, *a, &b) }
   end
 
   def sum(*a, &b)
-    NoBrainer.run { aggregate_rql(:sum, *a, &b) }
+    run { aggregate_rql(:sum, *a, &b) }
   end
 
   def avg(*a, &b)
-    NoBrainer.run { aggregate_rql(:avg, *a, &b) }
+    run { aggregate_rql(:avg, *a, &b) }
   end
 
   private
 
   def aggregate_rql(type, *a, &b)
-    without_ordering.without_plucking.to_rql.__send__(type, *klass.with_fields_aliased(a), &b)
+    rql = without_ordering.without_plucking.to_rql
+    rql = rql.__send__(type, *model.with_fields_aliased(a), &b)
+    rql = rql.default(nil) unless type == :sum
+    rql
   end
 end

data/lib/no_brainer/criteria/cache.rb

@@ -1,14 +1,14 @@
 module NoBrainer::Criteria::Cache
   extend ActiveSupport::Concern
 
-  included { attr_accessor :_with_cache }
+  included { criteria_option :with_cache, :merge_with => :set_scalar }
 
   def with_cache
-    chain { |criteria| criteria._with_cache = true }
+    chain(:with_cache => true)
   end
 
   def without_cache
-    chain { |criteria| criteria._with_cache = false }
+    chain(:with_cache => false)
   end
 
   def inspect
@@ -18,14 +18,14 @@ module NoBrainer::Criteria::Cache
   end
 
   def merge!(criteria, options={})
+    if options[:copy_cache_from] && options[:copy_cache_from].cached?
+      @cache = options[:copy_cache_from].instance_variable_get(:@cache)
+    end
     super
-    self._with_cache = criteria._with_cache unless criteria._with_cache.nil?
-    self.reload unless options[:keep_cache]
-    self
   end
 
   def with_cache?
-    @_with_cache != false
+    finalized_criteria.options[:with_cache] != false
   end
 
   def reload

data/lib/no_brainer/criteria/core.rb

@@ -1,14 +1,26 @@
 module NoBrainer::Criteria::Core
   extend ActiveSupport::Concern
 
-  included { attr_accessor :init_options }
+  included do
+    singleton_class.send(:attr_accessor, :options_definitions)
+    self.options_definitions = {}
+    attr_accessor :options
+
+    criteria_option :model, :merge_with => :set_scalar
+    criteria_option :finalized, :merge_with => :set_scalar
+  end
 
   def initialize(options={})
-    self.init_options = options
+    @options = options
+  end
+
+  def dup
+    # We don't keep any of the instance variables except options.
+    self.class.new(@options.dup)
   end
 
-  def klass
-    init_options[:klass]
+  def model
+    @options[:model]
   end
 
   def to_rql
@@ -16,16 +28,21 @@ module NoBrainer::Criteria::Core
   end
 
   def inspect
-    # rescue super because sometimes klass is not set.
+    # rescue super because sometimes model is not set.
     to_rql.inspect rescue super
   end
 
-  def run(rql=nil)
-    NoBrainer.run(:criteria => self) { (rql || to_rql) }
+  def run(&block)
+    block ||= proc { to_rql }
+    NoBrainer.run(:criteria => self, &block)
   end
 
   def merge!(criteria, options={})
-    self.init_options = self.init_options.merge(criteria.init_options)
+    criteria.options.each do |k,v|
+      merge_proc = self.class.options_definitions[k]
+      raise "Non declared option: #{k}" unless merge_proc
+      @options[k] = merge_proc.call(@options[k], v)
+    end
     self
   end
 
@@ -40,16 +57,14 @@ module NoBrainer::Criteria::Core
 
   private
 
-  def chain(options={}, &block)
-    tmp = self.class.new(self.init_options) # we might want to optimize that thing
-    block.call(tmp)
-    merge(tmp, options)
+  def chain(options={}, merge_options={}, &block)
+    merge(self.class.new(options), merge_options)
   end
 
   def compile_rql_pass1
     # This method is overriden by other modules.
-    raise "Criteria not bound to a class" unless klass
-    klass.rql_table
+    raise "Criteria not bound to a model" unless model
+    model.rql_table
   end
 
   def compile_rql_pass2
@@ -58,7 +73,7 @@ module NoBrainer::Criteria::Core
   end
 
   def finalized?
-    !!init_options[:finalized]
+    !!@options[:finalized]
   end
 
   def finalized_criteria
@@ -66,8 +81,33 @@ module NoBrainer::Criteria::Core
   end
 
   module ClassMethods
+    def criteria_option(*names)
+      options = names.extract_options!
+
+      names.map(&:to_sym).each do |name|
+        merge_proc = options[:merge_with]
+        merge_proc = MergeStrategies.method(merge_proc) if merge_proc.is_a?(Symbol)
+        self.options_definitions[name] = merge_proc
+      end
+    end
+
     def _finalize_criteria(base)
-      base.merge(base.class.new(:finalized => true))
+      base.__send__(:chain, :finalized => true)
+    end
+  end
+
+  module MergeStrategies
+    extend self
+    def set_scalar(a, b)
+      b
+    end
+
+    def merge_hash(a, b)
+      a ? a.merge(b) : b
+    end
+
+    def append_array(a, b)
+      a ? a+b : b
     end
   end
 end

data/lib/no_brainer/criteria/count.rb

@@ -2,7 +2,7 @@ module NoBrainer::Criteria::Count
   extend ActiveSupport::Concern
 
   def count
-    run(without_ordering.without_plucking.to_rql.count)
+    run { without_ordering.without_plucking.to_rql.count }
   end
 
   def empty?

data/lib/no_brainer/criteria/delete.rb

@@ -2,7 +2,7 @@ module NoBrainer::Criteria::Delete
   extend ActiveSupport::Concern
 
   def delete_all
-    run(without_ordering.without_plucking.to_rql.delete)
+    run { without_ordering.without_plucking.to_rql.delete }
   end
 
   def destroy_all

data/lib/no_brainer/criteria/extend.rb

@@ -0,0 +1,19 @@
+module NoBrainer::Criteria::Extend
+  extend ActiveSupport::Concern
+
+  included { criteria_option :extend, :merge_with => :append_array }
+
+  def extend(*modules, &block)
+    options = modules.extract_options!
+    modules << Module.new(&block) if block
+
+    return super(*modules) if options[:original_behavior]
+    chain(:extend => [modules])
+  end
+
+  def merge!(criteria, options={})
+    super.tap do
+      @options[:extend].to_a.each { |modules| extend(*modules, :original_behavior => true) }
+    end
+  end
+end

data/lib/no_brainer/criteria/first.rb

@@ -18,7 +18,7 @@ module NoBrainer::Criteria::First
   end
 
   def sample(n=nil)
-    result = NoBrainer.run { self.without_ordering.to_rql.sample(n.nil? ? 1 : n) }
+    result = run { self.without_ordering.to_rql.sample(n.nil? ? 1 : n) }
     result = result.map(&method(:instantiate_doc))
     n.nil? ? result.first : result
   end

data/lib/no_brainer/criteria/index.rb

@@ -1,10 +1,10 @@
 module NoBrainer::Criteria::Index
   extend ActiveSupport::Concern
 
-  included { attr_accessor :with_index_name }
+  included { criteria_option :use_index, :merge_with => :set_scalar }
 
   def with_index(index_name=true)
-    chain { |criteria| criteria.with_index_name = index_name }
+    chain(:use_index => index_name)
   end
 
   def without_index
@@ -12,25 +12,19 @@ module NoBrainer::Criteria::Index
   end
 
   def without_index?
-    finalized_criteria.with_index_name == false
+    finalized_criteria.options[:use_index] == false
   end
 
   def used_index
-    # only one of them will be active.
+    # Only one of them will be active.
     where_index_name || order_by_index_name
   end
 
-  def merge!(criteria, options={})
-    super
-    self.with_index_name = criteria.with_index_name unless criteria.with_index_name.nil?
-    self
-  end
-
   def compile_rql_pass2
     super.tap do
-      if with_index_name && (!used_index || order_by_index_name.to_s == klass.pk_name.to_s)
-        # The implicit ordering on the indexed pk does not count.
-        raise NoBrainer::Error::CannotUseIndex.new(with_index_name)
+      # The implicit ordering on the indexed pk does not count.
+      if @options[:use_index] && (!used_index || order_by_index_name.to_s == model.pk_name.to_s)
+        raise NoBrainer::Error::CannotUseIndex.new(@options[:use_index])
       end
     end
   end

data/lib/no_brainer/criteria/limit.rb

@@ -1,31 +1,23 @@
 module NoBrainer::Criteria::Limit
-  # TODO Test these guys
   extend ActiveSupport::Concern
 
-  included { attr_accessor :_skip, :_limit }
+  included { criteria_option :skip, :limit, :merge_with => :set_scalar }
 
   def limit(value)
-    chain { |criteria| criteria._limit = value }
+    chain(:limit => value)
   end
 
   def skip(value)
-    chain { |criteria| criteria._skip = value }
+    chain(:skip => value)
   end
   alias_method :offset, :skip
 
-  def merge!(criteria, options={})
-    super
-    self._skip = criteria._skip if criteria._skip
-    self._limit = criteria._limit if criteria._limit
-    self
-  end
-
   private
 
   def compile_rql_pass2
     rql = super
-    rql = rql.skip(_skip) if _skip
-    rql = rql.limit(_limit) if _limit
+    rql = rql.skip(@options[:skip]) if @options[:skip]
+    rql = rql.limit(@options[:limit]) if @options[:limit]
     rql
   end
 end