nobrainer 0.10.0 → 0.12.0

data/lib/no_brainer/document/attributes.rb

@@ -1,5 +1,5 @@
 module NoBrainer::Document::Attributes
-  VALID_FIELD_OPTIONS = [:index, :default, :type]
+  VALID_FIELD_OPTIONS = [:index, :default, :type, :type_cast_method, :validates]
   RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations] + NoBrainer::DecoratedSymbol::MODIFIERS.keys
   extend ActiveSupport::Concern
 
@@ -10,14 +10,13 @@ module NoBrainer::Document::Attributes
     self.fields = {}
   end
 
-  def initialize(attrs={}, options={})
-    super
-    @attributes = {}
+  def _initialize(attrs={}, options={})
+    @_attributes = {}.with_indifferent_access
     assign_attributes(attrs, options.reverse_merge(:pristine => true))
   end
 
   def attributes
-    @attributes.dup.freeze
+    Hash[@_attributes.keys.map { |k| [k, read_attribute(k)] }].with_indifferent_access.freeze
   end
 
   def read_attribute(name)
@@ -32,7 +31,7 @@ module NoBrainer::Document::Attributes
 
   def assign_defaults
     self.class.fields.each do |name, field_options|
-      if field_options.has_key?(:default) && !@attributes.has_key?(name.to_s)
+      if field_options.has_key?(:default) && !@_attributes.has_key?(name)
         default_value = field_options[:default]
         default_value = default_value.call if default_value.is_a?(Proc)
         self.write_attribute(name, default_value)
@@ -45,7 +44,7 @@ module NoBrainer::Document::Attributes
   end
 
   def assign_attributes(attrs, options={})
-    @attributes.clear if options[:pristine]
+    @_attributes.clear if options[:pristine]
     _assign_attributes(attrs, options)
     assign_defaults if options[:pristine]
     self
@@ -54,7 +53,7 @@ module NoBrainer::Document::Attributes
 
   def inspectable_attributes
     # TODO test that thing
-    Hash[@attributes.sort_by { |k,v| self.class.fields.keys.index(k.to_sym) || 2**10 }]
+    Hash[@_attributes.sort_by { |k,v| self.class.fields.keys.index(k.to_sym) || 2**10 }]
   end
 
   def inspect
@@ -88,28 +87,15 @@ module NoBrainer::Document::Attributes
       # Using a layer so the user can use super when overriding these methods
       inject_in_layer :attributes, <<-RUBY, __FILE__, __LINE__ + 1
         def #{name}=(value)
-          @attributes['#{name}'] = value
+          @_attributes['#{name}'] = value
         end
 
         def #{name}
-          @attributes['#{name}']
+          @_attributes['#{name}']
         end
       RUBY
     end
 
-    def remove_field(name)
-      name = name.to_sym
-
-      ([self] + descendants).each do |klass|
-        klass.fields.delete(name)
-      end
-
-      inject_in_layer :attributes, <<-RUBY, __FILE__, __LINE__ + 1
-        undef #{name}=
-        undef #{name}
-      RUBY
-    end
-
     def has_field?(name)
       !!fields[name.to_sym]
     end

data/lib/no_brainer/document/callbacks.rb

@@ -0,0 +1,37 @@
+module NoBrainer::Document::Callbacks
+  extend ActiveSupport::Concern
+
+  included do
+    extend ActiveModel::Callbacks
+    define_model_callbacks :initialize, :create, :update, :save, :destroy, :terminator => 'false'
+    define_model_callbacks :find, :only => [:after], :terminator => 'false'
+  end
+
+  def initialize(*args)
+    run_callbacks(:initialize) { _initialize(*args); true }
+  end
+
+  def _create(*args)
+    run_callbacks(:create) { super }
+  end
+
+  def update(*args, &block)
+    run_callbacks(:update) { super }
+  end
+
+  def replace(*args, &block)
+    run_callbacks(:update) { super }
+  end
+
+  def _update_changed(*args)
+    run_callbacks(:update) { super }
+  end
+
+  def save(*args)
+    run_callbacks(:save) { super }
+  end
+
+  def destroy(*args)
+    run_callbacks(:destroy) { super }
+  end
+end

data/lib/no_brainer/document/core.rb

@@ -15,6 +15,4 @@ module NoBrainer::Document::Core
 
     NoBrainer::Document::Core.all << self
   end
-
-  def initialize(attrs={}, options={}); end
 end

data/lib/no_brainer/document/criteria.rb

