couchrest_model 1.1.0.beta2 → 1.1.0.beta3

data/lib/couchrest/model/design_doc.rb

@@ -3,19 +3,13 @@ module CouchRest
   module Model
     module DesignDoc
       extend ActiveSupport::Concern
-      
+
       module ClassMethods
-        
+
         def design_doc
-          @design_doc ||= Design.new(default_design_doc)
+          @design_doc ||= ::CouchRest::Design.new(default_design_doc)
         end
-    
-        # Use when something has been changed, like a view, so that on the next request
-        # the design docs will be updated (if changed!)
-        def req_design_doc_refresh
-          @design_doc_fresh = { }
-        end
-        
+
         def design_doc_id
           "_design/#{design_doc_slug}"
         end
@@ -24,42 +18,20 @@ module CouchRest
           self.to_s
         end
 
-        def default_design_doc
-          {
-            "_id" => design_doc_id,
-            "language" => "javascript",
-            "views" => {
-              'all' => {
-                'map' => "function(doc) {
-                  if (doc['#{self.model_type_key}'] == '#{self.to_s}') {
-                    emit(doc['_id'],1);
-                  }
-                }"
-              }
-            }
-          }
+        def design_doc_uri(db = database)
+          "#{db.root}/#{design_doc_id}"
         end
 
-        # DEPRECATED
-        # use stored_design_doc to retrieve the current design doc
-        def all_design_doc_versions(db = database)
-          db.documents :startkey => "_design/#{self.to_s}", 
-            :endkey => "_design/#{self.to_s}-\u9999"
-        end
-       
         # Retreive the latest version of the design document directly
-        # from the database.
+        # from the database. This is never cached and will return nil if
+        # the design is not present.
+        #
+        # Use this method if you'd like to compare revisions [_rev] which
+        # is not stored in the normal design doc.
         def stored_design_doc(db = database)
-          db.get(design_doc_id) rescue nil
-        end
-        alias :model_design_doc :stored_design_doc
-
-        def refresh_design_doc(db = database)
-          raise "Database missing for design document refresh" if db.nil?
-          unless design_doc_fresh(db)
-            save_design_doc(db)
-            design_doc_fresh(db, true)
-          end
+          db.get(design_doc_id)
+        rescue RestClient::ResourceNotFound
+          nil
         end
 
         # Save the design doc onto a target database in a thread-safe way,
@@ -68,7 +40,7 @@ module CouchRest
         # See also save_design_doc! to always save the design doc even if there
         # are no changes.
         def save_design_doc(db = database, force = false)
-          update_design_doc(Design.new(design_doc), db, force)
+          update_design_doc(db, force)
         end
 
         # Force the update of the model's design_doc even if it hasn't changed.
@@ -76,48 +48,70 @@ module CouchRest
           save_design_doc(db, true)
         end
 
-        protected
+        private
 
-        def design_doc_fresh(db, fresh = nil)
-          @design_doc_fresh ||= {}
-          if fresh.nil? 
-            @design_doc_fresh[db.uri] || false
-          else
-            @design_doc_fresh[db.uri] = fresh
-          end
+        def design_doc_cache
+          Thread.current[:couchrest_design_cache] ||= {}
         end
+        def design_doc_cache_checksum(db)
+          design_doc_cache[design_doc_uri(db)]
+        end
+        def set_design_doc_cache_checksum(db, checksum)
+          design_doc_cache[design_doc_uri(db)] = checksum
+        end
+
+        # Writes out a design_doc to a given database if forced
+        # or the stored checksum is not the same as the current
+        # generated checksum.
+        #
+        # Returns the original design_doc provided, but does 
+        # not update it with the revision.
+        def update_design_doc(db, force = false)
+          return design_doc unless force || auto_update_design_doc
 
