nobrainer 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dd6046706e63442640e96473b737f37ad5a4fea7
-  data.tar.gz: e1634aaf6acfb3c3e5e4287c57151d54cce30ee1
+  metadata.gz: 43783bcf0d625af679de685ab771782ce9b141f3
+  data.tar.gz: 4b5e4ff205f55adb754133b681b6e71c71772790
 SHA512:
-  metadata.gz: ac735666befc4a025536e5beb72a8c4d4d79259875a8ad956ae16e4399c17cf5c2dcc7eecf6bcfa4351d56aec14b1a83a7d68cb751723d5beade516011990915
-  data.tar.gz: b6f69cd4dfbd953d9acc06a1c06aa9a27851baa51b1e1a2d0fce0ff320a32131c49724e5ea6aaa8af3a2aaf74bdb661379eb0a4e97abdb98e8084e5fae0516c5
+  metadata.gz: 1c182d056390dd2c7b51bac68999d79c72cfaca49837239c4eead56ce8d0ff474630cc7b24e9fa12a4ff8d36641a5f6cc46fb7c588c45e975af42e8d4b5dbebc
+  data.tar.gz: 5226adb01498de4e82f8b3a4729c818ed1a40dc07e3596061d64956407b9a62129108046e0625bbe60bcac1804f0b8111cab4ec3a736151b6cfdc3d5799f2d88

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, :colorize_logger,
+                   :distributed_lock_class
 
     def apply_defaults
       self.rethinkdb_url           = default_rethinkdb_url
@@ -15,6 +16,7 @@ module NoBrainer::Config
       self.max_reconnection_tries  = 10
       self.durability              = default_durability
       self.colorize_logger         = true
+      self.distributed_lock_class  = nil
     end
 
     def reset!
@@ -36,7 +38,7 @@ module NoBrainer::Config
 
     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']
@@ -46,11 +48,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/connection.rb

@@ -1,7 +1,7 @@
 require 'rethinkdb'
 
 class NoBrainer::Connection
-  attr_accessor :uri
+  attr_accessor :uri, :parsed_uri
 
   def initialize(uri)
     self.uri = uri
@@ -9,19 +9,21 @@ class NoBrainer::Connection
   end
 
   def parsed_uri
-    require 'uri'
-    uri = URI.parse(self.uri)
+    @parsed_uri ||= begin
+      require 'uri'
+      uri = URI.parse(self.uri)
 
-    if uri.scheme != 'rethinkdb'
-      raise NoBrainer::Error::Connection,
-        "Invalid URI. Expecting something like rethinkdb://host:port/database. Got #{uri}"
-    end
+      if uri.scheme != 'rethinkdb'
+        raise NoBrainer::Error::Connection,
+          "Invalid URI. Expecting something like rethinkdb://host:port/database. Got #{uri}"
+      end
 