@@ -16,7 +16,7 @@ module NoBrainer::Document::Criteria
              :with_cache, :without_cache,    # Cache
              :count, :empty?, :any?,         # Count
              :delete_all, :destroy_all,      # Delete
-             :includes,                      # EagerLoading
+             :includes, :preload,            # Preload
              :each, :to_a,                   # Enumerable
              :first, :last, :first!, :last!, # First
              :inc_all, :dec_all,             # Inc

data/lib/no_brainer/document/dirty.rb

@@ -5,84 +5,81 @@ module NoBrainer::Document::Dirty
   # ActiveModel::AttributeMethods which gives pretty violent method_missing()
   # capabilities, such as giving a getter/setter method for any keys within the
   # attributes keys. We don't want that.
+  # Also it doesn't work properly with array and hashes
 
-  included do
-    attr_accessor :previous_changes
-    after_save { clear_dirtiness }
+  included { after_save { clear_dirtiness } }
+
+  def old_attributes_values
+    @old_attributes_values ||= {}.with_indifferent_access
   end
 
-  def changed_attributes
-    @changed_attributes ||= {}
+  def clear_dirtiness
+    @old_attributes_values.try(:clear)
   end
 
   def _assign_attributes(attrs, options={})
     super
-    clear_dirtiness if options[:pristine]
-  end
-
-  def clear_dirtiness
-    self.previous_changes = changes
-    self.changed_attributes.clear
+    clear_dirtiness if options[:from_db]
   end
 
   def changed?
-    changed_attributes.present?
+    changes.present?
   end
 
   def changed
-    changed_attributes.keys
+    changes.keys
   end
 
   def changes
-    Hash[changed_attributes.map { |k,v| [k, [v, read_attribute(k)]] }]
+    result = {}.with_indifferent_access
+    old_attributes_values.each do |attr, old_value|
+      current_value = read_attribute(attr)
+      result[attr] = [old_value, current_value] if current_value != old_value
+    end
+    result
   end
 
-  def attribute_will_change!(attr, new_value)
-    return if changed_attributes.include?(attr)
-
-    # ActiveModel ignores TypeError and NoMethodError exception as if nothng
-    # happened. Why is that?
-    value = read_attribute(attr)
-    value = value.clone if value.duplicable?
-
-    return if value == new_value
-
-    changed_attributes[attr] = value
+  def attribute_may_change(attr, current_value)
+    unless old_attributes_values.has_key?(attr)
+      old_attributes_values[attr] = current_value.deep_dup
+    end
   end
 
   module ClassMethods
     def field(name, options={})
       super
 
