nobrainer 0.10.0 → 0.13.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, :required, :readonly]
   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)
@@ -40,13 +39,13 @@ module NoBrainer::Document::Attributes
     end
   end
 
-  def _assign_attributes(attrs, options={})
-    attrs.each { |k,v| self.write_attribute(k,v) }
-  end
-
   def assign_attributes(attrs, options={})
-    @attributes.clear if options[:pristine]
-    _assign_attributes(attrs, options)
+    @_attributes.clear if options[:pristine]
+    if options[:from_db]
+      @_attributes.merge!(attrs)
+    else
+      attrs.each { |k,v| self.write_attribute(k,v) }
+    end
     assign_defaults if options[:pristine]
     self
   end
@@ -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
@@ -72,46 +71,33 @@ module NoBrainer::Document::Attributes
       subclass.fields = self.fields.dup
     end
 
-    def field(name, options={})
-      name = name.to_sym
-
-      options.assert_valid_keys(*VALID_FIELD_OPTIONS)
-      if name.in?(RESERVED_FIELD_NAMES)
-        raise "Cannot use a reserved field name: #{name}"
-      end
-
-      ([self] + descendants).each do |klass|
-        klass.fields[name] ||= {}
-        klass.fields[name].merge!(options)
-      end
-
+    def _field(attr, options={})
       # 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
-        end
-
-        def #{name}
-          @attributes['#{name}']
-        end
-      RUBY
+      attr = attr.to_s
+      inject_in_layer :attributes do
+        define_method("#{attr}=") { |value| @_attributes[attr] = value }
+        define_method("#{attr}")  { @_attributes[attr] }
+      end
     end
 
-    def remove_field(name)
-      name = name.to_sym
+    def field(attr, options={})
+      attr = attr.to_sym
+
+      options.assert_valid_keys(*VALID_FIELD_OPTIONS)
+      if attr.in?(RESERVED_FIELD_NAMES)
+        raise "Cannot use a reserved field attr: #{attr}"
+      end
 
       ([self] + descendants).each do |klass|
-        klass.fields.delete(name)
+        klass.fields[attr] ||= {}
+        klass.fields[attr].deep_merge!(options)
       end
 
-      inject_in_layer :attributes, <<-RUBY, __FILE__, __LINE__ + 1
-        undef #{name}=
-        undef #{name}
-      RUBY
+      _field(attr, self.fields[attr])
     end
 
-    def has_field?(name)
-      !!fields[name.to_sym]
+    def has_field?(attr)
+      !!fields[attr.to_sym]
     end
   end
 end

data/lib/no_brainer/document/callbacks.rb

@@ -0,0 +1,29 @@
+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, &block)
+    run_callbacks(:initialize) { _initialize(*args); true }
+  end
+
+  def _create(*args, &block)
+    run_callbacks(:create) { super }
+  end
+
+  def _update_only_changed_attrs(*args, &block)
+    run_callbacks(:update) { super }
+  end
+
+  def save(*args, &block)
+    run_callbacks(:save) { super }
+  end
+
+  def destroy(*args, &block)
+    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,10 +16,9 @@ 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
              :update_all, :replace_all,      # Update
              :to => :all
 

data/lib/no_brainer/document/dirty.rb

@@ -1,88 +1,88 @@
 module NoBrainer::Document::Dirty
   extend ActiveSupport::Concern
+  # We need to save the changes as seen through read_attribute because
+  # the user sees attributes through the read_attribute getters.
+  # But we want to detect changes based on @_attributes to track
+  # things like undefined -> nil. Going through the getters will
+  # not give us that.
 
-  # We are not using ActiveModel::Dirty because it's using
-  # 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.
-
-  included do
-    attr_accessor :previous_changes
-    after_save { clear_dirtiness }
+  def assign_attributes(attrs, options={})
+    clear_dirtiness if options[:pristine]
+    super
   end
 
-  def changed_attributes
-    @changed_attributes ||= {}
+  def _create(*args)
+    super.tap { clear_dirtiness }
   end
 
-  def _assign_attributes(attrs, options={})
-    super
-    clear_dirtiness if options[:pristine]
+  def _update(*args)
+    super.tap { clear_dirtiness }
   end
 
   def clear_dirtiness
-    self.previous_changes = changes
-    self.changed_attributes.clear
+    @_old_attributes = {}.with_indifferent_access
+    @_old_attributes_keys = @_attributes.keys # to track undefined -> nil changes
   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.each do |attr, old_value|
+      current_value = read_attribute(attr)
+      if current_value != old_value || !@_old_attributes_keys.include?(attr)
+        result[attr] = [old_value, current_value]
+      end
+    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.has_key?(attr)
+      @_old_attributes[attr] = current_value.deep_dup
+    end
   end
 
   module ClassMethods
-    def field(name, options={})
+    def _field(attr, options={})
       super
