nobrainer 0.13.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5ca498dfa914c0c0178f339485d78ba804c5b95
-  data.tar.gz: c0e0c6f35d8927bb6281f860aac769753df59b88
+  metadata.gz: e97dd4f563340a2c8551ffefb21f22fc628954b2
+  data.tar.gz: 1fca054e8f966be9e7518f8245c39987d40068c7
 SHA512:
-  metadata.gz: ed914e1eee020658197d596245404a2a088acbf033f5fc3a44cb490620cdc5ef110d62e4da927e7579e5e3383bc90e16dd499269a9bd8952dfa2011d3e2f2a12
-  data.tar.gz: f3204081b4ef7617706ee3c037830bdacbde973ae79e914b782b39fb41f1ec36b0125f78b427d0f21078bdae543ee426f2936ba69a1327bc36176acc6997765e
+  metadata.gz: 1cbfebfa6ac2922e733d157522eda4e6c9edf9de9e51601f6892ac2ac2814593ed20807c68441a2ff7391398cf37896eeb739eaf2cdafa0da8e9fe91bb02fce2
+  data.tar.gz: ace1719ae85c7593145e81818fb1b93f715ad65d4634130c664b0fdd134c637aba0395066163b9fd3aee91f7ec0b27a53338e857ec2c089a4b425e02f2eba00b

data/lib/no_brainer/config.rb

@@ -4,7 +4,8 @@ module NoBrainer::Config
   class << self
     mattr_accessor :rethinkdb_url, :logger, :warn_on_active_record,
                    :auto_create_databases, :auto_create_tables,
-                   :max_reconnection_tries, :durability, :colorize_logger,
+                   :max_reconnection_tries, :durability,
+                   :user_timezone, :db_timezone, :colorize_logger,
                    :distributed_lock_class
 
     def apply_defaults
@@ -15,6 +16,8 @@ module NoBrainer::Config
       self.auto_create_tables      = true
       self.max_reconnection_tries  = 10
       self.durability              = default_durability
+      self.user_timezone           = :local
+      self.db_timezone             = :utc
       self.colorize_logger         = true
       self.distributed_lock_class  = nil
     end
@@ -27,6 +30,7 @@ module NoBrainer::Config
     def configure(&block)
       apply_defaults unless configured?
       block.call(self) if block
+      assert_valid_options!
       @configured = true
 
       NoBrainer.disconnect_if_url_changed
@@ -36,9 +40,21 @@ 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 default_rethinkdb_url
       db = ENV['RETHINKDB_DB'] || ENV['RDB_DB']
-      db ||= "#{Rails.application.class.parent_name.underscore}_#{Rails.env}" if defined?(Rails)
+      db ||= "#{Rails.application.class.parent_name.underscore}_#{Rails.env}" rescue nil
       host = ENV['RETHINKDB_HOST'] || ENV['RDB_HOST'] || 'localhost'
       port = ENV['RETHINKDB_PORT'] || ENV['RDB_PORT']
       auth = ENV['RETHINKDB_AUTH'] || ENV['RDB_AUTH']
@@ -48,11 +64,11 @@ module NoBrainer::Config
     end
 
     def default_logger
-      defined?(Rails) ? Rails.logger : Logger.new(STDERR).tap { |l| l.level = Logger::WARN }
+      defined?(Rails.logger) ? Rails.logger : Logger.new(STDERR).tap { |l| l.level = Logger::WARN }
     end
 
     def default_durability
-      (defined?(Rails) && (Rails.env.test? || Rails.env.development?)) ? :soft : :hard
+      (defined?(Rails.env) && (Rails.env.test? || Rails.env.development?)) ? :soft : :hard
     end
   end
 end

data/lib/no_brainer/criteria/count.rb

@@ -2,7 +2,7 @@ module NoBrainer::Criteria::Count
   extend ActiveSupport::Concern
 
   def count
-    run(to_rql.count)
+    run(without_ordering.to_rql.count)
   end
 
   def empty?

data/lib/no_brainer/criteria/delete.rb

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

data/lib/no_brainer/criteria/first.rb

