mongomodel 0.1

data/lib/mongomodel/concerns/attribute_methods.rb

@@ -0,0 +1,55 @@
+module MongoModel
+  module AttributeMethods
+    extend ActiveSupport::Concern
+    
+    include ActiveModel::AttributeMethods
+    
+    module ClassMethods
+      # Generates all the attribute related methods for defined properties
+      # accessors, mutators and query methods.
+      def define_attribute_methods
+        super(properties.keys)
+      end
+      
+      def property(*args)
+        property = super
+        undefine_attribute_methods
+        property
+      end
+    end
+    
+    def method_missing(method_id, *args, &block)
+      # If we haven't generated any methods yet, generate them, then
+      # see if we've created the method we're looking for.
+      unless self.class.attribute_methods_generated?
+        self.class.define_attribute_methods
+        method_name = method_id.to_s
+        
+        guard_private_attribute_method!(method_name, args)
+        
+        if self.class.generated_attribute_methods.method_defined?(method_name)
+          return self.send(method_id, *args, &block)
+        end
+      end
+      
+      super
+    end
+    
+    def respond_to?(*args)
+      self.class.define_attribute_methods
+      super
+    end
+    
+    def clone_attribute_value(attribute_name)
+      value = read_attribute(attribute_name)
+      value.duplicable? ? value.clone : value
+    rescue TypeError, NoMethodError
+      value
+    end
+    
+  protected
+    def attribute_method?(attr_name)
+      properties.has_key?(attr_name)
+    end
+  end
+end

data/lib/mongomodel/concerns/attribute_methods/before_type_cast.rb

@@ -0,0 +1,29 @@
+module MongoModel
+  module AttributeMethods
+    module BeforeTypeCast
+      extend ActiveSupport::Concern
+      
+      included do
+        attribute_method_suffix "_before_type_cast"
+      end
+      
+      # Returns an attribute value before typecasting.
+      def read_attribute_before_type_cast(name)
+        attributes.before_type_cast(name.to_sym)
+      end
+      
+      # Returns a hash of attributes before typecasting.
+      def attributes_before_type_cast
+        attributes.keys.inject({}) do |result, key|
+          result[key] = attributes.before_type_cast(key)
+          result
+        end
+      end
+      
+    private
+      def attribute_before_type_cast(attribute_name)
+        read_attribute_before_type_cast(attribute_name)
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/attribute_methods/dirty.rb

@@ -0,0 +1,35 @@
+module MongoModel
+  module AttributeMethods
+    module Dirty
+      extend ActiveSupport::Concern
+      
+      include ActiveModel::Dirty
+      
+      included do
+        after_save { changed_attributes.clear }
+      end
+      
+      # Returns the attributes as they were before any changes were made to the document.
+      def original_attributes
+        attributes.merge(changed_attributes)
+      end
+      
+      # Wrap write_attribute to remember original attribute value.
+      def write_attribute(attr, value)
+        attr = attr.to_sym
+          
+        # The attribute already has an unsaved change.
+        if changed_attributes.include?(attr)
+          old = changed_attributes[attr]
+          changed_attributes.delete(attr) if value == old
+        else
+          old = clone_attribute_value(attr)
+          changed_attributes[attr] = old unless value == old
+        end
+        
+        # Carry on.
+        super
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/attribute_methods/protected.rb

