nobrainer 0.18.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e146036464db0297a156c6987cb51011137f245
-  data.tar.gz: 7f6815c09410489fbe26b1c0faebdc7aefe001e1
+  metadata.gz: c53755e5f9ec902612c417fcf053404cf114ca0b
+  data.tar.gz: 529fe4b627d366ba4813fd6ff750192caf0df316
 SHA512:
-  metadata.gz: 00b32de4c7ccd965972369698d6619cfa873671d73c5805d03c37e026737eab42cfb5a3d2f94c00323ec05ce84c7baef0702c1572673ed90050f9f02dcf04458
-  data.tar.gz: 661eca7f94fb210e481ecf064829a72b095cc59552de2197856a9226d2978b91c489c26a4045e919368f6d532433b6cbcd3aba8c459c9cd5d2e3bb7f115c6d92
+  metadata.gz: 920d6b1c7bec9acd28b4a0e7f54a9967d068a01d31174396ca961eaf8cbfec31e3b8397ab2242ac87c73b9ca3789e80b47c8ca4b809d7a71b5fa80aeedb81f4b
+  data.tar.gz: 92144b91eb03ac14d2a01ea5244480b215286228691e5406a9f7bcf218499853ecfb0d1313f1380f62d509d97dc2bb1dac65ae8e97c0c2c3cc2b7b4c3835e1c2

data/lib/no_brainer/autoload.rb

@@ -17,9 +17,4 @@ module NoBrainer::Autoload
     constants.each { |constant| autoload constant }
     constants.each { |constant| include const_get(constant) }
   end
-
-  def eager_autoload_and_include(*constants)
-    eager_autoload(*constants)
-    constants.each { |constant| include const_get(constant) }
-  end
 end

data/lib/no_brainer/config.rb

@@ -1,46 +1,61 @@
 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 } },
+    :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 } },
+    :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 } } },
+    :per_thread_connection  => { :default => ->{ false }, :valid_values => [true, false] },
+    :machine_id             => { :default => ->{ default_machine_id } },
+    :criteria_cache_max_entries => { :default => -> { 10_000 } },
+  }
+
   class << self
-    mattr_accessor :app_name, :environment, :rethinkdb_url,
-                   :logger, :warn_on_active_record,
-                   :auto_create_databases, :auto_create_tables,
-                   :max_retries_on_connection_failure, :durability,
-                   :user_timezone, :db_timezone, :colorize_logger,
-                   :distributed_lock_class, :per_thread_connection
+    attr_accessor(*SETTINGS.keys)
+
+    def auto_create_databases=(value)
+      STDERR.puts "[NoBrainer] config.auto_create_databases is no longer active."
+      STDERR.puts "[NoBrainer] The current behavior is now to always auto create databases"
+    end
+
+    def auto_create_tables=(value)
+      STDERR.puts "[NoBrainer] config.auto_create_tables is no longer active."
+      STDERR.puts "[NoBrainer] The current behavior is now to always auto create tables"
+    end
 
     def apply_defaults
-      self.app_name                          = default_app_name
-      self.environment                       = default_environment
-      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_retries_on_connection_failure = default_max_retries_on_connection_failure
-      self.durability                        = default_durability
-      self.user_timezone                     = :local
-      self.db_timezone                       = :utc
-      self.colorize_logger                   = true
-      self.distributed_lock_class            = nil
-      self.per_thread_connection             = false
-    end
-
-    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
+      @applied_defaults_for = SETTINGS.keys.reject { |k| instance_variable_defined?("@#{k}") }
+      @applied_defaults_for.each { |k| __send__("#{k}=", SETTINGS[k][:default].call) }
+    end
+
+    def geo_options=(value)
+      @geo_options = value.try(:symbolize_keys)
+    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
-      assert_valid_options!
+      apply_defaults
+      assert_valid_options
       @configured = true
 
       NoBrainer::ConnectionManager.disconnect_if_url_changed
@@ -50,20 +65,18 @@ module NoBrainer::Config
       !!@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 : nil
+      defined?(Rails) ? Rails.application.class.parent_name.underscore.presence : nil rescue nil
     end
 
     def default_environment
@@ -94,8 +107,29 @@ module NoBrainer::Config
       dev_mode? ? 1 : 15
     end
 
-    def dev_mode?
-      self.environment.to_sym.in?([:development, :test])
+    def default_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
+    end
+
+    def machine_id=(machine_id)
+      machine_id = case machine_id
+        when Integer    then machine_id
+        when /^[0-9]+$/ then machine_id.to_i
+        else raise "Invalid machine_id"
+      end
+      max_id = NoBrainer::Document::PrimaryKey::Generator::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
   end
 end

data/lib/no_brainer/connection.rb

@@ -50,13 +50,11 @@ class NoBrainer::Connection
 
   # Note that truncating each table (purge) is much faster than dropping the
   # database (drop)
-  def purge!(options={})
+  def purge!
     table_list.each do |table_name|
-      next if table_name =~ /^nobrainer_/
+      next if table_name == 'nobrainer_index_meta' # keeping because indexes are not going away
       NoBrainer.run { |r| r.table(table_name).delete }
     end
     true
-  rescue RuntimeError => e
-    raise e unless e.message =~ /No entry with that name/
   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,11 +2,11 @@ module NoBrainer::Criteria::Aggregate
   extend ActiveSupport::Concern
 
   def min(*a, &b)
