couchrest 0.33 → 0.34

data/lib/couchrest/mixins/collection.rb

@@ -1,14 +1,5 @@
 module CouchRest
   module Mixins
-    module PaginatedResults
-      def amount_pages
-        @amount_pages ||= 0
-      end   
-      def amount_pages=(value)
-        @amount_pages = value
-      end               
-    end
-    
     module Collection
   
       def self.included(base)
@@ -93,8 +84,6 @@ module CouchRest
         DEFAULT_PAGE = 1
         DEFAULT_PER_PAGE = 30
         
-        attr_accessor :amount_pages
-
         # Create a new CollectionProxy to represent the specified view.  If a
         # container class is specified, the proxy will create an object of the
         # given type for each row that comes back from the view.  If no
@@ -122,11 +111,8 @@ module CouchRest
         def paginate(options = {})
           page, per_page = parse_options(options)
           results = @database.view(@view_name, pagination_options(page, per_page)) 
-          @amount_pages ||= (results['total_rows'].to_f / per_page.to_f).ceil
           remember_where_we_left_off(results, page)
           results = convert_to_container_array(results)
-          results.extend(PaginatedResults)
-          results.amount_pages = @amount_pages
           results
         end
 
@@ -204,8 +190,9 @@ module CouchRest
         def pagination_options(page, per_page)
           view_options = @view_options.clone
           if @last_key && @last_docid && @last_page == page - 1
-            view_options.delete(:key)
-            options = { :startkey => @last_key, :startkey_docid => @last_docid, :limit => per_page, :skip => 1 }
+            key = view_options.delete(:key)
+            end_key = view_options[:endkey] || key
+            options = { :startkey => @last_key, :endkey => end_key, :startkey_docid => @last_docid, :limit => per_page, :skip => 1 }
           else
             options = { :limit => per_page, :skip => per_page * (page - 1) }
           end

data/lib/couchrest/mixins/extended_attachments.rb

@@ -64,7 +64,7 @@ module CouchRest
         def set_attachment_attr(args)
           content_type = args[:content_type] ? args[:content_type] : get_mime_type(args[:file])
           self['_attachments'][args[:name]] = {
-            'content-type' => content_type,
+            'content_type' => content_type,
             'data'         => encode_attachment(args[:file].read)
           }
         end

data/lib/couchrest/mixins/extended_document_mixins.rb

@@ -6,3 +6,4 @@ require File.join(File.dirname(__FILE__), 'validation')
 require File.join(File.dirname(__FILE__), 'extended_attachments')
 require File.join(File.dirname(__FILE__), 'class_proxy')
 require File.join(File.dirname(__FILE__), 'collection')
+require File.join(File.dirname(__FILE__), 'attribute_protection')

data/lib/couchrest/mixins/properties.rb

@@ -27,7 +27,7 @@ module CouchRest
       class IncludeError < StandardError; end
       
       def self.included(base)
-        base.class_eval <<-EOS, __FILE__, __LINE__
+        base.class_eval <<-EOS, __FILE__, __LINE__ + 1
             extlib_inheritable_accessor(:properties) unless self.respond_to?(:properties)
             self.properties ||= []
         EOS
@@ -36,7 +36,7 @@ module CouchRest
       end
       
       def apply_defaults
-        return if self.respond_to?(:new_document?) && (new_document? == false)
+        return if self.respond_to?(:new?) && (new? == false)
         return unless self.class.respond_to?(:properties) 
         return if self.class.properties.empty?
         # TODO: cache the default object
@@ -56,50 +56,76 @@ module CouchRest
       def cast_keys
         return unless self.class.properties
         self.class.properties.each do |property|
-          next unless property.casted
-          key = self.has_key?(property.name) ? property.name : property.name.to_sym
-          # Don't cast the property unless it has a value
-          next unless self[key]   
-          target = property.type
-          if target.is_a?(Array)
-            klass = ::CouchRest.constantize(target[0])
-            self[property.name] = self[key].collect do |value|
-              # Auto parse Time objects
-              obj = ( (property.init_method == 'new') && klass == Time) ? Time.parse(value) : klass.send(property.init_method, value)
-              obj.casted_by = self if obj.respond_to?(:casted_by)
-              obj 
+          cast_property(property)
+        end
+      end
+      
+      def cast_property(property, assigned=false)
+        return unless property.casted
+        key = self.has_key?(property.name) ? property.name : property.name.to_sym
+        # Don't cast the property unless it has a value
+        return unless self[key]
+        if property.type.is_a?(Array)
+          klass = ::CouchRest.constantize(property.type[0])
+          arr = self[key].dup.collect do |value|
+            unless value.instance_of?(klass)
+              value = convert_property_value(property, klass, value)
             end
