nobrainer 0.22.0 → 0.28.0

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

@@ -1,8 +1,6 @@
 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
 
@@ -59,10 +57,9 @@ class NoBrainer::Document::Index::Index < Struct.new(
     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
+    NoBrainer::Document::Index::MetaStore.create(
+      :table_name => model.table_name, :index_name => aliased_name,
+      :rql_function => serialized_rql_proc)
   end
 
   def delete(options={})
@@ -70,9 +67,8 @@ class NoBrainer::Document::Index::Index < Struct.new(
 
     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
+    NoBrainer::Document::Index::MetaStore.where(
+      :table_name => model.table_name, :index_name => aliased_name).delete_all
   end
 
   def update(wanted_index, options={})

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

@@ -6,8 +6,7 @@ class NoBrainer::Document::Index::MetaStore
 
   default_scope ->{ order_by(:created_at) }
 
-  store_in :database => ->{ Thread.current[:nobrainer_meta_store_db] },
-           :table    => 'nobrainer_index_meta'
+  table_config :name => 'nobrainer_index_meta'
 
   field :table_name,   :type => String, :required => true
   field :index_name,   :type => String, :required => true
@@ -20,12 +19,4 @@ class NoBrainer::Document::Index::MetaStore
   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
-    block.call
-  ensure
-    Thread.current[:nobrainer_meta_store_db] = old_db_name
-  end
 end

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

@@ -1,16 +1,12 @@
 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 }
+  def meta_store
+    @meta_store ||= NoBrainer::Document::Index::MetaStore.to_a
   end
 
   class Op < Struct.new(:index, :op, :args)
@@ -21,9 +17,9 @@ class NoBrainer::Document::Index::Synchronizer
 
   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)
+      meta = meta_store.select { |i| i.table_name == model.table_name && i.index_name == s['index'] }.last
+      NoBrainer::Document::Index::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
@@ -46,23 +42,23 @@ class NoBrainer::Document::Index::Synchronizer
   end
 
   def generate_plan
-    @models_indexes_map.map { |model, indexes| _generate_plan_for(model, indexes) }.flatten(1)
+    @models_indexes_map.flat_map { |model, indexes| _generate_plan_for(model, indexes) }
   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()) }
+    lock = NoBrainer::Lock.new('nobrainer:sync_indexes')
+
+    lock.synchronize do
+      generate_plan.each { |op| op.run(options) }
     end
-  end
 
-  class << self
-    def instance
-      new(NoBrainer::Document.all)
+    unless options[:wait] == false
+      # Waiting on all models due to possible races
+      @models_indexes_map.each_key do |model|
+        NoBrainer.run(model.rql_table.index_wait())
+      end
     end
 
-    delegate :sync_indexes, :to => :instance
+    true
   end
 end

data/lib/no_brainer/document/index.rb

@@ -26,11 +26,11 @@ module NoBrainer::Document::Index
       end
 
       if name.in?(NoBrainer::Document::Attributes::RESERVED_FIELD_NAMES)
-        raise "Cannot use a reserved field name: #{name}"
+        raise "The index name `:#{name}' is reserved. Please use another one."
       end
 
       if has_field?(name) && kind != :single
-        raise "Cannot reuse field name #{name}"
+        raise "The field `#{name}' is already declared. Please remove its definition first."
       end
 
       if kind == :compound && what.size < 2
@@ -56,7 +56,7 @@ module NoBrainer::Document::Index
 
     def _field(attr, options={})
       if has_index?(attr) && indexes[attr].kind != :single
-        raise "Cannot reuse index attr #{attr}"
+        raise "The index `#{attr}' is already declared. Please remove its definition first."
       end
 
       super

data/lib/no_brainer/document/lazy_fetch.rb

@@ -34,9 +34,9 @@ module NoBrainer::Document::LazyFetch
       model = self
       inject_in_layer :lazy_fetch do
         if options[:lazy_fetch]
