nobrainer 0.16.0 → 0.18.1

data/lib/no_brainer/document/index/synchronizer.rb

@@ -0,0 +1,68 @@
+class NoBrainer::Document::Index::Synchronizer
+  Index = NoBrainer::Document::Index::Index
+  MetaStore = NoBrainer::Document::Index::MetaStore
+
+  def initialize(models)
+    @models_indexes_map = Hash[models.map do |model|
+      [model, model.indexes.values.reject { |index| index.name == model.pk_name }]
+    end]
+  end
+
+  def meta_store_on(db_name)
+    @meta_store ||= {}
+    @meta_store[db_name] ||= MetaStore.on(db_name) { MetaStore.all.to_a }
+  end
+
+  class Op < Struct.new(:index, :op, :args)
+    def run(options={})
+      index.__send__(op, *args, options)
+    end
+  end
+
+  def _generate_plan_for(model, wanted_indexes)
+    current_indexes = NoBrainer.run(model.rql_table.index_status).map do |s|
+      meta = meta_store_on(model.database_name)
+               .select { |i| i.table_name == model.table_name && i.index_name == s['index'] }.last
+      Index.new(model, s['index'], s['index'], nil, nil, nil, s['geo'], s['multi'], meta)
+    end
+
+    all_aliased_names = (wanted_indexes + current_indexes).map(&:aliased_name).uniq
+    all_aliased_names.map do |aliased_name|
+      wanted_index = wanted_indexes.select { |i| i.aliased_name == aliased_name }.first
+      current_index = current_indexes.select { |i| i.aliased_name == aliased_name }.first
+
+      next if wanted_index.try(:external)
+
+      case [!wanted_index.nil?, !current_index.nil?]
+      when [true, false] then Op.new(wanted_index, :create)
+      when [false, true] then Op.new(current_index, :delete)
+      when [true, true]  then
+        case wanted_index.same_definition?(current_index)
+        when true  then nil # up to date
+        when false then Op.new(current_index, :update, [wanted_index])
+        end
+      end
+    end.compact
+  end
+
+  def generate_plan
+    @models_indexes_map.map { |model, indexes| _generate_plan_for(model, indexes) }.flatten(1)
+  end
+
+  def sync_indexes(options={})
+    plan = generate_plan
+    plan.each { |op| op.run(options) }
+    unless options[:wait] == false
+      models = plan.map(&:index).map(&:model).uniq
+      models.each { |model| NoBrainer.run(model.rql_table.index_wait()) }
+    end
+  end
+
+  class << self
+    def instance
+      new(NoBrainer::Document.all)
+    end
+
+    delegate :sync_indexes, :to => :instance
+  end
+end

data/lib/no_brainer/document/index.rb

@@ -1,6 +1,9 @@
 module NoBrainer::Document::Index
-  VALID_INDEX_OPTIONS = [:multi, :as]
+  VALID_INDEX_OPTIONS = [:external, :geo, :multi, :as]
   extend ActiveSupport::Concern
+  extend NoBrainer::Autoload
+
+  autoload :Index, :Synchronizer, :MetaStore
 
   included do
     cattr_accessor :indexes, :instance_accessor => false
@@ -16,9 +19,9 @@ module NoBrainer::Document::Index
       raise "Too many arguments: #{args}" if args.size > 1
 
       kind, what = case args.first
-        when nil   then [:single,   name.to_sym]
-        when Array then [:compound, args.first.map(&:to_sym)]
-        when Proc  then [:proc,     args.first]
+        when nil    then [:single,   name.to_sym]
+        when Array  then [:compound, args.first.map(&:to_sym)]
+        when Proc   then [:proc,     args.first]
         else raise "Index argument must be a lambda or a list of fields"
       end
 
@@ -35,7 +38,8 @@ module NoBrainer::Document::Index
       as ||= name
       as = as.to_sym
 
-      indexes[name] = {:kind => kind, :what => what, :as => as, :options => options}
+      indexes[name] = NoBrainer::Document::Index::Index.new(self.root_class, name, as,
+        kind, what, options[:external], options[:geo], options[:multi], nil)
     end
 
     def remove_index(name)
