openlogic-couchrest_model 1.0.0

data/lib/couchrest/model/dirty.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+I18n.load_path << File.join(
+  File.dirname(__FILE__), "validations", "locale", "en.yml"
+)
+
+module CouchRest
+  module Model
+
+    # This applies to both Model::Base and Model::CastedModel
+    module Dirty
+      extend ActiveSupport::Concern
+      include ActiveModel::Dirty
+
+      included do
+        # internal dirty setting - overrides global setting.
+        # this is used to temporarily disable dirty tracking when setting 
+        # attributes directly, for performance reasons.
+        self.send(:attr_accessor, :disable_dirty)
+      end
+
+      def use_dirty?
+        doc = base_doc
+        doc && !doc.disable_dirty
+      end
+
+      def couchrest_attribute_will_change!(attr)
+        return if attr.nil? || !use_dirty?
+        attribute_will_change!(attr)
+        couchrest_parent_will_change!
+      end
+
+      def couchrest_parent_will_change!
+        casted_by.couchrest_attribute_will_change!(casted_by_property.name) if casted_by_property
+      end
+
+    end
+  end
+end

data/lib/couchrest/model/document_queries.rb

@@ -0,0 +1,99 @@
+module CouchRest
+  module Model
+    module DocumentQueries
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        # Load all documents that have the model_type_key's field equal to the
+        # name of the current class. Take the standard set of
+        # CouchRest::Database#view options.
+        def all(opts = {}, &block)
+          view(:all, opts, &block)
+        end
+        
+        # Returns the number of documents that have the model_type_key's field
+        # equal to the name of the current class. Takes the standard set of 
+        # CouchRest::Database#view options
+        def count(opts = {}, &block)
+          all({:raw => true, :limit => 0}.merge(opts), &block)['total_rows']
+        end
+        
+        # Load the first document that have the model_type_key's field equal to
+        # the name of the current class.
+        #
+        # ==== Returns
+        # Object:: The first object instance available
+        # or
+        # Nil:: if no instances available
+        #
+        # ==== Parameters
+        # opts<Hash>::
+        # View options, see <tt>CouchRest::Database#view</tt> options for more info.
+        def first(opts = {})
+          first_instance = self.all(opts.merge!(:limit => 1))
+          first_instance.empty? ? nil : first_instance.first
+        end
+        
+        # Load the last document that have the model_type_key's field equal to
+        # the name of the current class.
+        # It's similar to method first, just adds :descending => true
+        #
+        # ==== Returns
+        # Object:: The last object instance available
+        # or
+        # Nil:: if no instances available
+        #
+        # ==== Parameters
+        # opts<Hash>::
+        # View options, see <tt>CouchRest::Database#view</tt> options for more info.
+        def last(opts = {})
+          first(opts.merge!(:descending => true))
+        end
+        
+        # Load a document from the database by id
+        # No exceptions will be raised if the document isn't found
+        #
+        # ==== Returns
+        # Object:: if the document was found
+        # or
+        # Nil::
+        # 
+        # === Parameters
+        # id<String, Integer>:: Document ID
+        # db<Database>:: optional option to pass a custom database to use
+        def get(id, db = database)
+          begin
+            get!(id, db)
+          rescue
+            nil
+          end
+        end
+        alias :find :get
+
+        # Load a document from the database by id
+        # An exception will be raised if the document isn't found
+        #
+        # ==== Returns
+        # Object:: if the document was found
+        # or
+        # Exception
+        # 
+        # === Parameters
+        # id<String, Integer>:: Document ID
+        # db<Database>:: optional option to pass a custom database to use
+        def get!(id, db = database)
+          raise CouchRest::Model::DocumentNotFound if id.blank?
+
+          doc = db.get id
+          build_from_database(doc)
+        rescue RestClient::ResourceNotFound
+          raise CouchRest::Model::DocumentNotFound
+        end
+        alias :find! :get!
+        
+      end
+      
+    end
+  end
+end

data/lib/couchrest/model/embeddable.rb