-          model.for_each_subclass { |_model| _model.fields_to_lazy_fetch << attr }
+          model.subclass_tree.each { |subclass| subclass.fields_to_lazy_fetch << attr }
         else
-          model.for_each_subclass { |_model|  _model.fields_to_lazy_fetch.delete(attr) }
+          model.subclass_tree.each { |subclass| subclass.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 { |model| model.fields_to_lazy_fetch.delete(attr) }
+      subclass_tree.each { |subclass| subclass.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

@@ -6,9 +6,14 @@ module NoBrainer::Document::MissingAttributes
   end
 
   def assign_attributes(attrs, options={})
+    # there is one and only one key :pluck or :without to missing_attributes
     if options[:missing_attributes]
-      # there is one and only one key :pluck or :without to missing_attributes
-      @missing_attributes = options[:missing_attributes]
+      # TODO XXX this whole thing is gross.
+      # if @missing_attributes is already there, it's because we are doing a
+      # incremental reload. clear_missing_field will do the work of recognizing
+      # which fields are here or not.
+      @missing_attributes ||= options[:missing_attributes]
+
       assert_access_field(self.class.pk_name, "The primary key is not accessible. Use .raw or")
       assert_access_field(:_type, "The subclass type is not accessible. Use .raw or") if self.class.is_polymorphic
     end

data/lib/no_brainer/document/persistance.rb

@@ -60,12 +60,11 @@ module NoBrainer::Document::Persistance
   end
 
   def _create(options={})
-    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
+    unlock_unique_fields # just an optimization for the uniquness validation
     true
   end
 
@@ -75,8 +74,6 @@ module NoBrainer::Document::Persistance
   end
 
   def _update_only_changed_attrs(options={})
-    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.
     attrs = Hash[self.changed.map do |k|
@@ -87,26 +84,24 @@ module NoBrainer::Document::Persistance
       [k, attr]
     end]
     _update(attrs) if attrs.present?
+    unlock_unique_fields # just an optimization for the uniquness validation
     true
   end
 
-  def _save?(options)
+  def _save?(options={})
     new_record? ? _create(options) : _update_only_changed_attrs(options)
   end
 
   def save?(options={})
-    errors.clear
     _save?(options)
   end
 
-  def save(*args)
+  def save!(*args)
     save?(*args) or raise NoBrainer::Error::DocumentInvalid, self
-    nil
   end
 
-  def save!(*args)
-    save(*args)
-    :you_should_be_using_the_non_bang_version_of_save
+  def save(*args)
+    save?(*args)
   end
 
   def update?(attrs, options={})
@@ -114,27 +109,13 @@ module NoBrainer::Document::Persistance
     save?(options)
   end
 
-  def update(*args)
-    update?(*args) or raise NoBrainer::Error::DocumentInvalid, self
-    nil
-  end
-
   def update!(*args)
-    update(*args)
-    :you_should_be_using_the_non_bang_version_of_update
+    update?(*args) or raise NoBrainer::Error::DocumentInvalid, self
   end
   alias_method :update_attributes!, :update!
 
-  def update_attributes?(*args)
-    update?(*args).tap { STDERR.puts "[NoBrainer] update_attributes?() is deprecated. Please use update?() instead" }
-  end
-
-  def update_attributes(*args)
-    update(*args).tap { STDERR.puts "[NoBrainer] update_attributes() is deprecated. Please use update() instead" }
-  end
-
-  def update_attributes!(*args)
-    update!(*args).tap { STDERR.puts "[NoBrainer] update_attributes!() is deprecated. Please use update() instead" }
+  def update(*args)
+    update?(*args)
   end
 
   def delete
@@ -152,9 +133,12 @@ module NoBrainer::Document::Persistance
 
   module ClassMethods
     def create(attrs={}, options={})
-      new(attrs, options).tap { |doc| doc.save(options) }
+      new(attrs, options).tap { |doc| doc.save?(options) }
+    end
+
+    def create!(attrs={}, options={})
+      new(attrs, options).tap { |doc| doc.save!(options) }
     end
-    alias_method :create!, :create
 
     def insert_all(*args)
       docs = args.shift

data/lib/no_brainer/document/polymorphic.rb

@@ -28,16 +28,20 @@ module NoBrainer::Document::Polymorphic
       self == root_class
     end
 
-    def for_each_subclass(&block)
-      ([self] + self.descendants).each(&block)
+    def subclass_tree
+      [self] + self.descendants
     end
 
     def descendants_type_values
-      for_each_subclass.map(&:type_value)
+      subclass_tree.map(&:type_value)
     end
 
     def model_from_attrs(attrs)
-      attrs['_type'].try(:constantize) || root_class
+      class_name = attrs['_type'] || attrs[:_type]
+      return root_class unless class_name
+      class_name.to_s.constantize.tap { |cls| raise NameError unless cls <= self }
+    rescue NameError
+      raise NoBrainer::Error::InvalidPolymorphicType, "Invalid polymorphic class: `#{class_name}' is not a `#{self}'"
     end
 
     def all

data/lib/no_brainer/document/primary_key/generator.rb

@@ -20,6 +20,7 @@ module NoBrainer::Document::PrimaryKey::Generator
   # 1% of chance to have a collision with ~580 servers.
   # When using more than 500 machines, it's therefore a good
   # idea to set the machine_id manually to avoid collisions.
+  # XXX This is referenced in nobrainer/config.rb#default_machine_id
   MACHINE_ID_BITS = 24
 
   # 15 bits for the current pid. We wouldn't need it if the sequence number was
@@ -27,7 +28,7 @@ module NoBrainer::Document::PrimaryKey::Generator
   PID_BITS = 15
 
   # Total: 83 bits
-  # We need at most 14 digits in [A-Za-z0-9] to represent 83 bits:
+  # With 14 digits in [A-Za-z0-9], we can represent 83 bits:
   # Math.log(62**14)/Math.log(2) = 83.35
   ID_STR_LENGTH = 14
 
@@ -80,4 +81,8 @@ module NoBrainer::Document::PrimaryKey::Generator
   def self.generate
     convert_to_alphanum(@lock.synchronize { _generate })
   end
+
+  def self.field_type
+    String
+  end
 end

data/lib/no_brainer/document/primary_key.rb

@@ -3,6 +3,7 @@ module NoBrainer::Document::PrimaryKey
   autoload :Generator
 
   extend ActiveSupport::Concern
+  include ActiveModel::Conversion
 
   DEFAULT_PK_NAME = :id
 
@@ -23,6 +24,15 @@ module NoBrainer::Document::PrimaryKey
 
   delegate :hash, :to => :pk_value
 
+  def cache_key
+    "#{self.class.table_name}/#{pk_value}"
+  end
+
+  def to_key
+    # ActiveModel::Conversion
+    [pk_value]
+  end
+
   module ClassMethods
     def define_default_pk
       class_variable_set(:@@pk_name, nil)
@@ -30,6 +40,7 @@ module NoBrainer::Document::PrimaryKey
     end
 
     def define_pk(attr)
+      return if pk_name == attr
       if fields[pk_name].try(:[], :primary_key) == :default
         remove_field(pk_name, :set_default_pk => false)
       end
@@ -46,15 +57,19 @@ module NoBrainer::Document::PrimaryKey
     end
 
     def field(attr, options={})
-      if options[:primary_key]
+      if attr.to_sym == pk_name || options[:primary_key]
         options = options.merge(:readonly => true) if options[:readonly].nil?
         options = options.merge(:index => true)
 
-        if options[:type].in?([String, nil]) && options[:default].nil?
-          options[:type] = String
-          options[:default] = ->{ NoBrainer::Document::PrimaryKey::Generator.generate }
+        # TODO Maybe we should let the user configure the pk generator
+        pk_generator = NoBrainer::Document::PrimaryKey::Generator
+
+        if options[:type].in?([pk_generator.field_type, nil]) && !options.key?(:default)
+          options[:type] = pk_generator.field_type
+          options[:default] = ->{ pk_generator.generate }
         end
       end
+
       super
     end
 

data/lib/no_brainer/document/serialization.rb

@@ -4,8 +4,6 @@ module NoBrainer::Document::Serialization
   include ActiveModel::Serialization
   include ActiveModel::Serializers::JSON
 
-  included { self.include_root_in_json = false }
-
   def read_attribute_for_serialization(*a, &b)
     read_attribute(*a, &b)
   end

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

@@ -0,0 +1,21 @@
+class NoBrainer::Document::TableConfig::Synchronizer
+  def initialize(models)
+    @models = models
+  end
+
+  def sync_table_config(options={})
+    # XXX A bit funny since we might touch the lock table...
+    lock = NoBrainer::Lock.new('nobrainer:sync_table_config')
+
+    lock.synchronize do
+      @models.each(&:sync_table_config)
+    end
+
+    unless options[:wait] == false
+      # Waiting on all models due to possible races
+      @models.each(&:table_wait)
+    end
+
+    true
+  end
+end

data/lib/no_brainer/document/table_config.rb

@@ -0,0 +1,118 @@
+require 'rethinkdb'
+
+module NoBrainer::Document::TableConfig
+  extend ActiveSupport::Concern
+  extend NoBrainer::Autoload
+
+  autoload :Synchronizer
+
+  VALID_TABLE_CONFIG_OPTIONS = [:name, :durability, :shards, :replicas, :primary_replica_tag, :write_acks]
+
+  included do
+    cattr_accessor :table_config_options, :instance_accessor => false
+    self.table_config_options = {}
+  end
+
+  module ClassMethods
+    def store_in(options)
+      if options[:table]
+        STDERR.puts "[NoBrainer] `store_in(table: ...)' has been removed. Use `table_config(name: ...)' instead."
+        options[:name] = options.delete(:table)
+      end
+
+      if options[:database] || options[:db]
+        raise "`store_in(db: ...)' has been removed. Use `run_with(db: ...)' instead."
+      end
+
+      table_config(options)
+    end
+
+    def _set_table_config(options)
+      raise "table_config() must be used at the parent class, not a subclass" unless is_root_class?
+
+      options.assert_valid_keys(*VALID_TABLE_CONFIG_OPTIONS)
+      self.table_config_options.merge!(options)
+    end
+
+    def table_name
+      name = table_config_options[:name]
+      name = name.call if name.is_a?(Proc)
+      (name || root_class.name.tableize.gsub('/', '__')).to_s
+    end
+
+    def rql_table
+      RethinkDB::RQL.new.table(table_name)
+    end
+
+    def table_config(options={})
+      return _set_table_config(options) unless options.empty?
+      NoBrainer::System::TableConfig.new_from_db(NoBrainer.run { rql_table.config })
+    end
+
+    def table_status
+      NoBrainer::System::TableConfig.new_from_db(NoBrainer.run { rql_table.status })
+    end
+
+    def table_stats
+      NoBrainer::System::Stats.where(:db => NoBrainer.current_db, :table => table_name).to_a
+    end
+
+    def rebalance
+      NoBrainer.run { rql_table.rebalance }
+      true
+    end
+
+    def table_wait
+      NoBrainer.run { rql_table.wait }
+    end
+
+    def table_create_options
+      NoBrainer::Config.table_options
+        .merge(table_config_options)
+        .merge(:name => table_name)
+        .merge(:primary_key => lookup_field_alias(pk_name))
+        .reverse_merge(:durability => 'hard')
+        .reduce({}) { |h,(k,v)| h[k] = v.is_a?(Symbol) ? v.to_s : v; h } # symbols -> strings
+    end
+
+    def sync_table_config(options={})
+      c = table_create_options
+      table_config.update!(c.slice(:durability, :primary_key, :write_acks))
+      NoBrainer.run { rql_table.reconfigure(c.slice(:shards, :replicas, :primary_replica_tag)) }
+      true
+    end
+
+    def sync_indexes(options={})
+      NoBrainer::Document::Index::Synchronizer.new(self).sync_indexes(options)
+    end
+
+    def sync_schema(options={})
+      sync_table_config(options)
+      sync_indexes(options)
+    end
+  end
+
+  class << self
+    def sync_table_config(options={})
+      models = NoBrainer::Document.all(:types => [:user, :nobrainer])
+      NoBrainer::Document::TableConfig::Synchronizer.new(models).sync_table_config(options)
+    end
+
+    def sync_indexes(options={})
+      # nobrainer models don't have indexes
+      models = NoBrainer::Document.all(:types => [:user])
+      NoBrainer::Document::Index::Synchronizer.new(models).sync_indexes(options)
+    end
+
+    def sync_schema(options={})
+      sync_table_config(options)
+      sync_indexes(options)
+    end
+
+    def rebalance(options={})
+      models = NoBrainer::Document.all(:types => [:user])
+      models.each(&:rebalance)
+      true
+    end
+  end
+end

data/lib/no_brainer/document/timestamps.rb

@@ -17,4 +17,12 @@ module NoBrainer::Document::Timestamps
     self.updated_at = Time.now unless updated_at_changed?
     super(attrs.merge('updated_at' => @_attributes['updated_at']))
   end
+
+  def cache_key
+    "#{super}#{updated_at.try(:strftime, "-%s%L")}"
+  end
+
+  def touch
+    update!(:updated_at => Time.now)
+  end
 end

data/lib/no_brainer/document/validation/core.rb

@@ -0,0 +1,63 @@
+module NoBrainer::Document::Validation::Core
+  extend ActiveSupport::Concern
+  include ActiveModel::Validations
+  include ActiveModel::Validations::Callbacks
+
+  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 }
+  end
+
+  def valid?(context=nil, options={})
+    super(context || (new_record? ? :create : :update))
+  end
+
+  def save?(options={})
+    options = { :validate => true }.merge(options)
+
+    if options[:validate]
+      valid? ? super : false
+    else
+      super
+    end
+  end
+
+  SHORTHANDS = { :format => :format, :length => :length, :required => :presence,
+                 :uniq => :uniqueness, :unique => :uniqueness, :in => :inclusion }
+
+  module ClassMethods
+    def _field(attr, options={})
+      super
+
+      shorthands = SHORTHANDS
+      shorthands = shorthands.merge(:required => :not_null) if options[:type] == NoBrainer::Boolean
+      shorthands.each { |k,v| validates(attr, v => options[k]) if options.key?(k) }
+
+      validates(attr, options[:validates]) if options[:validates]
+      validates(attr, :length => { :minimum => options[:min_length] }) if options[:min_length]
+      validates(attr, :length => { :maximum => options[:max_length] }) if options[:max_length]
+    end
+  end
+end
+
+class ActiveModel::EachValidator
+  def should_validate_field?(record, attribute)
+    return true unless record.is_a?(NoBrainer::Document)
+    return true if record.new_record?
+
+    attr_changed = "#{attribute}_changed?"
+    return record.respond_to?(attr_changed) ? record.__send__(attr_changed) : true
+  end
+
+  # XXX Monkey Patching :(
+  def validate(record)
+    attributes.each do |attribute|
+      next unless should_validate_field?(record, attribute) # <--- Added
+      value = record.read_attribute_for_validation(attribute)
+      next if value.is_a?(NoBrainer::Document::AtomicOps::PendingAtomic) # <--- Added
+      next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+      validate_each(record, attribute, value)
+    end
+  end
+end