nobrainer 0.17.0 → 0.18.0

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

@@ -0,0 +1,83 @@
+class NoBrainer::Document::Index::Index < Struct.new(
+    :model, :name, :aliased_name, :kind, :what, :external, :geo, :multi, :meta)
+
+  MetaStore = NoBrainer::Document::Index::MetaStore
+
+  def initialize(*args)
+    super
+
+    self.name = self.name.to_sym
+    self.aliased_name = self.aliased_name.to_sym
+    self.external = !!self.external
+    self.geo = !!self.geo
+    self.multi = !!self.multi
+  end
+
+  def same_definition?(other)
+    # allow name to change through renames
+    self.model == other.model &&
+    self.geo == other.geo &&
+    self.multi == other.multi &&
+    self.serialized_rql_proc == other.serialized_rql_proc
+  end
+
+  def human_name
+    index_name = "index #{model}.#{name}"
+    index_name += " as #{aliased_name}" unless name == aliased_name
+    index_name
+  end
+
+  def rql_proc
+    case kind
+      when :single   then ->(doc) { doc[model.lookup_field_alias(what)] }
+      when :compound then ->(doc) { what.map { |field| doc[model.lookup_field_alias(field)] } }
+      when :proc     then what # TODO XXX not translating the field aliases
+    end
+  end
+
+  def serialized_rql_proc
+    meta.try(:rql_function) || (rql_proc && NoBrainer::RQL.rql_proc_as_json(rql_proc))
+  end
+
+  def show_op(verb, options={})
+    color = case verb
+            when :create then "\e[1;32m" # green
+            when :delete then "\e[1;31m" # red
+            when :update then "\e[1;33m" # yellow
+            end
+    STDERR.puts "[NoBrainer] #{color}#{verb.to_s.capitalize} #{human_name}\e[0m" if options[:verbose]
+  end
+
+  def create(options={})
+    show_op(:create, options)
+
+    opt = {}
+    opt[:multi] = true if multi
+    opt[:geo] = true if geo
+
+    NoBrainer::RQL.reset_lambda_var_counter
+    NoBrainer.run(model.rql_table.index_create(aliased_name, opt, &rql_proc))
+
+    MetaStore.on(model.database_name) do
+      MetaStore.create(:table_name => model.table_name, :index_name => aliased_name,
+                       :rql_function => serialized_rql_proc)
+    end
+  end
+
+  def delete(options={})
+    show_op(:delete, options)
+
+    NoBrainer.run(model.rql_table.index_drop(aliased_name))
+
+    MetaStore.on(model.database_name) do
+      MetaStore.where(:table_name => model.table_name, :index_name => aliased_name).delete_all
+    end
+  end
+
+  def update(wanted_index, options={})
+    wanted_index.show_op(:update, options)
+
+    self.delete(options.merge(:verbose => false))
+    wanted_index.create(options.merge(:verbose => false))
+  end
+end

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

@@ -0,0 +1,31 @@
+class NoBrainer::Document::Index::MetaStore
+  include NoBrainer::Document
+  include NoBrainer::Document::Timestamps
+
+  disable_perf_warnings
+
+  default_scope ->{ order_by(:created_at) }
+
+  store_in :database => ->{ Thread.current[:nobrainer_meta_store_db] },
+           :table    => 'nobrainer_index_meta'
+
+  field :table_name,   :type => String, :required => true
+  field :index_name,   :type => String, :required => true
+  field :rql_function, :type => String, :required => true
+
+  def rql_function=(value)
+    super(JSON.dump(value))
+  end
+
+  def rql_function
+    JSON.load(super)
+  end
+
+  def self.on(db_name, &block)
+    old_db_name = Thread.current[:nobrainer_meta_store_db]
+    Thread.current[:nobrainer_meta_store_db] = db_name
+    NoBrainer.with(:auto_create_tables => true) { block.call }
+  ensure
+    Thread.current[:nobrainer_meta_store_db] = old_db_name
+  end
+end

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/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/persistance.rb

@@ -60,7 +60,8 @@ module NoBrainer::Document::Persistance
   end
 
   def _create(options={})
-    return false if options[:validate] && !valid?
+    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
@@ -74,7 +75,7 @@ module NoBrainer::Document::Persistance
   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.
@@ -89,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 update_attributes?(attrs, options={})
+  def save!(*args)
+    save(*args)
+    :you_should_be_using_the_non_bang_version_of_save
+  end
+
+  def update?(attrs, options={})
     assign_attributes(attrs, options)
     save?(options)
   end
+  alias_method :update_attributes?, :update?
+
+  def update(*args)
+    update?(*args) or raise NoBrainer::Error::DocumentInvalid, self
+    nil
+  end
+  alias_method :update_attributes, :update
 
-  def update_attributes(*args)
-    update_attributes?(*args) or raise NoBrainer::Error::DocumentInvalid, self
+  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

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.rb

@@ -60,6 +60,8 @@ module NoBrainer::Document::Types
     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/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/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