-
-      inject_in_layer :dirty_tracking, <<-RUBY, __FILE__, __LINE__ + 1
-        def #{name}_changed?
-          changed_attributes.include?(:#{name})
+      attr = attr.to_s
+
+      inject_in_layer :dirty_tracking do
+        define_method("#{attr}_change") do
+          if @_old_attributes.has_key?(attr)
+            result = [@_old_attributes[attr], read_attribute(attr)]
+            result if result.first != result.last || !@_old_attributes_keys.include?(attr)
+          end
         end
 
-        def #{name}_change
-          [changed_attributes[:#{name}], #{name}] if #{name}_changed?
+        define_method("#{attr}_changed?") do
+          !!__send__("#{attr}_change")
         end
 
-        def #{name}_was
-          #{name}_changed? ? changed_attributes[:#{name}] : #{name}
+        define_method("#{attr}_was") do
+          @_old_attributes.has_key?(attr) ? @_old_attributes[attr] : read_attribute(attr)
         end
 
-        def #{name}=(value)
-          attribute_will_change!(:#{name}, value)
-          super
+        define_method("#{attr}") do
+          super().tap do |value|
+            # This take care of string/arrays/hashes that could change without going
+            # through the setter.
+            attribute_may_change(attr, 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("#{attr}=") do |value|
+          attribute_may_change(attr, read_attribute(attr))
+          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 }, :readonly => true
   end
 
   def ==(other)

data/lib/no_brainer/document/index.rb

@@ -41,29 +41,22 @@ module NoBrainer::Document::Index
       !!indexes[name.to_sym]
     end
 
-    def field(name, options={})
-      name = name.to_sym
-
-      if has_index?(name) && indexes[name][:kind] != :single
-        raise "Cannot reuse index name #{name}"
+    def _field(attr, options={})
+      if has_index?(attr) && indexes[attr][:kind] != :single
+        raise "Cannot reuse index attr #{attr}"
       end
 
       super
 
       case options[:index]
       when nil    then
-      when Hash   then index(name, options[:index])
-      when Symbol then index(name, options[:index] => true)
-      when true   then index(name)
-      when false  then remove_index(name)
+      when Hash   then index(attr, options[:index])
+      when Symbol then index(attr, options[:index] => true)
+      when true   then index(attr)
+      when false  then remove_index(attr)
       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/injection_layer.rb

@@ -2,10 +2,9 @@ module NoBrainer::Document::InjectionLayer
   extend ActiveSupport::Concern
 
   module ClassMethods
-    def inject_in_layer(name, code=nil, file=nil, line=nil, &block)
+    def inject_in_layer(name, &block)
       mod = class_eval "module NoBrainerLayer; module #{name.to_s.camelize}; self; end; end"
-      mod.module_eval(code, file, line) if code
-      mod.module_exec(&block) if block
+      mod.module_exec(&block)
       include mod
     end
   end

data/lib/no_brainer/document/persistance.rb

@@ -6,10 +6,9 @@ module NoBrainer::Document::Persistance
     define_model_callbacks :create, :update, :save, :destroy, :terminator => 'false'
   end
 
-  # TODO after_initialize, after_find callback
-  def initialize(attrs={}, options={})
-    super
+  def _initialize(attrs={}, options={})
     @new_record = !options[:from_db]
+    super
   end
 
   def new_record?
@@ -25,56 +24,43 @@ 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
+  def _update(attrs)
+    selector.update_all(attrs)
   end
 
-  def replace(options={}, &block)
-    run_callbacks :update do
-      if options[:validate] && !valid?
-        false
-      else
-        selector.replace_all(&block)
-        true
-      end
-    end
+  def _update_only_changed_attrs(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.
+    attrs = Hash[self.changed.map do |k|
+      attr = @_attributes[k]
+      # If we have a hash to save, we need to specify r.literal(),
+      # otherwise, the hash would just get merged with the existing one.
+      attr = RethinkDB::RQL.new.literal(attr) if attr.is_a?(Hash)
+      [k, attr]
+    end]
+    _update(attrs) if 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_only_changed_attrs(options)
   end
 
   def save!(*args)
@@ -95,12 +81,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/readonly.rb

@@ -0,0 +1,19 @@
+module NoBrainer::Document::Readonly
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def _field(attr, options={})
+      super
+      inject_in_layer :readonly do
+        if options[:readonly]
+          define_method("#{attr}=") do |value|
+            raise NoBrainer::Error::ReadonlyField.new("#{attr} is readonly") unless new_record?
+            super(value)
+          end
+        else
+          remove_method("#{attr}=") if method_defined?("#{attr}=")
+        end
+      end
+    end
+  end
+end

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,17 @@ 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
+  end
 
-    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=) }
+  def _create(options={})
+    self.created_at = self.updated_at = Time.now
+    super
   end
 
-  module ClassMethods
-    def disable_timestamps
-      self.remove_field :created_at
-      self.remove_field :updated_at
-    end
+  def _update(attrs)
+    self.updated_at = Time.now
+    super(attrs.merge('updated_at' => @_attributes['updated_at']))
   end
 end