+            associate_casted_to_parent(value, assigned)
+            value
+          end
+          self[key] = klass != String ? CastedArray.new(arr) : arr
+          self[key].casted_by = self if self[key].respond_to?(:casted_by)
+        else
+          if property.type == 'boolean'
+            klass = TrueClass
           else
-            # Auto parse Time objects
-            self[property.name] = if ((property.init_method == 'new') && target == 'Time')
-              # Using custom time parsing method because Ruby's default method is toooo slow 
-              self[key].is_a?(String) ? Time.mktime_with_offset(self[key].dup) : self[key]
-            # Float instances don't get initialized with #new
-            elsif ((property.init_method == 'new') && target == 'Float')
-              cast_float(self[key])
-            # 'boolean' type is simply used to generate a property? accessor method
-            elsif ((property.init_method == 'new') && target == 'boolean')
-              self[key]
-            else
-              # Let people use :send as a Time parse arg
-              klass = ::CouchRest.constantize(target)
-              klass.send(property.init_method, self[key].dup)   
-            end  
-            self[property.name].casted_by = self if self[property.name].respond_to?(:casted_by)
-          end 
+            klass = ::CouchRest.constantize(property.type)
+          end
           
-        end
-        
-        def cast_float(value)
-          begin 
-            Float(value)
-          rescue 
-            value
+          unless self[key].instance_of?(klass)
+            self[key] = convert_property_value(property, klass, self[property.name])
           end
+          associate_casted_to_parent(self[property.name], assigned)
         end
         
       end
       
+      def associate_casted_to_parent(casted, assigned)
+        casted.casted_by = self if casted.respond_to?(:casted_by)
+        casted.document_saved = true if !assigned && casted.respond_to?(:document_saved)
+      end
+      
+      def convert_property_value(property, klass, value)
+        if ((property.init_method == 'new') && klass == Time)
+          # Using custom time parsing method because Ruby's default method is toooo slow
+          value.is_a?(String) ? Time.mktime_with_offset(value.dup) : value
+        # Float instances don't get initialized with #new
+        elsif ((property.init_method == 'new') && klass == Float)
+          cast_float(value)
+          # 'boolean' type is simply used to generate a property? accessor method
+        elsif ((property.init_method == 'new') && klass == TrueClass)
+          value
+        else
+          klass.send(property.init_method, value.dup)
+        end
+      end
+      
+      def cast_property_by_name(property_name)
+        return unless self.class.properties
+        property = self.class.properties.detect{|property| property.name == property_name}
+        return unless property
+        cast_property(property, true)
+      end
+      
+      def cast_float(value)
+        begin 
+          Float(value)
+        rescue
+          value
+        end
+      end
+      
       module ClassMethods
         
         def property(name, options={})
@@ -125,7 +151,7 @@ module CouchRest
           # defines the getter for the property (and optional aliases)
           def create_property_getter(property)
             # meth = property.name
-            class_eval <<-EOS, __FILE__, __LINE__
+            class_eval <<-EOS, __FILE__, __LINE__ + 1
               def #{property.name}
                 self['#{property.name}']
               end
@@ -144,7 +170,7 @@ module CouchRest
             end
 
             if property.alias
-              class_eval <<-EOS, __FILE__, __LINE__
+              class_eval <<-EOS, __FILE__, __LINE__ + 1
                 alias #{property.alias.to_sym} #{property.name.to_sym}
               EOS
             end
@@ -152,16 +178,17 @@ module CouchRest
 
           # defines the setter for the property (and optional aliases)
           def create_property_setter(property)
-            meth = property.name
+            property_name = property.name
             class_eval <<-EOS