@@ -17,6 +17,12 @@ module NoBrainer::Criteria::First
     last.tap { |doc| raise NoBrainer::Error::DocumentNotFound unless doc }
   end
 
+  def sample(n=nil)
+    result = NoBrainer.run { self.without_ordering.to_rql.sample(n.nil? ? 1 : n) }
+    result = result.map(&method(:instantiate_doc))
+    n.nil? ? result.first : result
+  end
+
   private
 
   def get_one(criteria)

data/lib/no_brainer/criteria/order_by.rb

@@ -1,7 +1,7 @@
 module NoBrainer::Criteria::OrderBy
   extend ActiveSupport::Concern
 
-  included { attr_accessor :order, :_reverse_order }
+  included { attr_accessor :order, :ordering_mode }
 
   def initialize(options={})
     super
@@ -24,36 +24,55 @@ module NoBrainer::Criteria::OrderBy
 
     chain do |criteria|
       criteria.order = rules
-      criteria._reverse_order = false
+      criteria.ordering_mode = :normal
     end
   end
 
+  def without_ordering
+    chain { |criteria| criteria.ordering_mode = :disabled }
+  end
+
   def merge!(criteria, options={})
     super
     # The latest order_by() wins
     self.order = criteria.order if criteria.order.present?
-    self._reverse_order = criteria._reverse_order unless criteria._reverse_order.nil?
+    self.ordering_mode = criteria.ordering_mode unless criteria.ordering_mode.nil?
     self
   end
 
   def reverse_order
-    chain { |criteria| criteria._reverse_order = !self._reverse_order }
+    chain do |criteria|
+      criteria.ordering_mode =
+        case self.ordering_mode
+        when nil       then :reversed
+        when :normal   then :reversed
+        when :reversed then :normal
+        when :disabled then :disabled
+        end
+    end
   end
 
   private
 
   def effective_order
-    self.order.presence || {:id => :asc}
+    self.order.presence || (klass ? {klass.pk_name => :asc} : {})
   end
 
   def reverse_order?
-    !!self._reverse_order
+    self.ordering_mode == :reversed
+  end
+
+  def should_order?
+    self.ordering_mode != :disabled
   end
 
   def compile_rql_pass1
     rql = super
+    return rql unless should_order?
+    _effective_order = effective_order
+    return rql if _effective_order.empty?
 
-    rql_rules = effective_order.map do |k,v|
+    rql_rules = _effective_order.map do |k,v|
       case v
       when :asc  then reverse_order? ? RethinkDB::RQL.new.desc(k) : RethinkDB::RQL.new.asc(k)
       when :desc then reverse_order? ? RethinkDB::RQL.new.asc(k)  : RethinkDB::RQL.new.desc(k)
@@ -64,9 +83,10 @@ module NoBrainer::Criteria::OrderBy
     # We are going to try to go so and if we cannot, we'll simply apply
     # the ordering in pass2, which will happen after a potential filter().
 
-    if rql.body.type == Term::TermType::TABLE && !without_index?
+    NoBrainer::RQL.is_table?(rql)
+    if NoBrainer::RQL.is_table?(rql) && !without_index?
       options = {}
-      first_key = effective_order.first[0]
+      first_key = _effective_order.first[0]
       if (first_key.is_a?(Symbol) || first_key.is_a?(String)) && klass.has_index?(first_key)
         options[:index] = rql_rules.shift
       end
@@ -83,7 +103,10 @@ module NoBrainer::Criteria::OrderBy
 
   def compile_rql_pass2
     rql = super
-    rql = rql.order_by(*@rql_rules_pass2) if @rql_rules_pass2
+    if @rql_rules_pass2
+      rql = rql.order_by(*@rql_rules_pass2)
+      @rql_rules_pass2 = nil
+    end
     rql
   end
 

data/lib/no_brainer/criteria/update.rb

@@ -2,10 +2,10 @@ module NoBrainer::Criteria::Update
   extend ActiveSupport::Concern
 
   def update_all(*args, &block)
-    run(to_rql.update(*args, &block))
+    run(without_ordering.to_rql.update(*args, &block))
   end
 
   def replace_all(*args, &block)
-    run(to_rql.replace(*args, &block))
+    run(without_ordering.to_rql.replace(*args, &block))
   end
 end