@@ -0,0 +1,127 @@
+module MongoModel
+  module AttributeMethods
+    module Protected
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def property(name, *args, &block)#:nodoc:
+            property = super(name, *args, &block)
+
+            attr_protected(name) if property.options[:protected]
+            attr_accessible(name) if property.options[:accessible]
+            
+            property
+          end
+
+          # Attributes named in this macro are protected from mass-assignment,
+          # such as <tt>new(attributes)</tt>,
+          # <tt>update_attributes(attributes)</tt>, or
+          # <tt>attributes=(attributes)</tt>.
+          #
+          # Mass-assignment to these attributes will simply be ignored, to assign
+          # to them you can use direct writer methods. This is meant to protect
+          # sensitive attributes from being overwritten by malicious users
+          # tampering with URLs or forms.
+          #
+          #   class Customer < Recliner::Document
+          #     attr_protected :credit_rating
+          #   end
+          #
+          #   customer = Customer.new("name" => David, "credit_rating" => "Excellent")
+          #   customer.credit_rating # => nil
+          #   customer.attributes = { "description" => "Jolly fellow", "credit_rating" => "Superb" }
+          #   customer.credit_rating # => nil
+          #
+          #   customer.credit_rating = "Average"
+          #   customer.credit_rating # => "Average"
+          #
+          # To start from an all-closed default and enable attributes as needed,
+          # have a look at +attr_accessible+.
+          #
+          # If the access logic of your application is richer you can use <tt>Hash#except</tt>
+          # or <tt>Hash#slice</tt> to sanitize the hash of parameters before they are
+          # passed to Recliner.
+          # 
+          # For example, it could be the case that the list of protected attributes
+          # for a given model depends on the role of the user:
+          #
+          #   # Assumes plan_id is not protected because it depends on the role.
+          #   params[:account] = params[:account].except(:plan_id) unless admin?
+          #   @account.update_attributes(params[:account])
+          #
+          # Note that +attr_protected+ is still applied to the received hash. Thus,
+          # with this technique you can at most _extend_ the list of protected
+          # attributes for a particular mass-assignment call.
+          def attr_protected(*attrs)
+            write_inheritable_attribute(:attr_protected, attrs.map { |a| a.to_s } + protected_attributes)
+          end
+
+          # Specifies a white list of model attributes that can be set via
+          # mass-assignment, such as <tt>new(attributes)</tt>,
+          # <tt>update_attributes(attributes)</tt>, or
+          # <tt>attributes=(attributes)</tt>
+          #
+          # This is the opposite of the +attr_protected+ macro: Mass-assignment
+          # will only set attributes in this list, to assign to the rest of
+          # attributes you can use direct writer methods. This is meant to protect
+          # sensitive attributes from being overwritten by malicious users
+          # tampering with URLs or forms. If you'd rather start from an all-open
+          # default and restrict attributes as needed, have a look at
+          # +attr_protected+.
+          #
+          #   class Customer < Recliner::Document
+          #     attr_accessible :name, :nickname
+          #   end
+          #
+          #   customer = Customer.new(:name => "David", :nickname => "Dave", :credit_rating => "Excellent")
+          #   customer.credit_rating # => nil
+          #   customer.attributes = { :name => "Jolly fellow", :credit_rating => "Superb" }
+          #   customer.credit_rating # => nil
+          #
+          #   customer.credit_rating = "Average"
+          #   customer.credit_rating # => "Average"
+          #
+          # If the access logic of your application is richer you can use <tt>Hash#except</tt>
+          # or <tt>Hash#slice</tt> to sanitize the hash of parameters before they are
+          # passed to Recliner.
+          # 
+          # For example, it could be the case that the list of accessible attributes
+          # for a given model depends on the role of the user:
+          #
+          #   # Assumes plan_id is accessible because it depends on the role.
+          #   params[:account] = params[:account].except(:plan_id) unless admin?
+          #   @account.update_attributes(params[:account])
+          #
+          # Note that +attr_accessible+ is still applied to the received hash. Thus,
+          # with this technique you can at most _narrow_ the list of accessible
+          # attributes for a particular mass-assignment call.
+          def attr_accessible(*attrs)
+            write_inheritable_attribute(:attr_accessible, attrs.map { |a| a.to_s } + accessible_attributes)
+          end
+
+          # Returns an array of all the attributes that have been protected from mass-assignment.
+          def protected_attributes
+            read_inheritable_attribute(:attr_protected) || []
+          end
+
+          # Returns an array of all the attributes that have been made accessible to mass-assignment.
+          def accessible_attributes
+            read_inheritable_attribute(:attr_accessible) || []
+          end
+        end
+
+        def attributes=(attrs)#:nodoc:
+          super(remove_protected_attributes(attrs))
+        end
+
+      private
+        def remove_protected_attributes(attrs)
+          if self.class.accessible_attributes.empty?
+            attrs.reject { |k, v| self.class.protected_attributes.include?(k.to_s) }
+          else
+            attrs.reject { |k, v| !self.class.accessible_attributes.include?(k.to_s) }
+          end
+        end
+    end
+  end
+end