@@ -46,12 +50,8 @@ module NoBrainer::Document::Index
       !!indexes[name.to_sym]
     end
 
-    def lookup_index_alias(attr)
-      indexes[attr.to_sym].try(:[], :as) || attr
-    end
-
     def _field(attr, options={})
-      if has_index?(attr) && indexes[attr][:kind] != :single
+      if has_index?(attr) && indexes[attr].kind != :single
         raise "Cannot reuse index attr #{attr}"
       end
 
@@ -68,71 +68,12 @@ module NoBrainer::Document::Index
     end
 
     def _remove_field(attr, options={})
-      super
       remove_index(attr) if fields[attr][:index]
+      super
     end
 
-    def perform_create_index(index_name, options={})
-      index_name = index_name.to_sym
-      index_args = self.indexes[index_name]
-
-      index_proc = case index_args[:kind]
-        when :single   then ->(doc) { doc[lookup_field_alias(index_name)] }
-        when :compound then ->(doc) { index_args[:what].map { |field| doc[lookup_field_alias(field)] } }
-        when :proc     then index_args[:what]
-      end
-
-      NoBrainer.run(self.rql_table.index_create(index_args[:as], index_args[:options], &index_proc))
-      wait_for_index(index_name) unless options[:wait] == false
-
-      if options[:verbose]
-        if index_name == index_args[:as]
-          STDERR.puts "Created index #{self}.#{index_name}"
-        else
-          STDERR.puts "Created index #{self}.#{index_name} as #{index_args[:as]}"
-        end
-      end
-    end
-
-    def perform_drop_index(index_name, options={})
-      aliased_name = self.indexes[index_name].try(:[], :as) || index_name
-      NoBrainer.run(self.rql_table.index_drop(aliased_name))
-
-      if options[:verbose]
-        if index_name == index_args[:as]
-          STDERR.puts "Dropped index #{self}.#{index_name}"
-        else
-          STDERR.puts "Dreated index #{self}.#{index_name} as #{index_args[:as]}"
-        end
-      end
-    end
-
-    def get_index_alias_reverse_map
-      Hash[self.indexes.map { |k,v| [v[:as], k] }].tap do |mapping|
-        raise "Detected clashing index aliases" if mapping.count != self.indexes.count
-      end
-    end
-
-    def perform_update_indexes(options={})
-      alias_mapping = self.get_index_alias_reverse_map
-      current_indexes = NoBrainer.run(self.rql_table.index_list).map do |index|
-        alias_mapping[index.to_sym] || index.to_sym
-      end
-      wanted_indexes = self.indexes.keys - [self.pk_name]
-
-      (current_indexes - wanted_indexes).each do |index_name|
-        perform_drop_index(index_name, options)
-      end
-
-      (wanted_indexes - current_indexes).each do |index_name|
-        perform_create_index(index_name, options)
-      end
-    end
-    alias_method :update_indexes, :perform_update_indexes
-
-    def wait_for_index(index_name=nil, options={})
-      args = [index_name].compact
-      NoBrainer.run(self.rql_table.index_wait(*args))
+    def lookup_index_alias(attr)
+      indexes[attr.to_sym].try(:aliased_name) || attr
     end
   end
 end

data/lib/no_brainer/document/lazy_fetch.rb

@@ -19,7 +19,7 @@ module NoBrainer::Document::LazyFetch
     lazy_fetch = self.class.fields_to_lazy_fetch.to_a
     return super unless lazy_fetch.present?
     return super if options[:pluck]
-    super(options.merge(:without => lazy_fetch, :lazy_fetch => lazy_fetch))
+    super(options.deep_merge(:without => lazy_fetch, :lazy_fetch => lazy_fetch))
   end
 
   module ClassMethods
@@ -31,12 +31,12 @@ module NoBrainer::Document::LazyFetch
     def _field(attr, options={})
       super
       attr = attr.to_s
-      klass = self
+      model = self
       inject_in_layer :lazy_fetch do
         if options[:lazy_fetch]
-          klass.for_each_subclass { |_klass| _klass.fields_to_lazy_fetch << attr }
+          model.for_each_subclass { |_model| _model.fields_to_lazy_fetch << attr }
         else