data/lib/no_brainer/criteria/where.rb

@@ -54,24 +54,26 @@ module NoBrainer::Criteria::Where
     end
   end
 
-  class BinaryOperator < Struct.new(:key, :op, :value, :criteria)
+  class BinaryOperator < Struct.new(:key, :op, :value, :criteria, :casted_values)
     def simplify
       key = cast_key(self.key)
       case op
       when :in then
         case value
-        when Range then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), criteria)
-        when Array then BinaryOperator.new(key, :in, value.map(&method(:cast_value)).uniq, criteria)
+        when Range then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), criteria, true)
+        when Array then BinaryOperator.new(key, :in, value.map(&method(:cast_value)).uniq, criteria, true)
         else raise ArgumentError.new ":in takes an array/range, not #{value}"
         end
-      else BinaryOperator.new(key, op, cast_value(value), criteria)
+      when :between then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), criteria, true)
+      else BinaryOperator.new(key, op, cast_value(value), criteria, true)
       end
     end
 
     def to_rql(doc)
       case op
+      when :defined then value ? doc.has_fields(key) : doc.has_fields(key).not
       when :between then (doc[key] >= value.min) & (doc[key] <= value.max)
-      when :in then RethinkDB::RQL.new.expr(value).contains(doc[key])
+      when :in      then RethinkDB::RQL.new.expr(value).contains(doc[key])
       else doc[key].__send__(op, value)
       end
     end
@@ -87,18 +89,22 @@ module NoBrainer::Criteria::Where
     end
 
     def cast_value(value)
+      return value if casted_values
+
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata
         target_klass = association.target_klass
         opts = { :attr_name => key, :value => value, :type => target_klass}
         raise NoBrainer::Error::InvalidType.new(opts) unless value.is_a?(target_klass)
-        value.id
+        value.pk_value
       else
         criteria.klass.cast_user_to_db_for(key, value)
       end
     end
 
     def cast_key(key)
+      return key if casted_values
+
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata
         association.foreign_key

data/lib/no_brainer/decorated_symbol.rb

@@ -2,7 +2,8 @@ class NoBrainer::DecoratedSymbol < Struct.new(:symbol, :modifier, :args)
   MODIFIERS = { :in => :in, :nin => :nin,
                 :eq => :eq, :ne => :ne, :not => :ne,
                 :gt => :gt, :ge => :ge, :gte => :ge,
-                :lt => :lt, :le => :le, :lte => :le}
+                :lt => :lt, :le => :le, :lte => :le,
+                :defined => :defined }
 
   def self.hook
     Symbol.class_eval do

data/lib/no_brainer/document/association/belongs_to.rb

@@ -2,13 +2,18 @@ class NoBrainer::Document::Association::BelongsTo
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:foreign_key, :class_name, :index, :validates, :required]
+    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :index, :validates, :required]
     include NoBrainer::Document::Association::Core::Metadata
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
       # TODO test :foreign_key
-      options[:foreign_key].try(:to_sym) || :"#{target_name}_id"
+      options[:foreign_key].try(:to_sym) || :"#{target_name}_#{primary_key}"
+    end
+
+    def primary_key
+      # TODO test :primary_key
+      options[:primary_key].try(:to_sym) || target_klass.pk_name
     end
 
     def target_klass
@@ -32,7 +37,7 @@ class NoBrainer::Document::Association::BelongsTo
       add_callback_for(:after_validation)
     end
 
-    eager_load_with :owner_key => ->{ foreign_key }, :target_key => ->{ :id },
+    eager_load_with :owner_key => ->{ foreign_key }, :target_key => ->{ primary_key },
                     :unscoped => true
   end
 
@@ -49,13 +54,13 @@ class NoBrainer::Document::Association::BelongsTo
     return target if loaded?
 
     if fk = owner.read_attribute(foreign_key)
-      preload(target_klass.find(fk))
+      preload(target_klass.unscoped.where(primary_key => fk).first)
     end
   end
 
   def write(target)
     assert_target_type(target)
-    owner.write_attribute(foreign_key, target.try(:id))
+    owner.write_attribute(foreign_key, target.try(:pk_value))
     preload(target)
   end
 

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