-        # Writes out a design_doc to a given database, returning the
-        # updated design doc
-        def update_design_doc(design_doc, db, force = false)
+          # Grab the design doc's checksum
+          checksum = design_doc.checksum!
+
+          # If auto updates enabled, check checksum cache
+          return design_doc if auto_update_design_doc && design_doc_cache_checksum(db) == checksum
+
+          # Load up the stored doc (if present), update, and save
           saved = stored_design_doc(db)
           if saved
-            changes = force
-            design_doc['views'].each do |name, view|
-              if !compare_views(saved['views'][name], view)
-                changes = true
-                saved['views'][name] = view
-              end
-            end
-            if changes
+            if force || saved['couchrest-hash'] != checksum
+              saved.merge!(design_doc)
               db.save_doc(saved)
             end
-            design_doc
           else
-            design_doc.database = db
-            design_doc.save
-            design_doc
+            db.save_doc(design_doc)
+            design_doc.delete('_rev') # Prevent conflicts, never store rev as DB specific
           end
+
+          # Ensure checksum cached for next attempt if using auto updates
+          set_design_doc_cache_checksum(db, checksum) if auto_update_design_doc
+          design_doc
         end
 
-        # Return true if the two views match
-        def compare_views(orig, repl)
-          return false if orig.nil? or repl.nil?
-          (orig['map'].to_s.strip == repl['map'].to_s.strip) && (orig['reduce'].to_s.strip == repl['reduce'].to_s.strip)
+        def default_design_doc
+          {
+            "_id" => design_doc_id,
+            "language" => "javascript",
+            "views" => {
+              'all' => {
+                'map' => "function(doc) {
+                  if (doc['#{self.model_type_key}'] == '#{self.to_s}') {
+                    emit(doc['_id'],1);
+                  }
+                }"
+              }
+            }
+          }
         end
 
+
+
       end # module ClassMethods
-      
+
     end
   end
 end

data/lib/couchrest/model/designs/view.rb

@@ -90,6 +90,13 @@ module CouchRest
           result ? all.last : limit(1).descending.all.last
         end
 
+        # Return the number of documents in the currently defined result set.
+        # Use <tt>#count</tt> for the total number of documents regardless
+        # of the current limit defined.
+        def length
+          docs.length
+        end
+
         # Perform a count operation based on the current view. If the view
         # can be reduced, the reduce will be performed and return the first
         # value. This is okay for most simple queries, but may provide
@@ -106,7 +113,7 @@ module CouchRest
         def count
           raise "View#count cannot be used with group options" if query[:group]
           if can_reduce?
-            row = reduce.rows.first
+            row = reduce.skip(0).limit(1).rows.first
             row.nil? ? 0 : row.value
           else
             limit(0).total_rows
@@ -232,11 +239,19 @@ module CouchRest
         end
 
 
-        # The results should be provided in descending order.
+        # The results should be provided in descending order. If the startkey or
+        # endkey query options have already been seen set, calling this method
+        # will automatically swap the options around. If you don't want this,
+        # simply set descending before any other option.
         #
-        # Descending is false by default, this method will enable it and cannot
-        # be undone.
+        # Descending is false by default, and this method cannot
+        # be undone once used, it has no inverse option.
         def descending
+          if query[:startkey] || query[:endkey]
+            query[:startkey], query[:endkey] = query[:endkey], query[:startkey]
+          elsif query[:startkey_docid] || query[:endkey_docid]
+            query[:startkey_docid], query[:endkey_docid] = query[:endkey_docid], query[:startkey_docid]
+          end
           update_query(:descending => true)
         end
 
@@ -383,30 +398,22 @@ module CouchRest
         def execute
           return self.result if result
           raise "Database must be defined in model or view!" if use_database.nil?
-          retryable = true
-          # Remove the reduce value if its not needed
+
+          # Remove the reduce value if its not needed to prevent CouchDB errors
           query.delete(:reduce) unless can_reduce?