-          klass.for_each_subclass { |_klass|  _klass.fields_to_lazy_fetch.delete(attr) }
+          model.for_each_subclass { |_model|  _model.fields_to_lazy_fetch.delete(attr) }
         end
 
         # Lazy loading can also specified through criteria.
@@ -57,7 +57,7 @@ module NoBrainer::Document::LazyFetch
 
     def _remove_field(attr, options={})
       super
-      for_each_subclass { |klass| klass.fields_to_lazy_fetch.delete(attr) }
+      for_each_subclass { |model| model.fields_to_lazy_fetch.delete(attr) }
       inject_in_layer :lazy_fetch do
         remove_method("#{attr}") if method_defined?("#{attr}")
       end

data/lib/no_brainer/document/missing_attributes.rb

@@ -45,29 +45,12 @@ module NoBrainer::Document::MissingAttributes
     end
   end
 
+  def _read_attribute(name)
+    assert_access_field(name)
+    super
+  end
 
-  module ClassMethods
-    def _field(attr, options={})
-      super
-
-      inject_in_layer :missing_attributes do
-        define_method("#{attr}") do
-          assert_access_field(attr)
-          super()
-        end
-
-        define_method("#{attr}=") do |value|
-          super(value).tap { clear_missing_field(attr) }
-        end
-      end
-    end
-
-    def _remove_field(attr, options={})
-      super
-      inject_in_layer :missing_attributes do
-        remove_method("#{attr}=")
-        remove_method("#{attr}")
-      end
-    end
+  def _write_attribute(name, value)
+    super.tap { clear_missing_field(name) }
   end
 end

data/lib/no_brainer/document/persistance.rb

@@ -60,20 +60,22 @@ module NoBrainer::Document::Persistance
   end
 
   def _create(options={})
-    return false if options[:validate] && !valid?
-    keys = self.class.insert_all(@_attributes)
-    self.pk_value ||= keys.first
+    return false if options[:validate] != false && !valid?(nil, :clear_errors => false)
+
+    attrs = self.class.persistable_attributes(@_attributes, :instance => self)
+    result = NoBrainer.run(self.class.rql_table.insert(attrs))
+    self.pk_value ||= result['generated_keys'].to_a.first
     @new_record = false
     true
   end
 
   def _update(attrs)
-    attrs = self.class.persistable_attributes(attrs)
-    NoBrainer.run { selector.update(attrs) }
+    rql = ->(doc){ self.class.persistable_attributes(attrs, :instance => self, :rql_doc => doc) }
+    NoBrainer.run { selector.update(&rql) }
   end
 
   def _update_only_changed_attrs(options={})
-    return false if options[:validate] && !valid?
+    return false if options[:validate] != false && !valid?(nil, :clear_errors => false)
 
     # We won't be using the `changes` values, because they went through
     # read_attribute(), and we want the raw values.
@@ -88,23 +90,42 @@ module NoBrainer::Document::Persistance
     true
   end
 
-  def save(options={})
-    options = options.reverse_merge(:validate => true)
+  def _save?(options)
     new_record? ? _create(options) : _update_only_changed_attrs(options)
   end
 
+  def save?(options={})
+    errors.clear
+    _save?(options)
+  end
+
+  def save(*args)
+    save?(*args) or raise NoBrainer::Error::DocumentInvalid, self
+    nil
+  end
+
   def save!(*args)
-    save(*args) or raise NoBrainer::Error::DocumentInvalid, self
+    save(*args)
+    :you_should_be_using_the_non_bang_version_of_save
   end
 
-  def update_attributes(attrs, options={})
+  def update?(attrs, options={})
     assign_attributes(attrs, options)
-    save(options)
+    save?(options)
   end
+  alias_method :update_attributes?, :update?
 
-  def update_attributes!(*args)
-    update_attributes(*args) or raise NoBrainer::Error::DocumentInvalid, self
+  def update(*args)
+    update?(*args) or raise NoBrainer::Error::DocumentInvalid, self
+    nil
   end
