samlown-couchrest_extended_document 1.0.0

data/history.txt

@@ -0,0 +1,130 @@
+== Next Version
+
+* Major enhancements
+
+* Minor enhancements
+
+== 0.4.0
+
+* Major enhancements
+  * Separated ExtendedDocument from main CouchRest gem (Sam Lown)
+
+== 0.37
+
+* Minor enhancements
+  * Added gemspec (needed for Bundler install) (Tapajós)
+
+== 0.36
+
+* Major enhancements
+  * Adds support for continuous replication (sauy7)
+  * Automatic Type Casting (Alexander Uvarov, Sam Lown, Tim Heighes, Will Leinweber)
+  * Added a search method to CouchRest:Database to search the documents in a given database. (Dave Farkas, Arnaud Berthomier, John Wood)
+  
+* Minor enhancements
+  * Provide a description of the timeout error (John Wood)
+
+== 0.35
+
+* Major enhancements
+  * CouchRest::ExtendedDocument allow chaining the inherit class callback (Kenneth Kalmer) - http://github.com/couchrest/couchrest/issues#issue/8
+
+* Minor enhancements
+  * Fix attachment bug (Johannes Jörg Schmidt)
+  * Fix create database exception bug (Damien Mathieu)
+  * Compatible with restclient >= 1.4.0 new responses (Julien Kirch)
+  * Bug fix: Attribute protection no longer strips attributes coming from the database (Will Leinweber)
+  * Bug fix: Remove double CGI escape when PUTting an attachment (nzoschke)
+  * Bug fix: Changing Class proxy to set database on result sets (Peter Gumeson)
+  * Bug fix: Updated time regexp (Nolan Darilek)
+  * Added an update_doc method to database to handle conflicts during atomic updates. (Pierre Larochelle)
+  * Bug fix: http://github.com/couchrest/couchrest/issues/#issue/2 (Luke Burton)
+
+== 0.34
+
+* Major enhancements
+
+  * Added support for https database URIs. (Mathias Meyer)
+  * Changing some validations to be compatible with activemodel. (Marcos Tapajós)
+  * Adds attribute protection to properties. (Will Leinweber)
+  * Improved CouchRest::Database#save_doc, added "batch" mode to significantly speed up saves at cost of lower durability gurantees. (Igal Koshevoy)
+  * Added CouchRest::Database#bulk_save_doc and #batch_save_doc as human-friendlier wrappers around #save_doc. (Igal Koshevoy)
+  
+* Minor enhancements 
+  
+  * Fix content_type handling for attachments
+  * Fixed a bug in the pagination code that caused it to paginate over records outside of the scope of the view parameters.(John Wood)
+  * Removed amount_pages calculation for the pagination collection, since it cannot be reliably calculated without a view.(John Wood)
+  * Bug fix: http://github.com/couchrest/couchrest/issues/#issue/2 (Luke Burton)
+  * Bug fix: http://github.com/couchrest/couchrest/issues/#issue/1 (Marcos Tapajós)
+  * Removed the Database class deprecation notices (Matt Aimonetti)
+  * Adding support to :cast_as => 'Date'.  (Marcos Tapajós)
+  * Improve documentation  (Marcos Tapajós)
+  * Streamer fixes (Julien Sanchez)
+  * Fix Save on Document & ExtendedDocument crashed if bulk (Julien Sanchez)
+  * Fix Initialization of ExtendentDocument model shouldn't failed on a nil value in argument (deepj)
+  * Change to use Jeweler and Gemcutter (Marcos Tapajós)
+
+== 0.33
+
+* Major enhancements
+
+  * Added a new Rack logger middleware letting you log/save requests/queries (Matt Aimonetti)
+  
+* Minor enhancements 
+  
+  * Added #amount_pages to a paginated result array (Matt Aimonetti)
+  * Ruby 1.9.2 compatible (Matt Aimonetti)
+  * Added a property? method for property cast as :boolean (John Wood)
+  * Added an option to force the deletion of a attachments (bypass 409s) (Matt Aimonetti)
+  * Created a new abstraction layer for the REST API (Matt Aimonetti)
+  * Bug fix: made ExtendedDocument#all compatible with Couch 0.10 (tc)
+
+== 0.32
+  
+* Major enhancements
+
+  * ExtendedDocument.get doesn't raise an exception anymore. If no documents are found nil is returned.
+  * ExtendedDocument.get! works the say #get used to work and will raise an exception if a document isn't found.
+  
+* Minor enhancements  
+   
+  * Bug fix: Model.all(:keys => [1,2]) was not working (Matt Aimonetti)
+  * Added ValidationErrors#count in order to play nicely with Rails (Peter Wagenet)
+  * Bug fix: class proxy design doc refresh (Daniel Kirsh)
+  * Bug fix: the count method on the proxy collection was missing (Daniel Kirsch)
+  * Added #amount_pages to a paginated collection. (Matt Aimonetti)
+
+== 0.31
+
+* Major enhancements
+
+  * Created an abstraction HTTP layer to support different http adapters (Matt Aimonetti)
+  * Added ExtendedDocument.create({}) and #create!({}) so you don't have to do Model.new.create (Matt Aimonetti)
+  
+* Minor enhancements
+  
+  * Added an init.rb file for easy usage as a Rails plugin (Aaron Quint)
+  * Bug fix: pagination shouldn't die on empty results (Arnaud Berthomier)
+  * Optimized ExtendedDocument.count to run about 3x faster (Matt Aimonetti)
+  * Added Float casting (Ryan Felton & Matt Aimonetti)
+
+== 0.30
+ 
+* Major enhancements
+ 
+  * Added support for pagination (John Wood)
+  * Improved performance when initializing documents with timestamps (Matt Aimonetti)
+ 
+* Minor enhancements
+ 
+  * Extended the API to retrieve an attachment URI (Matt Aimonetti)
+  * Bug fix: default value should be able to be set as false (Alexander Uvarov)
+  * Bug fix: validates_is_numeric should be able to properly validate a Float instance (Rob Kaufman)
+  * Bug fix: fixed the Timeout implementation (Seth Falcon)
+  
+  
+---
+
+Unfortunately, before 0.30 we did not keep a track of the modifications made to CouchRest.
+You can see the full commit history on GitHub: http://github.com/couchrest/couchrest/commits/master/