-          begin
-            self.result = model.design_doc.view_on(use_database, name, query.reject{|k,v| v.nil?})
-          rescue RestClient::ResourceNotFound => e
-            if retryable
-              model.save_design_doc(use_database)
-              retryable = false
-              retry
-            else
-              raise e
-            end
-          end
+
+          model.save_design_doc(use_database)
+
+          self.result = model.design_doc.view_on(use_database, name, query.reject{|k,v| v.nil?})
         end
 
         # Class Methods
         class << self
-          
           # Simplified view creation. A new view will be added to the 
           # provided model's design document using the name and options.
           #
           # If the view name starts with "by_" and +:by+ is not provided in 
-          # the options, the new view's map method will be interpretted and
+          # the options, the new view's map method will be interpreted and
           # generated automatically. For example:
           #
           #   View.create(Meeting, "by_date_and_name")

data/lib/couchrest/model/designs.rb

@@ -28,8 +28,6 @@ module CouchRest
           mapper.create_view_method(:all)
 
           mapper.instance_eval(&block) if block_given?
-
-          req_design_doc_refresh
         end
 
         # Override the default page pagination value:

data/lib/couchrest/model/dirty.rb

@@ -0,0 +1,49 @@
+# 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 CouchRest::Model::CastedBy  # needed for base_doc
+      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?
+        bdoc = base_doc
+        bdoc && !bdoc.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_attribute) if @casted_by
+      end
+
+      private
+
+      # return the attribute name this object is referenced by in the parent
+      def casted_by_attribute
+        return @casted_by_attribute if @casted_by_attribute
+        attr = @casted_by.attributes
+        @casted_by_attribute = attr.keys.detect { |k| attr[k] == self }
+      end
+
+    end
+  end
+end

data/lib/couchrest/model/extended_attachments.rb

@@ -1,6 +1,7 @@
 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.
@@ -35,7 +36,10 @@ module CouchRest
       # deletes a file attachment from the current doc
       def delete_attachment(attachment_name)
         return unless attachments
-        attachments.delete attachment_name
+        if attachments.include?(attachment_name)
+          attribute_will_change!("_attachments")
+          attachments.delete attachment_name
+        end
       end
 
       # returns true if attachment_name exists
@@ -66,6 +70,8 @@ module CouchRest
         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

data/lib/couchrest/model/persistence.rb

@@ -12,7 +12,9 @@ module CouchRest
           _run_save_callbacks do
             set_unique_id if new? && self.respond_to?(:set_unique_id)
             result = database.save_doc(self)
-            (result["ok"] == true) ? self : false
+            ret = (result["ok"] == true) ? self : false
+            @changed_attributes.clear if ret && @changed_attributes
+            ret
           end
         end
       end
@@ -28,10 +30,13 @@ module CouchRest
       def update(options = {})
         raise "Calling #{self.class.name}#update on document that has not been created!" if self.new?
         return false unless perform_validations(options)
+        return true if !self.changed?
         _run_update_callbacks do
           _run_save_callbacks do
             result = database.save_doc(self)
-            result["ok"] == true
+            ret = result["ok"] == true
+            @changed_attributes.clear if ret && @changed_attributes
+            ret
           end
         end
       end
@@ -140,12 +145,18 @@ module CouchRest
         # should use the class name as part of the unique id.
         def unique_id method = nil, &block
           if method
+            define_method :get_unique_id do
+              self.send(method)
+            end
             define_method :set_unique_id do
-              self['_id'] ||= self.send(method)
+              self['_id'] ||= get_unique_id
             end
           elsif block
+            define_method :get_unique_id do
+              block.call(self)
+            end
             define_method :set_unique_id do
-              uniqid = block.call(self)
+              uniqid = get_unique_id
               raise ArgumentError, "unique_id block must not return nil" if uniqid.nil?
               self['_id'] ||= uniqid
             end

data/lib/couchrest/model/properties.rb

@@ -6,7 +6,9 @@ module CouchRest
 
       included do
         extlib_inheritable_accessor(:properties) unless self.respond_to?(:properties)