-      inject_in_layer :dirty_tracking, <<-RUBY, __FILE__, __LINE__ + 1
-        def #{name}_changed?
-          changed_attributes.include?(:#{name})
+      inject_in_layer :dirty_tracking do
+        define_method("#{name}_change") do
+          if old_attributes_values.has_key?(name)
+            result = [old_attributes_values[name], read_attribute(name)]
+            result = nil if result.first == result.last
+            result
+          end
         end
 
-        def #{name}_change
-          [changed_attributes[:#{name}], #{name}] if #{name}_changed?
+        define_method("#{name}_changed?") do
+          !!__send__("#{name}_change")
         end
 
-        def #{name}_was
-          #{name}_changed? ? changed_attributes[:#{name}] : #{name}
+        define_method("#{name}_was") do
+          old_attributes_values.has_key?(name) ?
+            old_attributes_values[name] : read_attribute(name)
         end
 
-        def #{name}=(value)
-          attribute_will_change!(:#{name}, value)
-          super
+        define_method("#{name}") do
+          super().tap do |value|
+            # This take care of string/arrays/hashes that could change without going
+            # through the setter.
+            attribute_may_change(name, value) if value.respond_to?(:size)
+          end
         end
-      RUBY
-    end
 
-    def remove_field(name)
-      super
-
-      inject_in_layer :dirty_tracking, <<-RUBY, __FILE__, __LINE__ + 1
-        undef #{name}_changed?
-        undef #{name}_change
-        undef #{name}_was
-        undef #{name}=
-      RUBY
+        define_method("#{name}=") do |value|
+          attribute_may_change(name, read_attribute(name))
+          super(value)
+        end
+      end
     end
   end
 end

data/lib/no_brainer/document/dynamic_attributes.rb

@@ -2,11 +2,19 @@ module NoBrainer::Document::DynamicAttributes
   extend ActiveSupport::Concern
 
   def read_attribute(name)
-    self.respond_to?("#{name}") ? super : @attributes[name.to_s]
+    if self.respond_to?("#{name}") 
+      super
+    else
+      @_attributes[name].tap { |value| attribute_may_change(name, value) if value.respond_to?(:size) }
+    end
   end
 
   def write_attribute(name, value)
-    attribute_will_change!(name, value)
-    self.respond_to?("#{name}=") ? super : @attributes[name.to_s] = value
+    if self.respond_to?("#{name}=")
+      super
+    else
+      attribute_may_change(name, read_attribute(name))
+      @_attributes[name] = value
+    end
   end
 end

data/lib/no_brainer/document/id.rb

@@ -6,7 +6,7 @@ module NoBrainer::Document::Id
   extend ActiveSupport::Concern
 
   included do
-    self.field :id, :default => ->{ NoBrainer::Document::Id.generate }
+    self.field :id, :type => String, :default => ->{ NoBrainer::Document::Id.generate }
   end
 
   def ==(other)

data/lib/no_brainer/document/index.rb

@@ -59,11 +59,6 @@ module NoBrainer::Document::Index
       end
     end
 
-    def remove_field(name)
-      remove_index(name) if fields[name.to_sym][:index]
-      super
-    end
-
     def perform_create_index(index_name, options={})
       index_name = index_name.to_sym
       index_args = self.indexes[index_name]

data/lib/no_brainer/document/persistance.rb

@@ -6,8 +6,7 @@ module NoBrainer::Document::Persistance
     define_model_callbacks :create, :update, :save, :destroy, :terminator => 'false'
   end
 
-  # TODO after_initialize, after_find callback
-  def initialize(attrs={}, options={})
+  def _initialize(attrs={}, options={})
     super
     @new_record = !options[:from_db]
   end
@@ -25,56 +24,57 @@ module NoBrainer::Document::Persistance
   end
 
   def reload(options={})
-    unless options[:keep_ivars]
-      id = self.id
-      instance_variables.each { |ivar| remove_instance_variable(ivar) }
-      @attributes = {}
-      self.id = id
-    end
-    assign_attributes(selector.raw.first!, :pristine => true, :from_db => true)
+    attrs = selector.raw.first!
+    instance_variables.each { |ivar| remove_instance_variable(ivar) } unless options[:keep_ivars]
+    initialize(attrs, :pristine => true, :from_db => true)
     self
   end
 
   def _create(options={})
-    run_callbacks :create do
-      if options[:validate] && !valid?
-        false
-      else
-        keys = self.class.insert_all(attributes)
-        self.id ||= keys.first
-        @new_record = false
-        true
-      end
-    end
+    return false if options[:validate] && !valid?
+    keys = self.class.insert_all(@_attributes)
+    self.id ||= keys.first
+    @new_record = false
+    true
   end
 
   def update(options={}, &block)
-    run_callbacks :update do
-      if options[:validate] && !valid?
-        false
-      else
-        selector.update_all(&block)
-        true
-      end
-    end
+    return false if options[:validate] && !valid?
+    selector.update_all(&block)
+    true
   end
 
   def replace(options={}, &block)
-    run_callbacks :update do
-      if options[:validate] && !valid?
-        false
-      else
-        selector.replace_all(&block)
-        true
-      end
+    return false if options[:validate] && !valid?
+    selector.replace_all(&block)
+    true
+  end
+
+  def _update_changed_attributes(changed_attrs)
+    # If we have a hash to save, we replace the entire document
+    # instead of doing some smart update. This is because RethinkDB
+    # will merge the existing hash with the given hash. If the
+    # user has deleted some keys, we won't remove them.
+    if changed_attrs.values.any? { |v| v.is_a?(Hash) }
+      selector.replace_all { @_attributes }
+    else
+      selector.update_all { changed_attrs }
     end
   end
 
+  def _update_changed(options={})
+    return false if options[:validate] && !valid?
+
+    # We won't be using the `changes` values, because they went through
+    # read_attribute(), and we want the raw values.
+    changed_attrs = Hash[self.changed.map { |k| [k, @_attributes[k]] }]
+    _update_changed_attributes(changed_attrs) if changed_attrs.present?
+    true
+  end
+
   def save(options={})
     options = options.reverse_merge(:validate => true)
-    run_callbacks :save do
-      new_record? ? _create(options) : replace(options) { attributes }
-    end
+    new_record? ? _create(options) : _update_changed(options)
   end
 
   def save!(*args)
@@ -95,12 +95,12 @@ module NoBrainer::Document::Persistance
       selector.delete_all
       @destroyed = true
     end
-    # TODO freeze attributes
+    @_attributes.freeze
     true
   end
 
   def destroy
-    run_callbacks(:destroy) { delete }
+    delete
   end
 
   module ClassMethods

data/lib/no_brainer/document/serialization.rb

@@ -3,7 +3,6 @@ module NoBrainer::Document::Serialization
 
   include ActiveModel::Serialization
   include ActiveModel::Serializers::JSON
-  include ActiveModel::Serializers::Xml
 
   included { self.include_root_in_json = false }
 end

data/lib/no_brainer/document/timestamps.rb

@@ -2,17 +2,18 @@ module NoBrainer::Document::Timestamps
   extend ActiveSupport::Concern
 
   included do
-    self.field :created_at, :type => Time
-    self.field :updated_at, :type => Time
+    field :created_at, :type => Time
+    field :updated_at, :type => Time
 
-    before_create { self.created_at = Time.now if self.respond_to?(:created_at=) }
-    before_save   { self.updated_at = Time.now if self.respond_to?(:updated_at=) }
+    before_create { self.created_at = self.updated_at = Time.now }
+    # Not using the before_update callback as it would mess
+    # with the dirty tracking. We want to bypass the database
+    # call if nothing has changed.
   end
 
-  module ClassMethods
-    def disable_timestamps
-      self.remove_field :created_at
-      self.remove_field :updated_at
-    end
+  def _update_changed_attributes(changed_attrs)
+    self.updated_at = Time.now
+    changed_attrs['updated_at'] = @_attributes['updated_at']
+    super
   end
 end

data/lib/no_brainer/document/types.rb

@@ -1,14 +1,9 @@
 module NoBrainer::Document::Types
   extend ActiveSupport::Concern
 
-  included do
-    # We namespace our fake Boolean class to avoid polluting the global namespace
-    class_exec { class Boolean; def initialize; raise; end; end }
-    before_validation :add_type_errors
-  end
-
   module CastingRules
     extend self
+    InvalidType = NoBrainer::Error::InvalidType
 
     def String(value)
       case value
@@ -63,67 +58,75 @@ module NoBrainer::Document::Types
       else raise InvalidType
       end
     end
-  end
 
-  def self.cast(value, type, cast_method)
-    return value if value.nil? || type.nil? || value.is_a?(type)
-    cast_method.call(value)
-  end
-
-  def self.lookup_cast_method(type)
-    type = type.to_s
-    type = 'Boolean' if type == 'NoBrainer::Document::Types::Boolean'
-    CastingRules.method(type)
-  rescue NameError
-    proc { raise InvalidType }
-  end
+    def lookup(type)
+      CastingRules.method(type.to_s)
+    rescue NameError
+      proc { raise InvalidType }
+    end
 
-  class InvalidType < RuntimeError
-    attr_accessor :type
-    def initialize(type=nil)
-      @type = type
+    def cast(value, type, type_cast_method)
+      return value if value.nil? || type.nil? || value.is_a?(type)
+      type_cast_method.call(value)
     end
+  end
 
-    def validation_error_args
-      [:invalid_type, :type => type.to_s.underscore.humanize.downcase]
+  included do
+    # We namespace our fake Boolean class to avoid polluting the global namespace
+    class_exec do
+      class Boolean
+        def initialize; raise; end
+        def self.inspect; 'Boolean'; end
+        def self.to_s; inspect; end
+        def self.name; inspect; end
+      end
     end
+    before_validation :add_type_errors
   end
 
   def add_type_errors
     return unless @pending_type_errors
     @pending_type_errors.each do |name, error|
-      errors.add(name, *error.validation_error_args)
+      errors.add(name, :invalid_type, :type => error.human_type_name)
     end
   end
 
   module ClassMethods
+    def cast_value_for(name, value)
+      name = name.to_sym
+      field_def = fields[name]
+      return value unless field_def && field_def[:type]
+      NoBrainer::Document::Types::CastingRules.cast(value, field_def[:type], field_def[:type_cast_method])
+    rescue NoBrainer::Error::InvalidType => error
+      error.type = field_def[:type]
+      error.value = value
+      error.attr_name = name
+      raise error
+    end
+
     def field(name, options={})
-      super
-      return unless options.has_key?(:type)
+      return super unless options.has_key?(:type)
+
       name = name.to_sym
       type = options[:type]
-      cast_method = NoBrainer::Document::Types.lookup_cast_method(type)
+      options[:type_cast_method] = NoBrainer::Document::Types::CastingRules.lookup(type)
+
+      super
 
       inject_in_layer :types do
         define_method("#{name}=") do |value|
           begin
-            value = NoBrainer::Document::Types.cast(value, type, cast_method)
+            value = self.class.cast_value_for(name, value)
             @pending_type_errors.try(:delete, name)
-          rescue NoBrainer::Document::Types::InvalidType => error
-            error.type ||= type
+          rescue NoBrainer::Error::InvalidType => error
             @pending_type_errors ||= {}
             @pending_type_errors[name] = error
           end
           super(value)
         end
-      end
-    end
 
-    def remove_field(name)
-      super
-      inject_in_layer :types, <<-RUBY, __FILE__, __LINE__ + 1
-        undef #{name}=
-      RUBY
+        define_method("#{name}?") { !!read_attribute(name) } if type == Boolean
+      end
     end
   end
 end

data/lib/no_brainer/document/validation.rb

@@ -8,6 +8,11 @@ module NoBrainer::Document::Validation
   end
 
   module ClassMethods
+    def field(name, options={})
+      super
+      validates(name.to_sym, options[:validates]) if options[:validates]
+    end
+
     def validates_uniqueness_of(*attr_names)
       validates_with UniquenessValidator, _merge_attributes(attr_names)
     end

data/lib/no_brainer/document.rb

@@ -5,10 +5,10 @@ module NoBrainer::Document
   extend NoBrainer::Autoload
 
   autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Validation, :Types,
-                       :Persistance, :Dirty, :Id, :Association, :Serialization, :Criteria,
-                       :Polymorphic, :Index, :Timestamps
+                       :Persistance, :Callbacks, :Dirty, :Id, :Association, :Serialization,
+                       :Criteria, :Polymorphic, :Index
 
-  autoload :DynamicAttributes
+  autoload :DynamicAttributes, :Timestamps
 
   singleton_class.delegate :all, :to => Core
 end

data/lib/no_brainer/document_with_timestamps.rb

@@ -0,0 +1,6 @@
+module NoBrainer::DocumentWithTimestamps
+  extend ActiveSupport::Concern
+
+  include NoBrainer::Document
+  include NoBrainer::Document::Timestamps
+end

data/lib/no_brainer/error.rb

@@ -1,11 +1,28 @@
 module NoBrainer::Error
-  class Connection          < StandardError; end
-  class DocumentNotFound    < StandardError; end
-  class DocumentInvalid     < StandardError; end
-  class DocumentNotSaved    < StandardError; end
-  class ChildrenExist       < StandardError; end
-  class CannotUseIndex      < StandardError; end
-  class MissingIndex        < StandardError; end
-  class InvalidType         < StandardError; end
-  class AssociationNotSaved < StandardError; end
+  class Connection          < RuntimeError; end
+  class DocumentNotFound    < RuntimeError; end
+  class DocumentInvalid     < RuntimeError; end
+  class DocumentNotSaved    < RuntimeError; end
+  class ChildrenExist       < RuntimeError; end
+  class CannotUseIndex      < RuntimeError; end
+  class MissingIndex        < RuntimeError; end
+  class InvalidType         < RuntimeError; end
+  class AssociationNotSaved < RuntimeError; end
+
+  class InvalidType < RuntimeError
+    attr_accessor :attr_name, :value, :type
+    def initialize(options={})
+      @attr_name = options[:attr_name]
+      @value     = options[:value]
+      @type      = options[:type]
+    end
+
+    def human_type_name
+      type.to_s.underscore.humanize.downcase
+    end
+
+    def message
+      "#{attr_name} should be used with a #{human_type_name}. Got `#{value}`"
+    end
+  end
 end

data/lib/no_brainer/query_runner/missing_index.rb

@@ -3,7 +3,7 @@ class NoBrainer::QueryRunner::MissingIndex < NoBrainer::QueryRunner::Middleware
     @runner.call(env)
   rescue RethinkDB::RqlRuntimeError => e
     if e.message =~ /^Index `(.+)` was not found\.$/
-      raise NoBrainer::Error::MissingIndex.new("Please run \"rake db:update_indexes\" to create index `#{$1}`\n" +
+      raise NoBrainer::Error::MissingIndex.new("Please run \"rake db:update_indexes\" to create the index `#{$1}`\n" +
                                                "--> Read http://nobrainer.io/docs/indexes for more information.")
     end
     raise