data/lib/mongomodel/concerns/attribute_methods/query.rb

@@ -0,0 +1,22 @@
+module MongoModel
+  module AttributeMethods
+    module Query
+      extend ActiveSupport::Concern
+      
+      included do
+        attribute_method_suffix "?"
+      end
+      
+      # Returns true if the attribute is not blank (i.e. it has some value). Otherwise returns false.
+      def query_attribute(name)
+        attributes.has?(name.to_sym)
+      end
+      
+    private
+      # Handle *? for method_missing.
+      def attribute?(attribute_name)
+        query_attribute(attribute_name)
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/attribute_methods/read.rb

@@ -0,0 +1,29 @@
+module MongoModel
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
+      
+      included do
+        attribute_method_suffix ""
+      end
+      
+      # Returns the value of the attribute identified by +name+ after it has been typecast (for example,
+      # "2004-12-12" in a date property is cast to a date object, like Date.new(2004, 12, 12)).
+      def read_attribute(name)
+        attributes[name.to_sym]
+      end
+      
+      # Returns the value of the attribute identified by <tt>name</tt> after it has been typecast (for example,
+      # "2004-12-12" in a date property is cast to a date object, like Date.new(2004, 12, 12)).
+      # (Alias for read_attribute).
+      def [](name)
+        read_attribute(name)
+      end
+    
+    private
+      def attribute(attribute_name)
+        read_attribute(attribute_name)
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/attribute_methods/write.rb

@@ -0,0 +1,29 @@
+module MongoModel
+  module AttributeMethods
+    module Write
+      extend ActiveSupport::Concern
+      
+      included do
+        attribute_method_suffix "="
+      end
+      
+      # Updates the attribute identified by <tt>name</tt> with the specified +value+.
+      # Values are typecast to the appropriate type determined by the property.
+      def write_attribute(name, value)
+        attributes[name.to_sym] = value
+      end
+      
+      # Updates the attribute identified by <tt>name</tt> with the specified +value+.
+      # (Alias for the protected write_attribute method).
+      def []=(name, value)
+        write_attribute(name, value)
+      end
+      
+    private
+      # Handle *= for method_missing.
+      def attribute=(attribute_name, value)
+        write_attribute(attribute_name, value)
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/attributes.rb

@@ -0,0 +1,85 @@
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/class/removal'
+
+module MongoModel
+  module Attributes
+    extend ActiveSupport::Concern
+    
+    included do
+      alias_method_chain :initialize, :attributes
+    end
+    
+    def initialize_with_attributes(attrs={})
+      initialize_without_attributes
+      
+      self.attributes = attrs
+      yield self if block_given?
+    end
+    
+    def attributes
+      @attributes ||= Attributes::Store.new(self)
+    end
+    
+    def attributes=(attrs)
+      attrs.each do |attr, value|
+        if respond_to?("#{attr}=")
+          send("#{attr}=", value)
+        else
+          write_attribute(attr, value)
+        end
+      end
+    end
+    
+    def freeze
+      attributes.freeze; self
+    end
+    
+    def frozen?
+      attributes.frozen?
+    end
+    
+    # Returns duplicated record with unfreezed attributes.
+    def dup
+      obj = super
+      obj.instance_variable_set('@attributes', instance_variable_get('@attributes').dup)
+      obj
+    end
+    
+    def to_mongo
+      attributes.to_mongo
+    end
+    
+    def embedded_documents
+      docs = []
+      
+      docs.concat attributes.values.select { |attr| attr.is_a?(EmbeddedDocument) }
+      
+      attributes.values.select { |attr| attr.is_a?(Collection) }.each do |collection|
+        docs.concat collection.embedded_documents
+      end
+      
+      docs
+    end
+    
+    module ClassMethods
+      def from_mongo(hash)
+        doc = class_for_type(hash['_type']).new
+        doc.attributes.from_mongo!(hash)
+        doc
+      end
+    
+    private
+      def class_for_type(type)
+        type = type.constantize
+        
+        if (subclasses + [name]).include?(type.to_s)
+          type
+        else
+          raise DocumentNotFound, "Document not of the correct type (got #{type.to_s})"
+        end
+      rescue NameError
+        self
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/callbacks.rb