+        extlib_inheritable_accessor(:property_by_name) unless self.respond_to?(:property_by_name)
         self.properties ||= []
+        self.property_by_name ||= {}
         raise "You can only mixin Properties in a class responding to [] and []=, if you tried to mixin CastedModel, make sure your class inherits from Hash or responds to the proper methods" unless (method_defined?(:[]) && method_defined?(:[]=))
       end
 
@@ -37,10 +39,33 @@ module CouchRest
       end
 
       # Store a casted value in the current instance of an attribute defined
-      # with a property.
+      # with a property and update dirty status
       def write_attribute(property, value)
         prop = find_property!(property)
-        self[prop.to_s] = prop.is_a?(String) ? value : prop.cast(self, value)
+        value = prop.is_a?(String) ? value : prop.cast(self, value)
+        attribute_will_change!(prop.name) if use_dirty? && self[prop.name] != value
+        self[prop.name] = value
+      end
+
+      def []=(key,value)
+        return super(key,value) unless use_dirty?
+
+        has_changes = self.changed?
+        if !has_changes && self.respond_to?(:get_unique_id)
+          check_id_change = true
+          old_id = get_unique_id
+        end
+
+        ret = super(key, value)
+
+        if check_id_change
+          # if we have set an attribute that results in the _id changing (unique_id),
+          # force changed? to return true so that the record can be saved
+          new_id = get_unique_id
+          changed_attributes["_id"] = new_id if old_id != new_id
+        end
+
+        ret
       end
 
       # Takes a hash as argument, and applies the values by using writer methods
@@ -54,29 +79,47 @@ module CouchRest
       end
       alias :attributes= :update_attributes_without_saving
 
+      # 'attributes' needed for Dirty
+      alias :attributes :properties_with_values
+
+      def set_attributes(hash)
+        attrs = remove_protected_attributes(hash)
+        directly_set_attributes(attrs)
+      end
+
+      protected
+
+      def find_property(property)
+        property.is_a?(Property) ? property : self.class.property_by_name[property.to_s]
+      end
 
-      private
       # The following methods should be accessable by the Model::Base Class, but not by anything else!
       def apply_all_property_defaults
         return if self.respond_to?(:new?) && (new? == false)
         # TODO: cache the default object
+        # Never mark default options as dirty!
+        dirty, self.disable_dirty = self.disable_dirty, true
         self.class.properties.each do |property|
           write_attribute(property, property.default_value)
         end
+        self.disable_dirty = dirty
       end
 
       def prepare_all_attributes(doc = {}, options = {})
+        self.disable_dirty = !!options[:directly_set_attributes]
         apply_all_property_defaults
         if options[:directly_set_attributes]
           directly_set_read_only_attributes(doc)
         else
           doc = remove_protected_attributes(doc)
         end
-        directly_set_attributes(doc) unless doc.nil?
+        res = doc.nil? ? doc : directly_set_attributes(doc)
+        self.disable_dirty = false
+        res
       end
 
       def find_property!(property)
-        prop = property.is_a?(Property) ? property : self.class.properties.detect {|p| p.to_s == property.to_s}
+        prop = find_property(property)
         raise ArgumentError, "Missing property definition for #{property.to_s}" if prop.nil?
         prop
       end
@@ -107,15 +150,12 @@ module CouchRest
         end
       end
 
-      def set_attributes(hash)
-        attrs = remove_protected_attributes(hash)
-        directly_set_attributes(attrs)
-      end
 
 
       module ClassMethods
 
         def property(name, *options, &block)
+          raise "Invalid property definition, '#{name}' already used for CouchRest Model type field" if name.to_s == model_type_key.to_s
           opts = { }
           type = options.shift
           if type.class != Hash
@@ -172,6 +212,7 @@ module CouchRest
               validates_casted_model property.name
             end
             properties << property
+            property_by_name[property.to_s] = property
             property
           end
 

data/lib/couchrest/model/property.rb