@@ -0,0 +1,78 @@
+module CouchRest::Model
+  module Embeddable
+    extend ActiveSupport::Concern
+
+    # Include Attributes early to ensure super() will work
+    include CouchRest::Attributes
+
+    included do
+      include CouchRest::Model::Configuration
+      include CouchRest::Model::Properties
+      include CouchRest::Model::PropertyProtection
+      include CouchRest::Model::Associations
+      include CouchRest::Model::Validations
+      include CouchRest::Model::Callbacks
+      include CouchRest::Model::CastedBy
+      include CouchRest::Model::Dirty
+      include CouchRest::Model::Callbacks
+
+      class_eval do
+        # Override CastedBy's base_doc?
+        def base_doc?
+          false # Can never be base doc!
+        end
+
+      end
+    end
+
+    # Initialize a new Casted Model. Accepts the same
+    # options as CouchRest::Model::Base for preparing and initializing
+    # attributes.
+    def initialize(keys = {}, options = {})
+      super()
+      prepare_all_attributes(keys, options)
+      run_callbacks(:initialize) { self }
+    end
+
+    # False if the casted model has already
+    # been saved in the containing document
+    def new?
+      casted_by.nil? ? true : casted_by.new?
+    end
+    alias :new_record? :new?
+
+    def persisted?
+      !new?
+    end
+
+    # The to_param method is needed for rails to generate resourceful routes.
+    # In your controller, remember that it's actually the id of the document.
+    def id
+      return nil if base_doc.nil?
+      base_doc.id
+    end
+    alias :to_key :id
+    alias :to_param :id
+
+    # Sets the attributes from a hash
+    def update_attributes_without_saving(hash)
+      hash.each do |k, v|
+        raise NoMethodError, "#{k}= method not available, use property :#{k}" unless self.respond_to?("#{k}=")
+      end      
+      hash.each do |k, v|
+        self.send("#{k}=",v)
+      end
+    end
+    alias :attributes= :update_attributes_without_saving
+
+  end # End Embeddable
+
+  # Provide backwards compatability with previous versions (pre 1.1.0)
+  module CastedModel
+    extend ActiveSupport::Concern
+    included do
+      include CouchRest::Model::Embeddable
+    end
+  end
+
+end

data/lib/couchrest/model/errors.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module CouchRest
+  module Model
+    module Errors
+
+      class CouchRestModelError < StandardError; end
+
+      # Raised when a persisence method ending in ! fails validation. The message
+      # will contain the full error messages from the +Document+ in question.
+      #
+      # Example:
+      #
+      # <tt>Validations.new(person.errors)</tt>
+      class Validations < CouchRestModelError
+        attr_reader :document
+        def initialize(document)
+          @document = document
+          super("Validation Failed: #{@document.errors.full_messages.join(", ")}")
+        end
+      end
+    end
+
+    class DocumentNotFound < Errors::CouchRestModelError; end
+  end
+end

data/lib/couchrest/model/extended_attachments.rb

@@ -0,0 +1,83 @@
+module CouchRest
+  module Model
+    module ExtendedAttachments
+      extend ActiveSupport::Concern
+
+      # Add a file attachment to the current document. Expects
+      # :file and :name to be included in the arguments.
+      def create_attachment(args={})
+        raise ArgumentError unless args[:file] && args[:name]
+        return if has_attachment?(args[:name])
+        set_attachment_attr(args)
+      rescue ArgumentError => e
+        raise ArgumentError, 'You must specify :file and :name'
+      end
+      
+      # return all attachments
+      def attachments
+        self['_attachments'] ||= {}
+      end
+
+      # reads the data from an attachment
+      def read_attachment(attachment_name)
+        database.fetch_attachment(self, attachment_name)
+      end
+
+      # modifies a file attachment on the current doc
+      def update_attachment(args={})
+        raise ArgumentError unless args[:file] && args[:name]
+        return unless has_attachment?(args[:name])
+        delete_attachment(args[:name])
+        set_attachment_attr(args)
+      rescue ArgumentError => e
+        raise ArgumentError, 'You must specify :file and :name'
+      end
+
+      # deletes a file attachment from the current doc
+      def delete_attachment(attachment_name)
+        return unless attachments
+        if attachments.include?(attachment_name)
+          attribute_will_change!("_attachments")
+          attachments.delete attachment_name
+        end
+      end
+
+      # returns true if attachment_name exists
+      def has_attachment?(attachment_name)
+        !!(attachments && attachments[attachment_name] && !attachments[attachment_name].empty?)
+      end
+
+      # returns URL to fetch the attachment from
+      def attachment_url(attachment_name)
+        return unless has_attachment?(attachment_name)
+        "#{database.root}/#{self.id}/#{attachment_name}"
+      end
+      
+      # returns URI to fetch the attachment from
+      def attachment_uri(attachment_name)
+        return unless has_attachment?(attachment_name)
+        "#{database.uri}/#{self.id}/#{attachment_name}"
+      end
+      
+      private
+      
+        def get_mime_type(path)
+          return nil if path.nil?
+          type = ::MIME::Types.type_for(path)
+          type.empty? ? nil : type.first.content_type
+        end
+
+        def set_attachment_attr(args)
+          content_type = args[:content_type] ? args[:content_type] : get_mime_type(args[:file].path)
+          content_type ||= (get_mime_type(args[:name]) || 'text/plain')
+
+          attribute_will_change!("_attachments")
+          attachments[args[:name]] = {
+            'content_type' => content_type,
+            'data'         => args[:file].read
+          }
+        end
+      
+    end # module ExtendedAttachments
+  end
+end

data/lib/couchrest/model/persistence.rb