@@ -49,7 +49,7 @@ module NoBrainer::Document::Association::Core
 
   included { attr_accessor :metadata, :owner }
 
-  delegate :foreign_key, :target_name, :target_klass, :to => :metadata
+  delegate :primary_key, :foreign_key, :target_name, :target_klass, :to => :metadata
 
   def initialize(metadata, owner)
     @metadata, @owner = metadata, owner

data/lib/no_brainer/document/association/has_many.rb

@@ -2,13 +2,18 @@ class NoBrainer::Document::Association::HasMany
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:foreign_key, :class_name, :dependent]
+    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :dependent]
     include NoBrainer::Document::Association::Core::Metadata
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
       # TODO test :foreign_key
-      options[:foreign_key].try(:to_sym) || owner_klass.name.foreign_key.to_sym
+      options[:foreign_key].try(:to_sym) || :"#{owner_klass.name.underscore}_#{owner_klass.pk_name}"
+    end
+
+    def primary_key
+      # TODO test :primary_key
+      options[:primary_key].try(:to_sym) || target_klass.pk_name
     end
 
     def target_klass
@@ -25,6 +30,7 @@ class NoBrainer::Document::Association::HasMany
       target_klass.association_metadata.values.select do |assoc|
         assoc.is_a?(NoBrainer::Document::Association::BelongsTo::Metadata) and
         assoc.foreign_key == self.foreign_key                              and
+        assoc.primary_key == self.primary_key                              and
         assoc.target_klass.root_class == owner_klass.root_class
       end
     end
@@ -34,11 +40,11 @@ class NoBrainer::Document::Association::HasMany
       add_callback_for(:before_destroy) if options[:dependent]
     end
 
-    eager_load_with :owner_key => ->{ :id }, :target_key => ->{ foreign_key }
+    eager_load_with :owner_key => ->{ primary_key }, :target_key => ->{ foreign_key }
   end
 
   def target_criteria
-    @target_criteria ||= target_klass.where(foreign_key => owner.id)
+    @target_criteria ||= target_klass.where(foreign_key => owner.pk_value)
                                      .after_find(set_inverse_proc)
   end
 

data/lib/no_brainer/document/attributes.rb

@@ -1,6 +1,7 @@
 module NoBrainer::Document::Attributes
-  VALID_FIELD_OPTIONS = [:index, :default, :type, :cast_user_to_db, :cast_db_to_user, :validates, :required, :unique, :readonly]
-  RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations] + NoBrainer::DecoratedSymbol::MODIFIERS.keys
+  VALID_FIELD_OPTIONS = [:index, :default, :type, :validates, :required, :unique, :in, :readonly, :primary_key]
+  RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations, :pk_value] \
+                          + NoBrainer::DecoratedSymbol::MODIFIERS.keys
   extend ActiveSupport::Concern
 
   included do
@@ -15,8 +16,12 @@ module NoBrainer::Document::Attributes
     assign_attributes(attrs, options.reverse_merge(:pristine => true))
   end
 
+  def readable_attributes
+    @_attributes.keys & self.class.fields.keys.map(&:to_s)
+  end
+
   def attributes
-    Hash[@_attributes.keys.map { |k| [k, read_attribute(k)] }].with_indifferent_access.freeze
+    Hash[readable_attributes.map { |k| [k, read_attribute(k)] }].with_indifferent_access.freeze
   end
 
   def read_attribute(name)
@@ -57,6 +62,10 @@ module NoBrainer::Document::Attributes
     Hash[@_attributes.sort_by { |k,v| self.class.fields.keys.index(k.to_sym) || 2**10 }]
   end
 
+  def to_s
+    "#<#{self.class} #{self.class.pk_name}: #{self.pk_value.inspect}>"
+  end
+
   def inspect
     "#<#{self.class} #{inspectable_attributes.map { |k,v| "#{k}: #{v.inspect}" }.join(', ')}>"
   end
@@ -97,6 +106,23 @@ module NoBrainer::Document::Attributes
       _field(attr, self.fields[attr])
     end
 