-    { :auth_key => uri.password,
-      :host     => uri.host,
-      :port     => uri.port || 28015,
-      :db       => uri.path.gsub(/^\//, ''),
-    }.tap { |result| raise "No database specified in #{uri}" unless result[:db].present? }
+      { :auth_key => uri.password,
+        :host     => uri.host,
+        :port     => uri.port || 28015,
+        :db       => uri.path.gsub(/^\//, ''),
+      }.tap { |result| raise "No database specified in #{uri}" unless result[:db].present? }
+    end
   end
 
   def raw

data/lib/no_brainer/criteria/core.rb

@@ -17,12 +17,7 @@ module NoBrainer::Criteria::Core
 
   def inspect
     # rescue super because sometimes klass is not set.
-    str = to_rql.inspect rescue super
-    if str =~ /Erroneous_Portion_Constructed/
-      # Need to fix the rethinkdb gem.
-      str = "the rethinkdb gem is flipping out with Erroneous_Portion_Constructed"
-    end
-    str
+    to_rql.inspect rescue super
   end
 
   def run(rql=nil)

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

@@ -12,11 +12,6 @@ module NoBrainer::Criteria::Preload
     chain(:keep_cache => true) { |criteria| criteria._preloads = values }
   end
 
-  def includes(*values)
-    NoBrainer.logger.warn "[NoBrainer] includes() is deprecated and will be removed, use preload() instead."
-    preload(*values)
-  end
-
   def merge!(criteria, options={})
     super
     self._preloads = self._preloads + criteria._preloads

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

@@ -56,14 +56,15 @@ module NoBrainer::Criteria::Where
 
   class BinaryOperator < Struct.new(:key, :op, :value, :criteria)
     def simplify
+      key = cast_key(self.key)
       case op
       when :in then
         case value
-        when Range then BinaryOperator.new(key, :between, (cast(value.min)..cast(value.max)), criteria)
-        when Array then BinaryOperator.new(key, :in, value.map(&method(:cast)).uniq, criteria)
+        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)
         else raise ArgumentError.new ":in takes an array/range, not #{value}"
         end
-      else BinaryOperator.new(key, op, cast(value), criteria)
+      else BinaryOperator.new(key, op, cast_value(value), criteria)
       end
     end
 
@@ -77,8 +78,33 @@ module NoBrainer::Criteria::Where
 
     private
 
-    def cast(value)
-      criteria.klass.cast_value_for(key, value)
+    def association
+      # FIXME This leaks memory with dynamic attributes. The internals of type
+      # checking will convert the key to a symbol, and Ruby does not garbage
+      # collect symbols.
+      @association ||= [criteria.klass.association_metadata[key.to_sym]]
+      @association.first
+    end
+
+    def cast_value(value)
+      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.pk_value
+      else
+        criteria.klass.cast_user_to_db_for(key, value)
+      end
+    end
+
+    def cast_key(key)
+      case association
+      when NoBrainer::Document::Association::BelongsTo::Metadata
+        association.foreign_key
+      else
+        key
+      end
     end
   end
 
@@ -126,8 +152,9 @@ module NoBrainer::Criteria::Where
     when String, Symbol then parse_clause_stub_eq(key, value)
     when NoBrainer::DecoratedSymbol then
       case key.modifier
-      when :ne then parse_clause(:not => { key.symbol => value })
-      when :eq then parse_clause_stub_eq(key.symbol, value)
+      when :nin then parse_clause(:not => { key.symbol.in => value })
+      when :ne  then parse_clause(:not => { key.symbol.eq => value })
+      when :eq  then parse_clause_stub_eq(key.symbol, value)
       else BinaryOperator.new(key.symbol, key.modifier, value, self)
       end
     else raise "Invalid key: #{key}"

data/lib/no_brainer/decorated_symbol.rb

@@ -1,5 +1,6 @@
 class NoBrainer::DecoratedSymbol < Struct.new(:symbol, :modifier, :args)
-  MODIFIERS = { :ne => :ne, :not => :ne, :in => :in, :eq => :eq,
+  MODIFIERS = { :in => :in, :nin => :nin,
+                :eq => :eq, :ne => :ne, :not => :ne,
                 :gt => :gt, :ge => :ge, :gte => :ge,
                 :lt => :lt, :le => :le, :lte => :le}
 

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
@@ -30,10 +35,9 @@ class NoBrainer::Document::Association::BelongsTo
 
       delegate("#{foreign_key}=", :assign_foreign_key, :call_super => true)
       add_callback_for(:after_validation)
-      # TODO test if we are not overstepping on another foreign_key
     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
 
@@ -47,21 +51,25 @@ class NoBrainer::Document::Association::BelongsTo
   end
 
   def read
-    return @target_container.first if loaded?
+    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
 
-  def preload(target)
-    @target_container = [*target] # the * is for the generic eager loading code
+  def preload(targets)
+    @target_container = [*targets] # the * is for the generic eager loading code
+    target
+  end
+
+  def target
     @target_container.first
   end
 
@@ -70,8 +78,8 @@ class NoBrainer::Document::Association::BelongsTo
   end
 
   def after_validation_callback
-    if loaded? && @target_container.first && !@target_container.first.persisted?
-      raise NoBrainer::Error::AssociationNotSaved.new("#{target_name} must be saved first")
+    if loaded? && target && !target.persisted?
+      raise NoBrainer::Error::AssociationNotPersisted.new("#{target_name} must be saved first")
     end
   end
 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,9 @@
 module NoBrainer::Document::Attributes
-  VALID_FIELD_OPTIONS = [:index, :default, :type, :type_cast_method, :validates, :required, :readonly]
-  RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations] + NoBrainer::DecoratedSymbol::MODIFIERS.keys
+  VALID_FIELD_OPTIONS = [:index, :default, :type, :cast_user_to_db,
+                         :cast_db_to_user, :validates, :required, :unique,
+                         :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 +18,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)
@@ -43,13 +50,14 @@ module NoBrainer::Document::Attributes
     @_attributes.clear if options[:pristine]
     if options[:from_db]
       @_attributes.merge!(attrs)
+      clear_dirtiness
     else
+      clear_dirtiness if options[:pristine]
       attrs.each { |k,v| self.write_attribute(k,v) }
     end
     assign_defaults if options[:pristine]
     self
   end
-  def attributes=(*args); assign_attributes(*args); end
 
   def inspectable_attributes
     # TODO test that thing
@@ -96,6 +104,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

@@ -3,8 +3,9 @@ module NoBrainer::Document::Callbacks
 
   included do
     extend ActiveModel::Callbacks
-    define_model_callbacks :initialize, :create, :update, :save, :destroy, :terminator => 'false'
-    define_model_callbacks :find, :only => [:after], :terminator => 'false'
+
+    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

@@ -1,18 +1,27 @@
 module NoBrainer::Document::Core
   extend ActiveSupport::Concern
 
-  singleton_class.send(:attr_accessor, :all)
-  self.all = []
+  singleton_class.class_eval do
+    attr_accessor :_all
+
+    def all
+      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
     extend ActiveModel::Translation
 
-    NoBrainer::Document::Core.all << self
+    NoBrainer::Document::Core._all << self
   end
 end

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 }
@@ -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

@@ -6,11 +6,6 @@ module NoBrainer::Document::Dirty
   # things like undefined -> nil. Going through the getters will
   # not give us that.
 
-  def assign_attributes(attrs, options={})
-    clear_dirtiness if options[:pristine]
-    super
-  end
-
   def _create(*args)
     super.tap { clear_dirtiness }
   end
@@ -84,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