data/lib/couchrest/casted_array.rb

@@ -0,0 +1,25 @@
+#
+# Wrapper around Array so that the casted_by attribute is set in all
+# elements of the array.
+#
+
+module CouchRest
+  class CastedArray < Array
+    attr_accessor :casted_by
+    
+    def << obj
+      obj.casted_by = self.casted_by if obj.respond_to?(:casted_by)
+      super(obj)
+    end
+    
+    def push(obj)
+      obj.casted_by = self.casted_by if obj.respond_to?(:casted_by)
+      super(obj)
+    end
+    
+    def []= index, obj
+      obj.casted_by = self.casted_by if obj.respond_to?(:casted_by)
+      super(index, obj)
+    end
+  end
+end

data/lib/couchrest/casted_model.rb

@@ -0,0 +1,59 @@
+require 'couchrest'
+require File.join(File.dirname(__FILE__), 'mixins/callbacks')
+require File.join(File.dirname(__FILE__), 'mixins/properties')
+
+module CouchRest
+  module CastedModel
+    
+    def self.included(base)
+      base.send(:include, ::CouchRest::Mixins::Callbacks)
+      base.send(:include, ::CouchRest::Mixins::Properties)
+      base.send(:attr_accessor, :casted_by)
+      base.send(:attr_accessor, :document_saved)
+    end
+    
+    def initialize(keys={})
+      raise StandardError unless self.is_a? Hash
+      apply_defaults # defined in CouchRest::Mixins::Properties
+      super()
+      keys.each do |k,v|
+        self[k.to_s] = v
+      end if keys
+      cast_keys      # defined in CouchRest::Mixins::Properties
+    end
+    
+    def []= key, value
+      super(key.to_s, value)
+    end
+    
+    def [] key
+      super(key.to_s)
+    end
+    
+    # Gets a reference to the top level extended
+    # document that a model is saved inside of
+    def base_doc
+      return nil unless @casted_by
+      @casted_by.base_doc
+    end
+    
+    # False if the casted model has already
+    # been saved in the containing document
+    def new?
+      !@document_saved
+    end
+    alias :new_record? :new?
+    
+    # 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

data/lib/couchrest/extended_document.rb