+    def _remove_field(attr, options={})
+      inject_in_layer :attributes do
+        remove_method("#{attr}=")
+        remove_method("#{attr}")
+      end
+    end
+
+    def remove_field(attr, options={})
+      attr = attr.to_sym
+
+      _remove_field(attr, options)
+
+      ([self] + descendants).each do |klass|
+        klass.fields.delete(attr)
+      end
+    end
+
     def has_field?(attr)
       !!fields[attr.to_sym]
     end

data/lib/no_brainer/document/callbacks.rb

@@ -1,19 +1,11 @@
 module NoBrainer::Document::Callbacks
   extend ActiveSupport::Concern
 
-  def self.terminator
-    if Gem.loaded_specs['activesupport'].version.release >= Gem::Version.new('4.1')
-      proc { false }
-    else
-      'false'
-    end
-  end
-
   included do
     extend ActiveModel::Callbacks
 
-    define_model_callbacks :initialize, :create, :update, :save, :destroy, :terminator => NoBrainer::Document::Callbacks.terminator
-    define_model_callbacks :find, :only => [:after], :terminator => NoBrainer::Document::Callbacks.terminator
+    define_model_callbacks :initialize, :create, :update, :save, :destroy, :terminator => proc { false }
+    define_model_callbacks :find, :only => [:after], :terminator => proc { false }
   end
 
   def initialize(*args, &block)

data/lib/no_brainer/document/core.rb

@@ -5,16 +5,18 @@ module NoBrainer::Document::Core
     attr_accessor :_all
 
     def all
-      Rails.application.eager_load! if defined?(Rails)
+      Rails.application.eager_load! if defined?(Rails.application.eager_load!)
       @_all
     end
   end
   self._all = []
 
-  # TODO This assume the primary key is id.
-  # RethinkDB can have a custom primary key. careful.
   include ActiveModel::Conversion
 
+  def to_key
+    [pk_value]
+  end
+
   included do
     # TODO test these includes
     extend ActiveModel::Naming

data/lib/no_brainer/document/criteria.rb

@@ -2,7 +2,7 @@ module NoBrainer::Document::Criteria
   extend ActiveSupport::Concern
 
   def selector
-    self.class.selector_for(id)
+    self.class.selector_for(pk_value)
   end
 
   included { cattr_accessor :default_scope_proc, :instance_accessor => false }
@@ -10,7 +10,7 @@ module NoBrainer::Document::Criteria
   module ClassMethods
     delegate :to_rql,                        # Core
              :limit, :offset, :skip,         # Limit
-             :order_by, :reverse_order,      # OrderBy
+             :order_by, :reverse_order, :without_ordering, # OrderBy
              :scoped, :unscoped,             # Scope
              :where, :with_index, :without_index, :used_index, :indexed?, # Where
              :with_cache, :without_cache,    # Cache
@@ -18,7 +18,7 @@ module NoBrainer::Document::Criteria
              :delete_all, :destroy_all,      # Delete
              :includes, :preload,            # Preload
              :each, :to_a,                   # Enumerable
-             :first, :last, :first!, :last!, # First
+             :first, :last, :first!, :last!, :sample, # First
              :update_all, :replace_all,      # Update
              :to => :all
 
@@ -40,20 +40,20 @@ module NoBrainer::Document::Criteria
       self.default_scope_proc = criteria.is_a?(Proc) ? criteria : proc { criteria }
     end
 
-    def selector_for(id)
-      # TODO Pass primary key if not default
-      unscoped.where(:id => id)
+    def selector_for(pk)
+      rql_table.get(pk)
     end
 
     # XXX this doesn't have the same semantics as
     # other ORMs. the equivalent is find!.
-    def find(id)
-      selector_for(id).first
+    def find(pk)
+      attrs = NoBrainer.run { selector_for(pk) }
+      new_from_db(attrs).tap { |doc| doc.run_callbacks(:find) } if attrs
     end
 
-    def find!(id)
-      find(id).tap do |doc|
-        raise NoBrainer::Error::DocumentNotFound, "#{self.class} id #{id} not found" unless doc
+    def find!(pk)
+      find(pk).tap do |doc|
+        raise NoBrainer::Error::DocumentNotFound, "#{self} #{pk_name}: #{pk} not found" unless doc
       end
     end
   end

