nobrainer 0.27.0 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc50cb3ae605543bb7ed3df448d0ff32d3b984d4
-  data.tar.gz: b8ae438c48a0d64408f4966f92002be17f6cdff0
+  metadata.gz: 8406e0c14de6dc8379b7047aa6d7254675e1b1fb
+  data.tar.gz: 0d9906ef55e4f74e5317a6d2377d4c1f19ac9799
 SHA512:
-  metadata.gz: 118724ce72e1c29432aa208b062f9e107b56dc0401d921f5194708a2c3f2b7a95160572cf2cd83cb22f322cad0fb7cfe3939fdccf8eb6ef401da99f975df275b
-  data.tar.gz: 2d5737b1035583abd7f888f61341b0922d85e654b919aee2c282be2fcd07bb144f3654ef76ad2d016289b5692766d72d7d0e7620f8d13a6923d054acab49de91
+  metadata.gz: fdcbf5021c15bad13546e7b346eb73fb7f6d0b62ab861578110b0ab81aafda8c364a4b6fe9b282d0f8f8c6d732ebd8dcc3f5be9aada980b79d34d93b0fed6fea
+  data.tar.gz: afa546845837919bb06b01c7ba4168626b74263244986d4d9d3a7428b9b68b24faa968572f110546fb5afb9c4b57dbb236d5c48556b9ae691d271deea62ff816

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 } } },
+    :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,7 +60,9 @@ 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
@@ -65,9 +75,16 @@ module NoBrainer::Config
       !!@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

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,22 +25,20 @@ 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
-  end
-
   def default_db
     parsed_uri[:db]
   end
@@ -51,13 +48,13 @@ class NoBrainer::Connection
   end
 
   def drop!
-    db_drop(current_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!)
   def purge!
-    table_list.each do |table_name|
-      # keeping the index meta store 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

data/lib/no_brainer/connection_manager.rb

@@ -4,11 +4,7 @@ module NoBrainer::ConnectionManager
   @lock = Mutex.new
 
   def synchronize(&block)
-    if NoBrainer::Config.per_thread_connection
-      block.call
-    else
-      @lock.synchronize { block.call }
-    end
+    @lock.synchronize { block.call }
   end
 
   def warn_for_other_orms
@@ -26,15 +22,12 @@ module NoBrainer::ConnectionManager
   end
 
   def get_new_connection
-    url = NoBrainer::Config.rethinkdb_url
-    raise "Please specify a database connection to RethinkDB" unless 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(url)
+    NoBrainer::Connection.new(get_next_url)
   end
 
   def current_connection
@@ -53,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
@@ -73,8 +72,9 @@ module NoBrainer::ConnectionManager
 
   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.rb

@@ -5,5 +5,5 @@ class NoBrainer::Criteria
   autoload_and_include :Core, :Run, :Raw, :Scope, :AfterFind, :Where, :OrderBy,
                        :Limit, :Pluck, :Count, :Delete, :Enumerable, :Find,
                        :First, :FirstOrCreate, :Changes, :Aggregate, :EagerLoad,
-                       :Update, :Cache, :Index, :Extend
+                       :Update, :Cache, :Index, :Extend, :Join
 end

data/lib/no_brainer/criteria/eager_load.rb

@@ -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/find.rb

@@ -12,7 +12,7 @@ module NoBrainer::Criteria::Find
   end
 
   def find(pk)
-    find?(pk).tap { |doc| raise_not_found(pk) unless doc }
+    find?(pk) || raise_not_found(pk)
   end
   alias_method :find!, :find
 

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)

data/lib/no_brainer/criteria/first_or_create.rb

@@ -1,31 +1,42 @@
 module NoBrainer::Criteria::FirstOrCreate
   extend ActiveSupport::Concern
 
-  def first_or_create(create_params={}, &block)
-    _first_or_create(create_params, :save_method => :save?, &block)
+  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={}, &block)
-    _first_or_create(create_params, :save_method => :save!, &block)
+  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 _first_or_create(create_params={}, options={}, &block)
+  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()
-    keys = where_params.keys
 
-    # When matching on the primary key, we'll just pretend that we have a
-    # uniqueness validator on it. We will be racy against other create(),
-    # but not on first_or_create().
-    # And if we get caught in a race with another create(), we'll just have a
-    # duplicate primary key exception.
-    matched_validator = true if keys == [model.pk_name]
-    matched_validator ||= !!get_uniqueness_validators_map[keys.sort]
-    unless matched_validator
+    # 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().
@@ -53,7 +64,7 @@ module NoBrainer::Criteria::FirstOrCreate
     create_params = create_params.symbolize_keys
 
     keys_in_conflict = create_params.keys & where_params.keys
-    keys_in_conflict = keys_in_conflict.select { |k| create_params[k] == where_params[k] }
+    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}"
@@ -69,7 +80,8 @@ module NoBrainer::Criteria::FirstOrCreate
     end
 
     new_instance.assign_attributes(create_params)