@@ -0,0 +1,178 @@
+module CouchRest
+  module Model
+    module Persistence
+      extend ActiveSupport::Concern
+
+      # Create the document. Validation is enabled by default and will return
+      # false if the document is not valid. If all goes well, the document will
+      # be returned.
+      def create(options = {})
+        return false unless perform_validations(options)
+        _run_create_callbacks do
+          _run_save_callbacks do
+            set_unique_id if new? && self.respond_to?(:set_unique_id)
+            result = database.save_doc(self)
+            ret = (result["ok"] == true) ? self : false
+            @changed_attributes.clear if ret && @changed_attributes
+            ret
+          end
+        end
+      end
+
+      # Creates the document in the db. Raises an exception
+      # if the document is not created properly.
+      def create!(options = {})
+        self.class.fail_validate!(self) unless self.create(options)
+      end
+
+      # Trigger the callbacks (before, after, around)
+      # only if the document isn't new
+      def update(options = {})
+        raise "Cannot save a destroyed document!" if destroyed?
+        raise "Calling #{self.class.name}#update on document that has not been created!" if new?
+        return false unless perform_validations(options)
+        return true if !self.disable_dirty && !self.changed?
+        _run_update_callbacks do
+          _run_save_callbacks do
+            result = database.save_doc(self)
+            ret = result["ok"] == true
+            @changed_attributes.clear if ret && @changed_attributes
+            ret
+          end
+        end
+      end
+
+      # Trigger the callbacks (before, after, around) and save the document
+      def save(options = {})
+        self.new? ? create(options) : update(options)
+      end
+
+      # Saves the document to the db using save. Raises an exception
+      # if the document is not saved properly.
+      def save!
+        self.class.fail_validate!(self) unless self.save
+        true
+      end
+
+      # Deletes the document from the database. Runs the :destroy callbacks.
+      def destroy
+        _run_destroy_callbacks do
+          result = database.delete_doc(self)
+          if result['ok']
+            @_destroyed = true
+            self.freeze
+          end
+          result['ok']
+        end
+      end
+
+      def destroyed?
+        !!@_destroyed
+      end
+
+      def persisted?
+        !new? && !destroyed?
+      end
+
+      # Update the document's attributes and save. For example:
+      #
+      #   doc.update_attributes :name => "Fred"
+      # Is the equivilent of doing the following:
+      #
+      #   doc.attributes = { :name => "Fred" }
+      #   doc.save
+      #
+      def update_attributes(hash)
+        update_attributes_without_saving hash
+        save
+      end
+
+      # Reloads the attributes of this object from the database.
+      # It doesn't override custom instance variables.
+      #
+      # Returns self.
+      def reload
+        prepare_all_attributes(database.get(id), :directly_set_attributes => true)
+        self
+      end
+
+      protected
+
+      def perform_validations(options = {})
+        perform_validation = case options
+        when Hash
+          options[:validate] != false
+        else
+          options
+        end
+        perform_validation ? valid? : true
+      end
+
+
+      module ClassMethods
+
+        # Creates a new instance, bypassing attribute protection and
+        # uses the type field to determine which model to use to instanatiate
+        # the new object.
+        #
+        # ==== Returns
+        #  a document instance
+        #
+        def build_from_database(doc = {}, options = {}, &block)
+          src = doc[model_type_key]
+          base = (src.blank? || src == self.to_s) ? self : src.constantize
+          base.new(doc, options.merge(:directly_set_attributes => true), &block)
+        end
+
+        # Defines an instance and save it directly to the database
+        #
+        # ==== Returns
+        #  returns the reloaded document
+        def create(attributes = {}, &block)
+          instance = new(attributes, &block)
+          instance.create
+          instance
+        end
+
+        # Defines an instance and save it directly to the database
+        #
+        # ==== Returns
+        #  returns the reloaded document or raises an exception
+        def create!(attributes = {}, &block)
+          instance = new(attributes, &block)
+          instance.create!
+          instance
+        end
+
+        # Name a method that will be called before the document is first saved,
+        # which returns a string to be used for the document's <tt>_id</tt>.
+        #
+        # Because CouchDB enforces a constraint that each id must be unique,
+        # this can be used to enforce eg: uniq usernames. Note that this id
+        # must be globally unique across all document types which share a
+        # database, so if you'd like to scope uniqueness to this class, you
+        # should use the class name as part of the unique id.
+        def unique_id(method = nil, &block)
+          if method
+            define_method :set_unique_id do
+              self['_id'] ||= self.send(method)
+            end
+          elsif block
+            define_method :set_unique_id do
+              uniqid = block.call(self)
+              raise ArgumentError, "unique_id block must not return nil" if uniqid.nil?
+              self['_id'] ||= uniqid
+            end
+          end
+        end
+
+        # Raise an error if validation failed.
+        def fail_validate!(document)
+          raise Errors::Validations.new(document)
+        end
+      end
+
+
+    end
+  end
+end