+  alias_method :update_attributes, :update
+
+  def update!(*args)
+    update(*args)
+    :you_should_be_using_the_non_bang_version_of_update
+  end
+  alias_method :update_attributes!, :update!
 
   def delete
     unless @destroyed
@@ -124,10 +145,6 @@ module NoBrainer::Document::Persistance
       new(attrs, options).tap { |doc| doc.save(options) }
     end
 
-    def create!(attrs={}, options={})
-      new(attrs, options).tap { |doc| doc.save!(options) }
-    end
-
     def insert_all(*args)
       docs = args.shift
       docs = [docs] unless docs.is_a?(Array)
@@ -140,16 +157,16 @@ module NoBrainer::Document::Persistance
       NoBrainer.run(rql_table.sync)['synced'] == 1
     end
 
-    def persistable_key(k)
+    def persistable_key(k, options={})
       k
     end
 
-    def persistable_value(k, v)
+    def persistable_value(k, v, options={})
       v
     end
 
-    def persistable_attributes(attrs)
-      Hash[attrs.map { |k,v| [persistable_key(k), persistable_value(k, v)] }]
+    def persistable_attributes(attrs, options={})
+      Hash[attrs.map { |k,v| [persistable_key(k, options), persistable_value(k, v, options)] }]
     end
   end
 end

data/lib/no_brainer/document/polymorphic.rb

@@ -36,7 +36,7 @@ module NoBrainer::Document::Polymorphic
       for_each_subclass.map(&:type_value)
     end
 
-    def klass_from_attrs(attrs)
+    def model_from_attrs(attrs)
       attrs['_type'].try(:constantize) || root_class
     end
 

data/lib/no_brainer/document/types/set.rb

@@ -0,0 +1,23 @@
+class Set
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when Set   then value
+      when Array then Set.new(value)
+      else raise InvalidType
+      end
+    end
+
+    def nobrainer_cast_db_to_model(value)
+      value.is_a?(Array) ? Set.new(value) : value
+    end
+
+    def nobrainer_cast_model_to_db(value)
+      value.is_a?(Set) ? value.to_a : value
+    end
+  end
+
+  extend NoBrainerExtentions
+end

data/lib/no_brainer/document/types.rb

@@ -22,7 +22,7 @@ module NoBrainer::Document::Types
   module ClassMethods
     def cast_user_to_model_for(attr, value)
       type = fields[attr.to_sym].try(:[], :type)
-      return value if type.nil? || value.nil?
+      return value if type.nil? || value.nil? || value.is_a?(NoBrainer::Document::AtomicOps::PendingAtomic)
       if type.respond_to?(:nobrainer_cast_user_to_model)
         type.nobrainer_cast_user_to_model(value)
       else
@@ -53,13 +53,15 @@ module NoBrainer::Document::Types
       cast_model_to_db_for(attr, value)
     end
 
-    def persistable_value(k, v)
+    def persistable_value(k, v, options={})
       cast_model_to_db_for(k, super)
     end
 
     def _field(attr, options={})
       super
 
+      return unless options[:type]
+
       NoBrainer::Document::Types.load_type_extensions(options[:type]) if options[:type]
 
       inject_in_layer :types do
@@ -105,13 +107,13 @@ module NoBrainer::Document::Types
   class << self
     mattr_accessor :loaded_extensions
     self.loaded_extensions = Set.new
-    def load_type_extensions(klass)
-      unless loaded_extensions.include?(klass)
+    def load_type_extensions(model)
+      unless loaded_extensions.include?(model)
         begin
-          require File.join(File.dirname(__FILE__), 'types', klass.name.underscore)
+          require File.join(File.dirname(__FILE__), 'types', model.name.underscore)
         rescue LoadError
         end
-        loaded_extensions << klass
+        loaded_extensions << model
       end
     end
   end

data/lib/no_brainer/document/uniqueness.rb

@@ -66,10 +66,10 @@ module NoBrainer::Document::Uniqueness
 
     def initialize(options={})
       super
-      klass = options[:class]
+      model = options[:class]
       self.scope = [*options[:scope]]
-      ([klass] + klass.descendants).each do |_klass|
-        _klass.unique_validators << self
+      ([model] + model.descendants).each do |_model|
+        _model.unique_validators << self
       end
     end
 