-    new_instance.__send__(options[:save_method])
+    save_method = save_options.delete(:save_method)
+    new_instance.__send__(save_method, save_options)
     return new_instance
   ensure
     new_instance.try(:unlock_unique_fields)
@@ -93,9 +105,10 @@ module NoBrainer::Criteria::FirstOrCreate
     end]
   end
 
-  def get_uniqueness_validators_map
-    Hash[model.unique_validators
+  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, 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

data/lib/no_brainer/criteria/where.rb

@@ -11,6 +11,10 @@ module NoBrainer::Criteria::Where
     chain(:where_ast => parse_clause([*args, block].compact))
   end
 
+  def _where(*args, &block)
+    chain(:where_ast => parse_clause([*args, block].compact, :unsafe => true))
+  end
+
   def self.merge_where_ast(a, b)
     (a ? MultiOperator.new(:and, [a, b]) : b).simplify
   end
@@ -90,20 +94,19 @@ module NoBrainer::Criteria::Where
 
     def simplify
       new_key_path = cast_key_path(key_path)
-      new_op, new_value = case op
+      new_key_modifier, new_op, new_value = case op
         when :in then
           case value
-          when Range then [:between, (cast_value(value.min)..cast_value(value.max))]
-          when Array then [:in, value.map(&method(:cast_value)).uniq]
+          when Range then [key_modifier, :between, (cast_value(value.min)..cast_value(value.max))]
+          when Array then [key_modifier, :in, value.map(&method(:cast_value)).uniq]
           else raise ArgumentError.new "`in' takes an array/range, not #{value}"
           end
-        when :between then [op, (cast_value(value.min)..cast_value(value.max))]
-        when :defined
-          raise "Incorrect use of `#{op}' and `#{key_modifier}'" if key_modifier != :scalar
-          [op, cast_value(value)]
-        else [op, cast_value(value)]
+        when :between then [key_modifier, op, (cast_value(value.min)..cast_value(value.max))]
+        when :include then ensure_scalar_for(op); [:any, :eq, cast_value(value)]
+        when :defined, :undefined then ensure_scalar_for(op); [key_modifier, op, cast_value(value)]
+        else [key_modifier, op, cast_value(value)]
       end
-      BinaryOperator.new(new_key_path, key_modifier, new_op, new_value, model, true)
+      BinaryOperator.new(new_key_path, new_key_modifier, new_op, new_value, model, true)
     end
 
     def to_rql(doc)
@@ -115,7 +118,8 @@ module NoBrainer::Criteria::Where
       case key_modifier
       when :scalar then
         case op
-        when :defined then value ? doc.has_fields(key) : doc.has_fields(key).not
+        when :defined   then  value ? doc.has_fields(key) : doc.has_fields(key).not
+        when :undefined then !value ? doc.has_fields(key) : doc.has_fields(key).not
         else to_rql_scalar(doc[key])
         end
       when :any then doc[key].map { |lvalue| to_rql_scalar(lvalue) }.contains(true)
@@ -142,6 +146,10 @@ module NoBrainer::Criteria::Where
 
     private
 
+    def ensure_scalar_for(op)
+      raise "Incorrect use of `#{op}' and `#{key_modifier}'" if key_modifier != :scalar
+    end
+
     def association
       return nil if key_path.size > 1
       @association ||= [model.association_metadata[key_path.first]]
@@ -161,7 +169,7 @@ module NoBrainer::Criteria::Where
         value.pk_value
       else
         case op
-        when :defined then NoBrainer::Boolean.nobrainer_cast_user_to_model(value)
+        when :defined, :undefined then NoBrainer::Boolean.nobrainer_cast_user_to_model(value)
         when :intersects
           raise "Use a geo object with `intersects`" unless value.is_a?(NoBrainer::Geo::Base)
           value
@@ -308,14 +316,17 @@ module NoBrainer::Criteria::Where
                 end if op == :eq
 
     nested_prefix = options[:nested_prefix] || []
+
+    tail_args = [op, value, self.model, !!options[:unsafe]]
+
     case key
     when Symbol::Decoration
       raise "Use only one .not, .all or .any modifiers in the query" if key.symbol.is_a?(Symbol::Decoration)
       case key.decorator
-        when :any, :all then BinaryOperator.new(nested_prefix + [key.symbol], key.decorator, op, value, self.model)
-        when :not       then UnaryOperator.new(:not, BinaryOperator.new(nested_prefix + [key.symbol], :scalar, op, value, self.model))
+        when :any, :all then BinaryOperator.new(nested_prefix + [key.symbol], key.decorator, *tail_args)
+        when :not       then UnaryOperator.new(:not, BinaryOperator.new(nested_prefix + [key.symbol], :scalar, *tail_args))
       end
-    else BinaryOperator.new(nested_prefix + [key], :scalar, op, value, self.model)
+    else BinaryOperator.new(nested_prefix + [key], :scalar, *tail_args)
     end
   end