davber_couchrest_extended_document 1.0.0

data/THANKS.md

@@ -0,0 +1,22 @@
+CouchRest THANKS
+=====================
+
+CouchRest was originally developed by J. Chris Anderson <jchris@grabb.it>
+and a number of other contributors. Many people further contributed to 
+CouchRest by reporting problems, suggesting various improvements or submitting
+changes. A list of these people is included below.
+
+ * [Matt Aimonetti](http://merbist.com/about/)
+ * [Greg Borenstein](http://ideasfordozens.com)
+ * [Geoffrey Grosenbach](http://nubyonrails.com/)
+ * [Jonathan S. Katz](http://github.com/jkatz)
+ * [Matt Lyon](http://mattly.tumblr.com/)
+ * Simon Rozet (simon /at/ rozet /dot/ name)
+ * [Marcos Tapajós](http://tapajos.me)
+ * [Sam Lown](http://github.com/samlown)
+ * [Will Leinweber](http://github.com/will)
+
+ 
+Patches are welcome. The primary source for this software project is [on Github](http://github.com/couchrest/couchrest_extended_document)
+
+A lot of people have active forks - thank you all - even the patches I don't end up using are helpful.

data/examples/model/example.rb

@@ -0,0 +1,144 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'couchrest')
+
+def show obj
+  puts obj.inspect
+  puts
+end
+
+SERVER = CouchRest.new
+SERVER.default_database = 'couchrest-extendeddoc-example'
+
+class Author < CouchRest::ExtendedDocument
+  use_database SERVER.default_database
+  property :name
+  
+  def drink_scotch
+    puts "... glug type glug ... I'm #{name} ... type glug glug ..."
+  end
+end
+
+class Post < CouchRest::ExtendedDocument
+  use_database SERVER.default_database
+  
+  property :title
+  property :body
+  property :author, :cast_as => 'Author'
+
+  timestamps!
+end
+
+class Comment < CouchRest::ExtendedDocument
+  use_database SERVER.default_database
+  
+  property :commenter, :cast_as => 'Author'
+  timestamps!
+  
+  def post= post
+    self["post_id"] = post.id
+  end
+  def post
+    Post.get(self['post_id']) if self['post_id']
+  end
+  
+end
+
+puts "Act I: CRUD"
+puts
+puts "(pause for dramatic effect)"
+puts
+sleep 2
+
+puts "Create an author."
+quentin = Author.new("name" => "Quentin Hazel")
+show quentin
+
+puts "Create a new post."
+post = Post.new(:title => "First Post", :body => "Lorem ipsum dolor sit amet, consectetur adipisicing elit...")
+show post
+
+puts "Add the author to the post."
+post.author = quentin
+show post
+
+puts "Save the post."
+post.save
+show post
+
+puts "Load the post."
+reloaded = Post.get(post.id)
+show reloaded
+
+puts "The author of the post is an instance of Author."
+reloaded.author.drink_scotch
+
+puts "\nAdd some comments to the post."
+comment_one = Comment.new :text => "Blah blah blah", :commenter => {:name => "Joe Sixpack"}
+comment_two = Comment.new :text => "Yeah yeah yeah", :commenter => {:name => "Jane Doe"}
+comment_three = Comment.new :text => "Whatever...", :commenter => {:name => "John Stewart"}
+
+# TODO - maybe add some magic here?
+comment_one.post = post
+comment_two.post = post
+comment_three.post = post
+comment_one.save
+comment_two.save
+comment_three.save
+
+show comment_one
+show comment_two
+show comment_three
+
+puts "We can load a post through its comment (no magic here)."
+show post = comment_one.post
+
+puts "Commenters are also authors."
+comment_two['commenter'].drink_scotch
+comment_one['commenter'].drink_scotch
+comment_three['commenter'].drink_scotch
+
+puts "\nLet's save an author to her own document."
+jane = comment_two['commenter']
+jane.save
+show jane
+
+puts "Oh, that's neat! Because Ruby passes hash valuee by reference, Jane's new id has been added to the comment she left."
+show comment_two
+
+puts "Of course, we'd better remember to save it."
+comment_two.save
+show comment_two
+
+puts "Oooh, denormalized... feel the burn!"
+puts
+puts
+puts
+puts "Act II: Views"
+puts
+puts
+sleep 2
+
+puts "Let's find all the comments that go with our post."
+puts "Our post has id #{post.id}, so lets find all the comments with that post_id."
+puts
+
+class Comment
+  view_by :post_id
+end
+
+comments = Comment.by_post_id :key => post.id
+show comments
+
+puts "That was too easy."
+puts "We can even wrap it up in a finder on the Post class."
+puts
+
+class Post
+  def comments
+    Comment.by_post_id :key => id
+  end
+end
+
+show post.comments
+puts "Gimme 5 minutes and I'll roll this into the framework. ;)"
+puts
+puts "There is a lot more that can be done with views, but a lot of the interesting stuff is joins, which of course range across types. We'll pick up where we left off, next time."

data/history.txt

@@ -0,0 +1,165 @@
+== Next Version
+
+* Major enhancements
+
+* Minor enhancements
+
+== 1.0.0.beta6
+
+* Minor enhancements
+  * Added 'find_by_*' alias for finding first item in view with matching key.
+  * Fixed issue with active_support in Rails3 and text in README for JSON.
+  * Refactoring of properties, added read_attribute and write_attribute methods.
+  * Now possible to send anything to update_attribtues method. Invalid or readonly attributes will be ignored.
+  * Updating to use couchrest_inheritable_attributes to avoid possible Rails conflicts 
+
+* Major enhancements
+  * Added support for anonymous CastedModels defined in Documents
+
+== 1.0.0.beta5
+
+* Minor enhancements
+  * Added 'find' alias for 'get' for easier rails transition
+
+== 1.0.0.beta3
+
+* Minor enhancements
+  * Removed Validation by default, requires too many structure changes (FAIL)
+  * Added support for instantiation of documents read from database as couchrest-type provided (Sam Lown)
+  * Improved attachment handling for detecting file type (Sam Lown)
+  * Removing some monkey patches and relying on active_support for constantize and humanize (Sam Lown)
+  * Added support for setting type directly on property (Sam Lown)
+
+
+== 1.0.0.beta2
+
+* Minor enhancements
+  * Enable Validation by default and refactored location (Sam Lown)
+
+== 1.0.0.beta
+
+* Major enhancements
+  * Separated ExtendedDocument from main CouchRest gem (Sam Lown)
+
+* Minor enhancements
+  * active_support included by default
+
+== 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,39 @@
+#
+# 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
+    attr_accessor :property
+
+    def initialize(array, property)
+      self.property = property
+      super(array)
+    end
+    
+    def << obj
+      super(instantiate_and_cast(obj))
+    end
+    
+    def push(obj)
+      super(instantiate_and_cast(obj))
+    end
+    
+    def []= index, obj
+      super(index, instantiate_and_cast(obj))
+    end
+
+    protected
+
+    def instantiate_and_cast(obj)
+      if self.casted_by && self.property && obj.class != self.property.type_class
+        self.property.cast_value(self.casted_by, obj)
+      else
+        obj.casted_by = self.casted_by if obj.respond_to?(:casted_by)
+        obj
+      end
+    end
+  end
+end

data/lib/couchrest/casted_model.rb

@@ -0,0 +1,53 @@
+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)
+    end
+    
+    def initialize(keys={})
+      raise StandardError unless self.is_a? Hash
+      apply_all_property_defaults # defined in CouchRest::Mixins::Properties
+      super()
+      keys.each do |k,v|
+        write_attribute(k.to_s, v)
+      end if keys
+    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?
+      @casted_by.nil? ? true : @casted_by.new?
+    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,262 @@
+
+require File.join(File.dirname(__FILE__), "property")
+require File.join(File.dirname(__FILE__), "validation")
+require File.join(File.dirname(__FILE__), 'mixins')
+
+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
+    include CouchRest::Mixins::Attributes
+
+    # Including validation here does not work due to the way inheritance is handled.
+    #include CouchRest::Validation
+
+    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(doc = {})
+      type_field = CouchRest.type_field
+      base = (doc[type_field].blank? || doc[type_field] == self.to_s) ? self : doc[type_field].constantize
+      base.new(doc, :directly_set_attributes => true)      
+    end
+    
+
+    # Instantiate a new ExtendedDocument by preparing all properties
+    # using the provided document hash.
+    #
+    # Options supported:
+    # 
+    # * :directly_set_attributes: true when data comes directly from database
+    #
+    def initialize(doc = {}, options = {})
+      prepare_all_attributes(doc, options) # defined in CouchRest::Mixins::Attributes
+      super(doc)
+      unless self['_id'] && self['_rev']
+        self[CouchRest.type_field] = 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, Time, :read_only => true, :protected => true, :auto_validation => false)
+        property(:created_at, Time, :read_only => true, :protected => true, :auto_validation => false)
+        
+        set_callback :save, :before do |object|
+          write_attribute('updated_at', Time.now)
+          write_attribute('created_at', Time.now) 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 || {}
+        return view(m, query, *args, &block)
+      elsif m.to_s =~ /^find_(by_.+)/
+        view_name = $1
+        if has_view?(view_name)
+          query = {:key => args.first, :limit => 1}
+          return view(view_name, query).first
+        end
+      end
+      super
+    end
+    
+    ### instance methods
+    
+    # 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
+    
+    # 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)
+      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
+  
+  end
+end