data/lib/no_brainer/document/validation.rb

@@ -5,19 +5,28 @@ module NoBrainer::Document::Validation
 
   included do
     # We don't want before_validation returning false to halt the chain.
-    define_callbacks :validation, :skip_after_callbacks_if_terminated => true, :scope => [:kind, :name],
-                     :terminator => proc { false }
+    define_callbacks :validation, :skip_after_callbacks_if_terminated => true,
+                     :scope => [:kind, :name], :terminator => proc { false }
   end
 
-  def valid?(context=nil)
-    super(context || (new_record? ? :create : :update))
+  def valid?(context=nil, options={})
+    context ||= new_record? ? :create : :update
+
+  # copy/pasted, because we need to have control on errors.clear
+    current_context, self.validation_context = validation_context, context
+    errors.clear unless options[:clear_errors] == false
+    run_validations!
+  ensure
+    self.validation_context = current_context
   end
 
   module ClassMethods
     def _field(attr, options={})
       super
+      validates(attr, { :format => { :with => options[:format] } }) if options.has_key?(:format)
       validates(attr, { :presence => options[:required] }) if options.has_key?(:required)
       validates(attr, { :uniqueness => options[:unique] }) if options.has_key?(:unique)
+      validates(attr, { :uniqueness => options[:uniq] }) if options.has_key?(:uniq)
       validates(attr, { :inclusion => {:in => options[:in]} }) if options.has_key?(:in)
       validates(attr, options[:validates]) if options[:validates]
     end

data/lib/no_brainer/document.rb

@@ -7,7 +7,7 @@ module NoBrainer::Document
   autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Readonly,
                        :Validation, :Persistance, :Types, :Uniqueness, :Callbacks, :Dirty, :Id,
                        :Association, :Serialization, :Criteria, :Polymorphic, :Index, :Aliases,
-                       :MissingAttributes, :LazyFetch
+                       :MissingAttributes, :LazyFetch, :AtomicOps
 
   autoload :DynamicAttributes, :Timestamps
 

data/lib/no_brainer/error.rb

@@ -9,6 +9,20 @@ module NoBrainer::Error
   class AssociationNotPersisted < RuntimeError; end
   class ReadonlyField           < RuntimeError; end
   class MissingAttribute        < RuntimeError; end
+  class AtomicBlock             < RuntimeError; end
+
+  class CannotReadAtomic < RuntimeError
+    attr_accessor :instance, :field, :value
+    def initialize(instance, field, value)
+      @instance = instance
+      @field = field
+      @value = value
+    end
+
+    def message
+      "Cannot read #{field}, atomic operations are pending"
+    end
+  end
 
   class DocumentInvalid < RuntimeError
     attr_accessor :instance

data/lib/no_brainer/fork.rb

@@ -4,6 +4,7 @@ module NoBrainer::Fork
       alias_method :fork_without_nobrainer, :fork
 
       def fork(&block)
+        # Not so safe to disconnect in the child (c.f. driver's code)
         NoBrainer.disconnect
         fork_without_nobrainer(&block)
       end

data/lib/no_brainer/query_runner/connection_lock.rb

@@ -2,6 +2,10 @@ class NoBrainer::QueryRunner::ConnectionLock < NoBrainer::QueryRunner::Middlewar
   @@lock = Mutex.new
 
   def call(env)
-    @@lock.synchronize { @runner.call(env) }
+    if NoBrainer::Config.per_thread_connection
+      @runner.call(env) 
+    else
+      @@lock.synchronize { @runner.call(env) }
+    end
   end
 end

data/lib/no_brainer/query_runner/database_on_demand.rb

@@ -2,24 +2,25 @@ class NoBrainer::QueryRunner::DatabaseOnDemand < NoBrainer::QueryRunner::Middlew
   def call(env)
     @runner.call(env)
   rescue RuntimeError => e
-    if database_name = database_on_demand_exception?(e)
+    if database_name = handle_database_on_demand_exception?(env, e)
       auto_create_database(env, database_name)
       retry
     end
     raise
   end
 