-    instantiate_doc run { aggregate_rql(:min, *a, &b) }
+    order_by(a, &b).first
   end
 
   def max(*a, &b)
-    instantiate_doc run { aggregate_rql(:max, *a, &b) }
+    order_by(a, &b).last
   end
 
   def sum(*a, &b)

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
@@ -37,15 +37,20 @@ module NoBrainer::Criteria::Cache
   end
 
   def each(options={}, &block)
-    return super unless with_cache? && !options[:no_cache] && block
+    return super unless with_cache? && !options[:no_cache] && block && !@cache_too_small
     return @cache.each(&block) if @cache
 
     cache = []
     super(options.merge(:no_cache => true)) do |instance|
       block.call(instance)
-      cache << instance
+      cache << instance unless @cache_too_small
+
+      if cache.size > NoBrainer::Config.criteria_cache_max_entries
+        cache = []
+        @cache_too_small = true
+      end
     end
-    @cache = cache
+    @cache = cache unless @cache_too_small
     self
   end
 

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 model
-    init_options[:model]
+    @options[:model]
   end
 
   def to_rql
@@ -26,12 +38,16 @@ module NoBrainer::Criteria::Core
   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
 
   def merge(criteria, options={})
-    dup.tap { |new_criteria| new_criteria.merge!(criteria, options) }
+    dup.merge!(criteria, options)
   end
 
   def ==(other)
@@ -41,10 +57,8 @@ 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={})
+    merge(self.class.new(options), merge_options)
   end
 
   def compile_rql_pass1
@@ -59,7 +73,7 @@ module NoBrainer::Criteria::Core
   end
 
   def finalized?
-    !!init_options[:finalized]
+    !!@options[:finalized]
   end
 
   def finalized_criteria
@@ -67,8 +81,29 @@ 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 append_array(a, b)
+      a ? a+b : b
     end
   end
 end

data/lib/no_brainer/criteria/delete.rb

@@ -2,10 +2,10 @@ module NoBrainer::Criteria::Delete
   extend ActiveSupport::Concern
 
   def delete_all
-    run { without_ordering.without_plucking.to_rql.delete }
+    run { without_distinct.without_ordering.without_plucking.to_rql.delete }
   end
 
   def destroy_all
-    to_a.each { |doc| doc.destroy }
+    to_a.each(&:destroy)
   end
 end

data/lib/no_brainer/criteria/eager_load.rb

@@ -0,0 +1,51 @@
+module NoBrainer::Criteria::EagerLoad
+  extend ActiveSupport::Concern
+
+  included { criteria_option :eager_load, :merge_with => :append_array }
+
+  def eager_load(*values)
+    chain({:eager_load => values}, :copy_cache_from => self)
+  end
+
+  def preload(*values)
+    STDERR.puts "[NoBrainer] `preload' is deprecated and will be removed, please use `eager_load' instead"
+    eager_load(*values)
+  end
+
+  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.
+      if self.cached? && criteria.options[:eager_load].present?
+        perform_eager_load(@cache)
+      end
+    end
+  end
+
+  def each(options={}, &block)
+    return super unless should_eager_load? && !options[:no_eager_loading] && block
+
+    docs = []
+    super(options.merge(:no_eager_loading => true)) { |doc| docs << doc }
+    # TODO batch the eager loading with NoBrainer::Config.criteria_cache_max_entries
+    perform_eager_load(docs)
+    docs.each(&block)
+    self
+  end
+
+  private
+
+  def should_eager_load?
+    @options[:eager_load].present? && !raw?
+  end
+
+  def get_one(criteria)
+    super.tap { |doc| perform_eager_load([doc]) }
+  end
+
+  def perform_eager_load(docs)
+    if should_eager_load? && docs.present?
+      NoBrainer::Document::Association::EagerLoader.new.eager_load(docs, @options[:eager_load])
+    end
+  end
+end

data/lib/no_brainer/criteria/extend.rb

@@ -1,31 +1,19 @@
 module NoBrainer::Criteria::Extend
   extend ActiveSupport::Concern
 
-  included { attr_accessor :extend_modules }
+  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 do |criteria|
-      criteria.extend_modules ||= []
-      criteria.extend_modules += [modules]
-    end
+    chain(:extend => [modules])
   end
 
   def merge!(criteria, options={})
-    super
-
-    if criteria.extend_modules.present?
-      self.extend_modules = self.extend_modules.to_a + criteria.extend_modules
+    super.tap do
+      @options[:extend].to_a.each { |modules| extend(*modules, :original_behavior => true) }
     end
-
-    if self.extend_modules.present?
-      self.extend_modules.each { |modules| extend(*modules, :original_behavior => true) }
-    end
-
-    self
   end
 end

data/lib/no_brainer/criteria/find.rb

@@ -0,0 +1,27 @@
+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 }
+  end
+  alias_method :find_by!, :find_by
+
+  def find?(pk)
+    without_ordering.find_by?(model.pk_name => pk)
+  end
+
+  def find(pk)
+    without_ordering.find_by(model.pk_name => pk)
+  end
+  alias_method :find!, :find
+
+  private
+
+  def raise_not_found(args)
+    raise NoBrainer::Error::DocumentNotFound, "#{model} #{args.inspect.gsub(/\[{(.*)}\]/, '\1')} not found"
+  end
+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 == model.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,30 +1,23 @@
 module NoBrainer::Criteria::Limit
   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