data/lib/no_brainer/document/dirty.rb

@@ -79,5 +79,16 @@ module NoBrainer::Document::Dirty
         end
       end
     end
+
+    def _remove_field(attr, options={})
+      super
+      inject_in_layer :dirty_tracking do
+        remove_method("#{attr}_change")
+        remove_method("#{attr}_changed?")
+        remove_method("#{attr}_was")
+        remove_method("#{attr}=")
+        remove_method("#{attr}")
+      end
+    end
   end
 end

data/lib/no_brainer/document/dynamic_attributes.rb

@@ -17,4 +17,8 @@ module NoBrainer::Document::DynamicAttributes
       @_attributes[name] = value
     end
   end
+
+  def readable_attributes
+    @_attributes.keys
+  end
 end

data/lib/no_brainer/document/id.rb

@@ -5,17 +5,23 @@ require 'digest/md5'
 module NoBrainer::Document::Id
   extend ActiveSupport::Concern
 
-  included do
-    self.field :id, :type => String, :default => ->{ NoBrainer::Document::Id.generate }, :readonly => true
+  DEFAULT_PK_NAME = :id
+
+  def pk_value
+    __send__(self.class.pk_name)
+  end
+
+  def pk_value=(value)
+    __send__("#{self.class.pk_name}=", value)
   end
 
   def ==(other)
     return super unless self.class == other.class
-    !id.nil? && id == other.id
+    !pk_value.nil? && pk_value == other.pk_value
   end
   alias_method :eql?, :==
 
-  delegate :hash, :to => :id
+  delegate :hash, :to => :pk_value
 
   # The following code is inspired by the mongo-ruby-driver
 
@@ -46,4 +52,43 @@ module NoBrainer::Document::Id
 
     oid.unpack("C12").map {|e| v=e.to_s(16); v.size == 1 ? "0#{v}" : v }.join
   end
+
+  module ClassMethods
+    def define_default_pk
+      class_variable_set(:@@pk_name, nil)
+      field NoBrainer::Document::Id::DEFAULT_PK_NAME, :primary_key => :default,
+        :type => String, :default => ->{ NoBrainer::Document::Id.generate }
+    end
+
+    def define_pk(attr)
+      if fields[pk_name].try(:[], :primary_key) == :default
+        remove_field(pk_name, :set_default_pk => false)
+      end
+      class_variable_set(:@@pk_name, attr)
+    end
+
+    def pk_name
+      class_variable_get(:@@pk_name)
+    end
+
+    def _field(attr, options={})
+      super
+      define_pk(attr) if options[:primary_key]
+    end
+
+    def field(attr, options={})
+      if options[:primary_key]
+        options = options.merge(:readonly => true) if options[:readonly].nil?
+        options = options.merge(:index => true)
+      end
+      super
+    end
+
+    def _remove_field(attr, options={})
+      super
+      if fields[attr][:primary_key] && options[:set_default_pk] != false
+        define_default_pk
+      end
+    end
+  end
 end

data/lib/no_brainer/document/index.rb

@@ -5,7 +5,6 @@ module NoBrainer::Document::Index
   included do
     cattr_accessor :indexes, :instance_accessor => false
     self.indexes = {}
-    self.index :id
   end
 
   module ClassMethods
@@ -57,6 +56,11 @@ module NoBrainer::Document::Index
       end
     end
 
+    def _remove_field(attr, options={})
+      super
+      remove_index(attr) if fields[attr][:index]
+    end
+
     def perform_create_index(index_name, options={})
       index_name = index_name.to_sym
       index_args = self.indexes[index_name]
@@ -79,7 +83,7 @@ module NoBrainer::Document::Index
 
     def perform_update_indexes(options={})
       current_indexes = NoBrainer.run(self.rql_table.index_list).map(&:to_sym)
-      wanted_indexes = self.indexes.keys - [:id] # XXX Primary key?
+      wanted_indexes = self.indexes.keys - [self.pk_name]
 
       (current_indexes - wanted_indexes).each do |index_name|
         perform_drop_index(index_name, options)