@@ -38,8 +38,12 @@ module CouchRest::Model
         end
         arr = value.collect { |data| cast_value(parent, data) }
         # allow casted_by calls to be passed up chain by wrapping in CastedArray
-        value = type_class != String ? CastedArray.new(arr, self) : arr
-        value.casted_by = parent if value.respond_to?(:casted_by)
+        value = CastedArray.new(arr, self)
+        value.casted_by = parent
+      elsif (type == Object || type == Hash) && (value.class == Hash)
+        # allow casted_by calls to be passed up chain by wrapping in CastedHash
+        value = CouchRest::Model::CastedHash[value]
+        value.casted_by = parent
       elsif !value.nil?
         value = cast_value(parent, value)
       end

data/lib/couchrest/model/proxyable.rb

@@ -48,7 +48,6 @@ module CouchRest
         end
 
         # Base
-        
         def new(*args)
           proxy_update(model.new(*args))
         end
@@ -56,7 +55,7 @@ module CouchRest
         def build_from_database(doc = {})
           proxy_update(model.build_from_database(doc))
         end
-        
+
         def method_missing(m, *args, &block)
           if has_view?(m)
             if model.respond_to?(m)
@@ -73,32 +72,32 @@ module CouchRest
           end
           super
         end
-        
+
         # DocumentQueries
-        
+
         def all(opts = {}, &block)
           proxy_update_all(@model.all({:database => @database}.merge(opts), &block))
         end
-        
+
         def count(opts = {})
           @model.count({:database => @database}.merge(opts))
         end
-        
+
         def first(opts = {})
           proxy_update(@model.first({:database => @database}.merge(opts)))
         end
-        
+
         def last(opts = {})
           proxy_update(@model.last({:database => @database}.merge(opts)))
         end
-        
+
         def get(id)
           proxy_update(@model.get(id, @database))
         end
         alias :find :get
-        
+
         # Views
-        
+
         def has_view?(view)
           @model.has_view?(view)
         end
@@ -106,27 +105,22 @@ module CouchRest
         def view_by(*args)
           @model.view_by(*args)
         end
-       
+
         def view(name, query={}, &block)
           proxy_update_all(@model.view(name, {:database => @database}.merge(query), &block))
         end
-        
+
         def first_from_view(name, *args)
           # add to first hash available, or add to end
           (args.last.is_a?(Hash) ? args.last : (args << {}).last)[:database] = @database
           proxy_update(@model.first_from_view(name, *args))
         end
-       
+
         # DesignDoc
-        
         def design_doc
           @model.design_doc
         end
-        
-        def refresh_design_doc(db = nil)
-          @model.refresh_design_doc(db || @database)
-        end
-        
+
         def save_design_doc(db = nil)
           @model.save_design_doc(db || @database)
         end

data/lib/couchrest/model/support/couchrest_design.rb

@@ -0,0 +1,33 @@
+
+CouchRest::Design.class_eval do
+
+  # Calculate and update the checksum of the Design document.
+  # Used for ensuring the latest version has been sent to the database.
+  #
+  # This will generate an flatterned, ordered array of all the elements of the
+  # design document, convert to string then generate an MD5 Hash. This should
+  # result in a consisitent Hash accross all platforms.
+  #
+  def checksum!
+    # create a copy of basic elements
+    base = self.dup
+    base.delete('_id')
+    base.delete('_rev')
+    base.delete('couchrest-hash')
+    result = nil
+    flatten =
+      lambda {|r|
+        (recurse = lambda {|v|
+          if v.is_a?(Hash)
+            v.to_a.map{|v| recurse.call(v)}.flatten
+          elsif v.is_a?(Array)
+            v.flatten.map{|v| recurse.call(v)}
+          else
+            v.to_s
+          end
+        }).call(r)
+      }
+    self['couchrest-hash'] = Digest::MD5.hexdigest(flatten.call(base).sort.join(''))
+  end
+
+end