-              def #{meth}=(value)
-                self['#{meth}'] = value
+              def #{property_name}=(value)
+                self['#{property_name}'] = value
+                cast_property_by_name('#{property_name}')
               end
             EOS
 
             if property.alias
               class_eval <<-EOS
-                alias #{property.alias.to_sym}= #{meth.to_sym}=
+                alias #{property.alias.to_sym}= #{property_name.to_sym}=
               EOS
             end
           end

data/lib/couchrest/mixins/validation.rb

@@ -50,7 +50,10 @@ module CouchRest
     
     def self.included(base)
       base.extlib_inheritable_accessor(:auto_validation)
-      base.class_eval <<-EOS, __FILE__, __LINE__
+      base.class_eval <<-EOS, __FILE__, __LINE__ + 1
+          # Callbacks
+          define_callbacks :validate
+          
           # Turn off auto validation by default
           self.auto_validation ||= false
           
@@ -71,9 +74,10 @@ module CouchRest
       EOS
       
       base.extend(ClassMethods)
-      base.class_eval <<-EOS, __FILE__, __LINE__
+      base.class_eval <<-EOS, __FILE__, __LINE__ + 1
+        define_callbacks :validate
         if method_defined?(:_run_save_callbacks)
-          save_callback :before, :check_validations
+          set_callback :save, :before, :check_validations
         end
       EOS
       base.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
@@ -115,8 +119,7 @@ module CouchRest
     # Check if a resource is valid in a given context
     #
     def valid?(context = :default)
-      result = self.class.validators.execute(context, self)
-      result && validate_casted_arrays
+      recursive_valid?(self, context, true)
     end
     
     # checking on casted objects
@@ -133,29 +136,24 @@ module CouchRest
       result
     end
 
-    # Begin a recursive walk of the model checking validity
-    #
-    def all_valid?(context = :default)
-      recursive_valid?(self, context, true)
-    end
-
     # Do recursive validity checking
     #
     def recursive_valid?(target, context, state)
       valid = state
-      target.instance_variables.each do |ivar|
-        ivar_value = target.instance_variable_get(ivar)
-        if ivar_value.validatable?
-          valid = valid && recursive_valid?(ivar_value, context, valid)
-        elsif ivar_value.respond_to?(:each)
-          ivar_value.each do |item|
+      target.each do |key, prop|
+        if prop.is_a?(Array)
+          prop.each do |item|
             if item.validatable?
-              valid = valid && recursive_valid?(item, context, valid)
+              valid = recursive_valid?(item, context, valid) && valid
             end
           end
+        elsif prop.validatable?
+          valid = recursive_valid?(prop, context, valid) && valid
         end
       end
-      return valid && target.valid?
+      target._run_validate_callbacks do
+        target.class.validators.execute(context, target) && valid
+      end
     end
 
 
@@ -212,21 +210,12 @@ module CouchRest
       def create_context_instance_methods(context)
         name = "valid_for_#{context.to_s}?"           # valid_for_signup?
         if !self.instance_methods.include?(name)
-          class_eval <<-EOS, __FILE__, __LINE__
+          class_eval <<-EOS, __FILE__, __LINE__ + 1
             def #{name}                               # def valid_for_signup?
               valid?('#{context.to_s}'.to_sym)        #   valid?('signup'.to_sym)
             end                                       # end
           EOS
         end
-
-        all = "all_valid_for_#{context.to_s}?"        # all_valid_for_signup?
-        if !self.instance_methods.include?(all)
-          class_eval <<-EOS, __FILE__, __LINE__
-            def #{all}                                # def all_valid_for_signup?
-              all_valid?('#{context.to_s}'.to_sym)    #   all_valid?('signup'.to_sym)
-            end                                       # end
-          EOS
-        end
       end
 
       # Create a new validator of the given klazz and push it onto the

data/lib/couchrest/more/casted_model.rb

@@ -5,8 +5,10 @@ module CouchRest
   module CastedModel
     
     def self.included(base)
+      base.send(:include, ::CouchRest::Callbacks)
       base.send(:include, ::CouchRest::Mixins::Properties)
       base.send(:attr_accessor, :casted_by)
+      base.send(:attr_accessor, :document_saved)
     end
     
     def initialize(keys={})