@@ -0,0 +1,318 @@
+gem 'samlown-couchrest'
+require 'couchrest'
+require 'active_support'
+require 'mime/types'
+require "enumerator"
+require File.join(File.dirname(__FILE__), "monkeypatches")
+require File.join(File.dirname(__FILE__), "property")
+require File.join(File.dirname(__FILE__), 'mixins')
+require File.join(File.dirname(__FILE__), 'casted_model')
+
+module CouchRest
+  
+  # Same as CouchRest::Document but with properties and validations
+  class ExtendedDocument < Document
+
+    VERSION = "1.0.0"
+
+    include CouchRest::Mixins::Callbacks
+    include CouchRest::Mixins::DocumentQueries    
+    include CouchRest::Mixins::Views
+    include CouchRest::Mixins::DesignDoc
+    include CouchRest::Mixins::ExtendedAttachments
+    include CouchRest::Mixins::ClassProxy
+    include CouchRest::Mixins::Collection
+    include CouchRest::Mixins::AttributeProtection
+
+    def self.subclasses
+      @subclasses ||= []
+    end
+    
+    def self.inherited(subklass)
+      super
+      subklass.send(:include, CouchRest::Mixins::Properties)
+      subklass.class_eval <<-EOS, __FILE__, __LINE__ + 1
+        def self.inherited(subklass)
+          super
+          subklass.properties = self.properties.dup
+        end
+      EOS
+      subclasses << subklass
+    end
+    
+    # Accessors
+    attr_accessor :casted_by
+    
+    # Callbacks
+    define_callbacks :create, "result == :halt"
+    define_callbacks :save, "result == :halt"
+    define_callbacks :update, "result == :halt"
+    define_callbacks :destroy, "result == :halt"
+
+    # Creates a new instance, bypassing attribute protection
+    #
+    # ==== Returns
+    #  a document instance
+    def self.create_from_database(passed_keys={})
+      new(passed_keys, :directly_set_attributes => true)      
+    end
+    
+    def initialize(passed_keys={}, options={})
+      apply_defaults # defined in CouchRest::Mixins::Properties
+      remove_protected_attributes(passed_keys) unless options[:directly_set_attributes]
+      directly_set_attributes(passed_keys) unless passed_keys.nil?
+      super(passed_keys)
+      cast_keys      # defined in CouchRest::Mixins::Properties
+      unless self['_id'] && self['_rev']
+        self['couchrest-type'] = self.class.to_s
+      end
+      after_initialize if respond_to?(:after_initialize)
+    end
+    
+    # Defines an instance and save it directly to the database 
+    # 
+    # ==== Returns
+    #  returns the reloaded document
+    def self.create(options)
+      instance = new(options)
+      instance.create
+      instance
+    end
+    
+    # Defines an instance and save it directly to the database 
+    # 
+    # ==== Returns
+    #  returns the reloaded document or raises an exception
+    def self.create!(options)
+      instance = new(options)
+      instance.create!
+      instance
+    end
+    
+    # Automatically set <tt>updated_at</tt> and <tt>created_at</tt> fields
+    # on the document whenever saving occurs. CouchRest uses a pretty
+    # decent time format by default. See Time#to_json
+    def self.timestamps!
+      class_eval <<-EOS, __FILE__, __LINE__
+        property(:updated_at, :read_only => true, :type => 'Time', :auto_validation => false)
+        property(:created_at, :read_only => true, :type => 'Time', :auto_validation => false)
+        
+        set_callback :save, :before do |object|
+          object['updated_at'] = Time.now
+          object['created_at'] = object['updated_at'] if object.new?
+        end
+      EOS
+    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 self.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
+    
+    # Temp solution to make the view_by methods available
+    def self.method_missing(m, *args, &block)
+      if has_view?(m)
+        query = args.shift || {}
+        view(m, query, *args, &block)
+      else
+        super
+      end
+    end
+    
+    ### instance methods
+    
+    # Returns the Class properties
+    #
+    # ==== Returns
+    # Array:: the list of properties for the instance
+    def properties
+      self.class.properties
+    end
+    
+    # Gets a reference to the actual document in the DB
+    # Calls up to the next document if there is one,
+    # Otherwise we're at the top and we return self
+    def base_doc
+      return self if base_doc?
+      @casted_by.base_doc
+    end
+    
+    # Checks if we're the top document
+    def base_doc?
+      !@casted_by
+    end
+    
+    # Takes a hash as argument, and applies the values by using writer methods
+    # for each key. It doesn't save the document at the end. Raises a NoMethodError if the corresponding methods are
+    # missing. In case of error, no attributes are changed.    
+    def update_attributes_without_saving(hash)
+      # remove attributes that cannot be updated, silently ignoring them
+      # which matches Rails behavior when, for instance, setting created_at.
+      # make a copy, we don't want to change arguments
+      attrs = hash.dup
+      %w[_id _rev created_at updated_at].each {|attr| attrs.delete(attr)}
+      check_properties_exist(attrs)
+			set_attributes(attrs)
+    end
+    alias :attributes= :update_attributes_without_saving
+
+    # Takes a hash as argument, and applies the values by using writer methods
+    # for each key. Raises a NoMethodError if the corresponding methods are
+    # missing. In case of error, no attributes are changed.
+    def update_attributes(hash)
+      update_attributes_without_saving hash
+      save
+    end
+
+    # for compatibility with old-school frameworks
+    alias :new_record? :new?
+    alias :new_document? :new?
+    
+    # Trigger the callbacks (before, after, around)
+    # and create the document
+    # It's important to have a create callback since you can't check if a document
+    # was new after you saved it
+    #
+    # When creating a document, both the create and the save callbacks will be triggered.
+    def create(bulk = false)
+      caught = catch(:halt)  do
+        _run_create_callbacks do
+            _run_save_callbacks do
+              create_without_callbacks(bulk)
+          end
+        end
+      end
+    end
+    
+    # unlike save, create returns the newly created document
+    def create_without_callbacks(bulk =false)
+      raise ArgumentError, "a document requires a database to be created to (The document or the #{self.class} default database were not set)" unless database
+      set_unique_id if new? && self.respond_to?(:set_unique_id)
+      result = database.save_doc(self, bulk)
+      (result["ok"] == true) ? self : false
+    end
+    
+    # Creates the document in the db. Raises an exception
+    # if the document is not created properly.
+    def create!
+      raise "#{self.inspect} failed to save" unless self.create
+    end
+    
+    # Trigger the callbacks (before, after, around)
+    # only if the document isn't new
+    def update(bulk = false)
+      caught = catch(:halt)  do
+        if self.new?
+          save(bulk)
+        else
+          _run_update_callbacks do
+            _run_save_callbacks do
+              save_without_callbacks(bulk)
+            end
+          end
+        end
+      end
+    end
+    
+    # Trigger the callbacks (before, after, around)
+    # and save the document
+    def save(bulk = false)
+      caught = catch(:halt)  do
+        if self.new?
+          _run_save_callbacks do
+            save_without_callbacks(bulk)
+          end
+        else
+          update(bulk)
+        end
+      end
+    end
+    
+    # Overridden to set the unique ID.
+    # Returns a boolean value
+    def save_without_callbacks(bulk = false)
+      raise ArgumentError, "a document requires a database to be saved to (The document or the #{self.class} default database were not set)" unless database
+      set_unique_id if new? && self.respond_to?(:set_unique_id)
+      result = database.save_doc(self, bulk)
+      mark_as_saved 
+      result["ok"] == true
+    end
+    
+    # Saves the document to the db using save. Raises an exception
+    # if the document is not saved properly.
+    def save!
+      raise "#{self.inspect} failed to save" unless self.save
+      true
+    end
+
+    # Deletes the document from the database. Runs the :destroy callbacks.
+    # Removes the <tt>_id</tt> and <tt>_rev</tt> fields, preparing the
+    # document to be saved to a new <tt>_id</tt>.
+    def destroy(bulk=false)
+      caught = catch(:halt)  do
+        _run_destroy_callbacks do
+          result = database.delete_doc(self, bulk)
+          if result['ok']
+            self.delete('_rev')
+            self.delete('_id')
+          end
+          result['ok']
+        end
+      end
+    end
+    
+    protected
+    
+    # Set document_saved flag on all casted models to true
+    def mark_as_saved
+      self.each do |key, prop|
+        if prop.is_a?(Array)
+          prop.each do |item|
+            if item.respond_to?(:document_saved)
+              item.send(:document_saved=, true)
+            end
+          end
+        elsif prop.respond_to?(:document_saved)
+          prop.send(:document_saved=, true)
+        end
+      end
+    end
+
+		private
+
+		def check_properties_exist(attrs)
+      attrs.each do |attribute_name, attribute_value|
+        raise NoMethodError, "#{attribute_name}= method not available, use property :#{attribute_name}" unless self.respond_to?("#{attribute_name}=")
+      end      
+		end
+    
+    def directly_set_attributes(hash)
+      hash.each do |attribute_name, attribute_value|
+        if self.respond_to?("#{attribute_name}=")
+          self.send("#{attribute_name}=", hash.delete(attribute_name))
+        end
+      end
+    end
+    
+		def set_attributes(hash)
+			attrs = remove_protected_attributes(hash)
+			directly_set_attributes(attrs)
+		end
+  end
+end