-  def database_on_demand_exception?(e)
-    NoBrainer::Config.auto_create_databases && e.message =~ /^Database `(.+)` does not exist\.$/ && $1
+  def handle_database_on_demand_exception?(env, e)
+    (NoBrainer::Config.auto_create_databases || env[:auto_create_databases]) &&
+    e.message =~ /^Database `(.+)` does not exist\.$/ && $1
   end
 
   private
 
   def auto_create_database(env, database_name)
-    if env[:auto_create_database] == database_name
+    if env[:last_auto_create_database] == database_name
       raise "Auto database creation is not working with #{database_name}"
     end
-    env[:auto_create_database] = database_name
+    env[:last_auto_create_database] = database_name
 
     NoBrainer.db_create(database_name)
   rescue RuntimeError => e

data/lib/no_brainer/query_runner/logger.rb

@@ -10,8 +10,12 @@ class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
   private
 
   def log_query(env, start_time, exception=nil)
-    return if on_demand_exception?(exception)
-    not_indexed = env[:criteria] && env[:criteria].where_present? && !env[:criteria].where_indexed?
+    return if handle_on_demand_exception?(env, exception)
+
+    not_indexed = env[:criteria] && env[:criteria].where_present? &&
+                    !env[:criteria].where_indexed? &&
+                    !env[:criteria].model.try(:perf_warnings_disabled)
+
     level = exception ? Logger::ERROR :
              not_indexed ? Logger::INFO : Logger::DEBUG
     return if NoBrainer.logger.nil? || NoBrainer.logger.level > level
@@ -19,7 +23,7 @@ class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
     duration = Time.now - start_time
 
     msg_duration = (duration * 1000.0).round(1).to_s
-    msg_duration = " " * [0, 5 - msg_duration.size].max + msg_duration
+    msg_duration = " " * [0, 6 - msg_duration.size].max + msg_duration
     msg_duration = "[#{msg_duration}ms] "
 
     msg_db = "[#{env[:db_name]}] " if env[:db_name] && env[:db_name].to_s != NoBrainer.connection.parsed_uri[:db]
@@ -49,9 +53,9 @@ class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
     NoBrainer.logger.add(level, msg)
   end
 
-  def on_demand_exception?(e)
+  def handle_on_demand_exception?(env, e)
     # pretty gross I must say.
-    e && (NoBrainer::QueryRunner::DatabaseOnDemand.new(nil).database_on_demand_exception?(e) ||
-          NoBrainer::QueryRunner::TableOnDemand.new(nil).table_on_demand_exception?(e))
+    e && (NoBrainer::QueryRunner::DatabaseOnDemand.new(nil).handle_database_on_demand_exception?(env, e) ||
+          NoBrainer::QueryRunner::TableOnDemand.new(nil).handle_table_on_demand_exception?(env, e))
   end
 end

data/lib/no_brainer/query_runner/missing_index.rb

@@ -7,13 +7,14 @@ class NoBrainer::QueryRunner::MissingIndex < NoBrainer::QueryRunner::Middleware
       database_name = $2
       table_name = $3
 
-      klass = NoBrainer::Document.all.select { |m| m.table_name == table_name }.first
-      index_name = klass.get_index_alias_reverse_map[index_name.to_sym]
+      model = NoBrainer::Document.all.select { |m| m.table_name == table_name }.first
+      index = model.indexes.values.select { |i| i.aliased_name == index_name.to_sym }.first if model
+      index_name = index.name if index
 
-      if klass && klass.pk_name.to_s == index_name
+      if model.try(:pk_name).try(:to_s) == index_name
         err_msg  = "Please update the primary key `#{index_name}` in the table `#{database_name}.#{table_name}`."
       else
-        err_msg  = "Please run `NoBrainer.update_indexes' or `rake db:update_indexes' to create the index `#{index_name}`"
+        err_msg  = "Please run `NoBrainer.sync_indexes' or `rake nobrainer:sync_indexes' to create the index `#{index_name}`"
         err_msg += " in the table `#{database_name}.#{table_name}`."
         err_msg += " Read http://nobrainer.io/docs/indexes for more information."
       end