@@ -26,5 +28,31 @@ module CouchRest
     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
+end

data/lib/couchrest/more/extended_document.rb

@@ -14,6 +14,7 @@ module CouchRest
     include CouchRest::Mixins::ExtendedAttachments
     include CouchRest::Mixins::ClassProxy
     include CouchRest::Mixins::Collection
+		include CouchRest::Mixins::AttributeProtection
 
     def self.subclasses
       @subclasses ||= []
@@ -21,7 +22,7 @@ module CouchRest
     
     def self.inherited(subklass)
       subklass.send(:include, CouchRest::Mixins::Properties)
-      subklass.class_eval <<-EOS, __FILE__, __LINE__
+      subklass.class_eval <<-EOS, __FILE__, __LINE__ + 1
         def self.inherited(subklass)
           subklass.properties = self.properties.dup
         end
@@ -33,18 +34,14 @@ module CouchRest
     attr_accessor :casted_by
     
     # Callbacks
-    define_callbacks :create
-    define_callbacks :save
-    define_callbacks :update
-    define_callbacks :destroy
+    define_callbacks :create, "result == :halt"
+    define_callbacks :save, "result == :halt"
+    define_callbacks :update, "result == :halt"
+    define_callbacks :destroy, "result == :halt"
     
     def initialize(passed_keys={})
       apply_defaults # defined in CouchRest::Mixins::Properties
-      passed_keys.each do |k,v|
-        if self.respond_to?("#{k}=")
-          self.send("#{k}=", passed_keys.delete(k))
-        end
-      end if passed_keys
+	  set_attributes(passed_keys) unless passed_keys.nil?
       super
       cast_keys      # defined in CouchRest::Mixins::Properties
       unless self['_id'] && self['_rev']
@@ -76,17 +73,17 @@ module CouchRest
     # 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__
+      class_eval <<-EOS, __FILE__, __LINE__ + 1
         property(:updated_at, :read_only => true, :cast_as => 'Time', :auto_validation => false)
         property(:created_at, :read_only => true, :cast_as => 'Time', :auto_validation => false)
         
-        save_callback :before do |object|
+        set_callback :save, :before do |object|
           object['updated_at'] = Time.now
-          object['created_at'] = object['updated_at'] if object.new_document?
+          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,
@@ -128,17 +125,32 @@ module CouchRest
       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)
-      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
+      # 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
@@ -149,7 +161,8 @@ module CouchRest
     end
 
     # for compatibility with old-school frameworks
-    alias :new_record? :new_document?
+    alias :new_record? :new?
+    alias :new_document? :new?
     
     # Trigger the callbacks (before, after, around)
     # and create the document
@@ -170,7 +183,7 @@ module CouchRest
     # 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_document? && self.respond_to?(:set_unique_id)
+      set_unique_id if new? && self.respond_to?(:set_unique_id)
       result = database.save_doc(self, bulk)
       (result["ok"] == true) ? self : false
     end
@@ -185,7 +198,7 @@ module CouchRest
     # only if the document isn't new
     def update(bulk = false)
       caught = catch(:halt)  do
-        if self.new_document?
+        if self.new?
           save(bulk)
         else
           _run_update_callbacks do
@@ -201,7 +214,7 @@ module CouchRest
     # and save the document
     def save(bulk = false)
       caught = catch(:halt)  do
-        if self.new_document?
+        if self.new?
           _run_save_callbacks do
             save_without_callbacks(bulk)
           end
@@ -215,8 +228,9 @@ module CouchRest
     # 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_document? && self.respond_to?(:set_unique_id)
+      set_unique_id if new? && self.respond_to?(:set_unique_id)
       result = database.save_doc(self, bulk)
+      mark_as_saved 
       result["ok"] == true
     end
     
@@ -224,6 +238,7 @@ module CouchRest
     # 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.
@@ -242,5 +257,38 @@ module CouchRest
       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 set_attributes(hash)
+			attrs = remove_protected_attributes(hash)
+      attrs.each do |attribute_name, attribute_value|
+        if self.respond_to?("#{attribute_name}=")
+          self.send("#{attribute_name}=", attrs.delete(attribute_name))
+        end
+      end
+		end
   end
 end