@@ -0,0 +1,294 @@
+require 'active_support/core_ext/module/aliasing'
+
+module MongoModel
+  # Callbacks are hooks into the lifecycle of a MongoModel object that allow you to trigger logic
+  # before or after an alteration of the object state. This can be used to make sure that associated and
+  # dependent objects are deleted when +destroy+ is called (by overwriting +before_destroy+) or to massage attributes
+  # before they're validated (by overwriting +before_validation+). As an example of the callbacks initiated, consider
+  # the <tt>Document#save</tt> call for a new document:
+  #
+  # * (-) <tt>save</tt>
+  # * (-) <tt>valid</tt>
+  # * (1) <tt>before_validation</tt>
+  # * (-) <tt>validate</tt>
+  # * (-) <tt>validate_on_create</tt>
+  # * (2) <tt>after_validation</tt>
+  # * (3) <tt>before_save</tt>
+  # * (4) <tt>before_create</tt>
+  # * (-) <tt>create</tt>
+  # * (5) <tt>after_create</tt>
+  # * (6) <tt>after_save</tt>
+  #
+  # That's a total of eight callbacks, which gives you immense power to react and prepare for each state in the
+  # MongoModel lifecycle. The sequence for calling <tt>Document#save</tt> for an existing record is similar, except that each 
+  # <tt>_on_create</tt> callback is replaced by the corresponding <tt>_on_update</tt> callback.
+  #
+  # Examples:
+  #   class CreditCard < MongoModel::Document
+  #     # Strip everything but digits, so the user can specify "555 234 34" or
+  #     # "5552-3434" or both will mean "55523434"
+  #     def before_validation_on_create
+  #       self.number = number.gsub(/[^0-9]/, "") if number?
+  #     end
+  #   end
+  #
+  #   class Subscription < MongoModel::Document
+  #     before_create :record_signup
+  #
+  #     private
+  #       def record_signup
+  #         self.signed_up_on = Date.today
+  #       end
+  #   end
+  #
+  # == Inheritable callback queues
+  #
+  # Besides the overwritable callback methods, it's also possible to register callbacks through the use of the callback macros.
+  # Their main advantage is that the macros add behavior into a callback queue that is kept intact down through an inheritance
+  # hierarchy. Example:
+  #
+  #   class Topic < MongoModel::Document
+  #     before_destroy :destroy_author
+  #   end
+  #
+  #   class Reply < Topic
+  #     before_destroy :destroy_readers
+  #   end
+  #
+  # Now, when <tt>Topic#destroy</tt> is run only +destroy_author+ is called. When <tt>Reply#destroy</tt> is run, both +destroy_author+ and
+  # +destroy_readers+ are called. Contrast this to the situation where we've implemented the save behavior through overwriteable
+  # methods:
+  #
+  #   class Topic < MongoModel::Document
+  #     def before_destroy() destroy_author end
+  #   end
+  #
+  #   class Reply < Topic
+  #     def before_destroy() destroy_readers end
+  #   end
+  #
+  # In that case, <tt>Reply#destroy</tt> would only run +destroy_readers+ and _not_ +destroy_author+. So, use the callback macros when
+  # you want to ensure that a certain callback is called for the entire hierarchy, and use the regular overwriteable methods
+  # when you want to leave it up to each descendant to decide whether they want to call +super+ and trigger the inherited callbacks.
+  #
+  # *IMPORTANT:* In order for inheritance to work for the callback queues, you must specify the callbacks before specifying the
+  # associations. Otherwise, you might trigger the loading of a child before the parent has registered the callbacks and they won't
+  # be inherited.
+  #
+  # == Types of callbacks
+  #
+  # There are four types of callbacks accepted by the callback macros: Method references (symbol), callback objects,
+  # inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects are the
+  # recommended approaches, inline methods using a proc are sometimes appropriate (such as for creating mix-ins), and inline
+  # eval methods are deprecated.
+  #
+  # The method reference callbacks work by specifying a protected or private method available in the object, like this:
+  #
+  #   class Topic < MongoModel::Document
+  #     before_destroy :delete_parents
+  #
+  #     private
+  #       def delete_parents
+  #         self.class.delete_all "parent_id = #{id}"
+  #       end
+  #   end
+  #
+  # The callback objects have methods named after the callback called with the record as the only parameter, such as:
+  #
+  #   class BankAccount < MongoModel::Document
+  #     before_save      EncryptionWrapper.new
+  #     after_save       EncryptionWrapper.new
+  #     after_initialize EncryptionWrapper.new
+  #   end
+  #
+  #   class EncryptionWrapper
+  #     def before_save(doc)
+  #       doc.credit_card_number = encrypt(doc.credit_card_number)
+  #     end
+  #
+  #     def after_save(doc)
+  #       doc.credit_card_number = decrypt(doc.credit_card_number)
+  #     end
+  #
+  #     alias_method :after_load, :after_save
+  #
+  #     private
+  #       def encrypt(value)
+  #         # Secrecy is committed
+  #       end
+  #
+  #       def decrypt(value)
+  #         # Secrecy is unveiled
+  #       end
+  #   end
+  #
+  # So you specify the object you want messaged on a given callback. When that callback is triggered, the object has
+  # a method by the name of the callback messaged. You can make these callbacks more flexible by passing in other
+  # initialization data such as the name of the attribute to work with:
+  #
+  #   class BankAccount < MongoModel::Document
+  #     before_save      EncryptionWrapper.new("credit_card_number")
+  #     after_save       EncryptionWrapper.new("credit_card_number")
+  #     after_initialize EncryptionWrapper.new("credit_card_number")
+  #   end
+  #
+  #   class EncryptionWrapper
+  #     def initialize(attribute)
+  #       @attribute = attribute
+  #     end
+  #
+  #     def before_save(doc)
+  #       doc.send("#{@attribute}=", encrypt(doc.send("#{@attribute}")))
+  #     end
+  #
+  #     def after_save(record)
+  #       doc.send("#{@attribute}=", decrypt(doc.send("#{@attribute}")))
+  #     end
+  #
+  #     alias_method :after_load, :after_save
+  #
+  #     private
+  #       def encrypt(value)
+  #         # Secrecy is committed
+  #       end
+  #
+  #       def decrypt(value)
+  #         # Secrecy is unveiled
+  #       end
+  #   end
+  #
+  # The callback macros usually accept a symbol for the method they're supposed to run, but you can also pass a "method string",
+  # which will then be evaluated within the binding of the callback. Example:
+  #
+  #   class Topic < MongoModel::Document
+  #     before_destroy 'self.class.delete_all "parent_id = #{id}"'
+  #   end
+  #
+  # Notice that single quotes (') are used so the <tt>#{id}</tt> part isn't evaluated until the callback is triggered. Also note that these
+  # inline callbacks can be stacked just like the regular ones:
+  #
+  #   class Topic < MongoModel::Document
+  #     before_destroy 'self.class.delete_all "parent_id = #{id}"',
+  #                    'puts "Evaluated after parents are destroyed"'
+  #   end
+  #
+  # == The +after_find+ and +after_initialize+ exceptions
+  #
+  # Because +after_find+ and +after_initialize+ are called for each object found and instantiated by find, we've had
+  # to implement a simple performance constraint (50% more speed on a simple test case). Unlike all the other callbacks, +after_find+ and
+  # +after_initialize+ will only be run if an explicit implementation is defined (<tt>def after_find</tt>). In that case, all of the
+  # callback types will be called.
+  #
+  # == <tt>before_validation*</tt> returning statements
+  #
+  # If the returning value of a +before_validation+ callback can be evaluated to +false+, the process will be aborted and <tt>Document#save</tt> will return +false+.
+  # If Document#save! is called it will raise a MongoModel::DocumentInvalid exception.
+  # Nothing will be appended to the errors object.
+  #
+  # == Canceling callbacks
+  #
+  # If a <tt>before_*</tt> callback returns +false+, all the later callbacks and the associated action are cancelled. If an <tt>after_*</tt> callback returns
+  # +false+, all the later callbacks are cancelled. Callbacks are generally run in the order they are defined, with the exception of callbacks
+  # defined as methods on the model, which are called last.
+  module Callbacks
+    extend ActiveSupport::Concern
+    
+    include ActiveSupport::Callbacks
+
+    CALLBACKS = [
+      :after_initialize, :after_find, :before_validation, :after_validation,
+      :before_save, :around_save, :after_save, :before_create, :around_create,
+      :after_create, :before_update, :around_update, :after_update,
+      :before_destroy, :around_destroy, :after_destroy
+    ]
+
+    included do
+      [:initialize, :valid?].each do |method|
+        alias_method_chain method, :callbacks
+      end
+      
+      define_callbacks :initialize, :find, :save, :create, :update, :destroy,
+                       :validation, :terminator => "result == false", :scope => [:kind, :name]
+    end
+    
+    module ClassMethods
+      def after_initialize(*args, &block)
+        options = args.extract_options!
+        options[:prepend] = true
+        set_callback(:initialize, :after, *(args << options), &block)
+      end
+
+      def after_find(*args, &block)
+        options = args.extract_options!
+        options[:prepend] = true
+        set_callback(:find, :after, *(args << options), &block)
+      end
+
+      [:save, :create, :update, :destroy].each do |callback|
+        module_eval <<-CALLBACKS, __FILE__, __LINE__
+          def before_#{callback}(*args, &block)
+            set_callback(:#{callback}, :before, *args, &block)
+          end
+
+          def around_#{callback}(*args, &block)
+            set_callback(:#{callback}, :around, *args, &block)
+          end
+
+          def after_#{callback}(*args, &block)
+            options = args.extract_options!
+            options[:prepend] = true
+            options[:if] = Array(options[:if]) << "!halted && value != false"
+            set_callback(:#{callback}, :after, *(args << options), &block)
+          end
+        CALLBACKS
+      end
+
+      def before_validation(*args, &block)
+        options = args.extract_options!
+        if options[:on]
+          options[:if] = Array(options[:if])
+          options[:if] << "@_on_validate == :#{options[:on]}"
+        end
+        set_callback(:validation, :before, *(args << options), &block)
+      end
+
+      def after_validation(*args, &block)
+        options = args.extract_options!
+        options[:if] = Array(options[:if])
+        options[:if] << "!halted"
+        options[:if] << "@_on_validate == :#{options[:on]}" if options[:on]
+        options[:prepend] = true
+        set_callback(:validation, :after, *(args << options), &block)
+      end
+    end
+    
+    def initialize_with_callbacks(*args, &block) #:nodoc:
+      initialize_without_callbacks(*args, &block)
+      run_callbacks_with_embedded(:initialize)
+    end
+    
+    def valid_with_callbacks? #:nodoc:
+      @_on_validate = new_record? ? :create : :update
+      run_callbacks(:validation) do
+        valid_without_callbacks?
+      end
+    end
+    
+    def run_callbacks_with_embedded(kind, *args, &block)
+      if block_given?
+        embedded_callbacks = nest_embedded_callbacks(kind, *args, &block)
+        run_callbacks(kind, *args, &embedded_callbacks)
+      else
+        run_callbacks(kind, *args)
+        embedded_documents.each { |doc| doc.run_callbacks(kind, *args) } unless kind == :initialize
+      end
+    end
+  
+  private
+    def nest_embedded_callbacks(kind, *args, &block)
+      embedded_documents.inject(block) do |block, doc|
+        Proc.new { doc.run_callbacks(kind, *args, &block) }
+      end
+    end
+  end
+end