couchrest_extended_document 1.0.0.beta6 → 1.0.0

data/lib/couchrest/mixins.rb

@@ -9,3 +9,4 @@ require File.join(mixins_dir, 'extended_attachments')
 require File.join(mixins_dir, 'class_proxy')
 require File.join(mixins_dir, 'collection')
 require File.join(mixins_dir, 'attribute_protection')
+require File.join(mixins_dir, 'attributes')

data/lib/couchrest/mixins/attributes.rb

@@ -0,0 +1,75 @@
+module CouchRest
+  module Mixins
+    module Attributes
+
+      ## Support for handling attributes
+      # 
+      # This would be better in the properties file, but due to scoping issues
+      # this is not yet possible.
+      #
+
+      def prepare_all_attributes(doc = {}, options = {})
+        apply_all_property_defaults
+        if options[:directly_set_attributes]
+          directly_set_read_only_attributes(doc)          
+        else
+          remove_protected_attributes(doc)
+        end
+        directly_set_attributes(doc) unless doc.nil?
+      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 any protected and update all the rest. Any attributes
+        # which do not have a property will simply be ignored.
+        attrs = remove_protected_attributes(hash)
+        directly_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
+
+      private
+
+      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 directly_set_read_only_attributes(hash)
+        property_list = self.properties.map{|p| p.name}
+        hash.each do |attribute_name, attribute_value|
+          next if self.respond_to?("#{attribute_name}=")
+          if property_list.include?(attribute_name)
+            write_attribute(attribute_name, hash.delete(attribute_name))
+          end
+        end
+      end
+      
+      def set_attributes(hash)
+        attrs = remove_protected_attributes(hash)
+        directly_set_attributes(attrs)
+      end
+
+      def check_properties_exist(attrs)
+        property_list = self.properties.map{|p| p.name}
+        attrs.each do |attribute_name, attribute_value|
+          raise NoMethodError, "Property #{attribute_name} not created" unless respond_to?("#{attribute_name}=") or property_list.include?(attribute_name)
+        end      
+      end
+
+    end
+  end
+end
+

data/lib/couchrest/mixins/callbacks.rb

@@ -370,6 +370,8 @@ module CouchRest
       end
 
       module ClassMethods
+        extend CouchRest::InheritableAttributes
+
         #CHAINS = {:before => :before, :around => :before, :after => :after}
 
         # Make the _run_save_callbacks method. The generated method takes
@@ -497,9 +499,9 @@ module CouchRest
         def define_callbacks(*symbols)
           terminator = symbols.pop if symbols.last.is_a?(String)
           symbols.each do |symbol|
-            extlib_inheritable_accessor("_#{symbol}_terminator") { terminator }
+            couchrest_inheritable_accessor("_#{symbol}_terminator") { terminator }
 
-            extlib_inheritable_accessor("_#{symbol}_callback") do
+            couchrest_inheritable_accessor("_#{symbol}_callback") do
               CallbackChain.new(symbol)
             end
 

data/lib/couchrest/mixins/properties.rb

@@ -1,7 +1,6 @@
 require 'time'
 require File.join(File.dirname(__FILE__), '..', 'property')
 require File.join(File.dirname(__FILE__), '..', 'casted_array')
-require File.join(File.dirname(__FILE__), '..', 'typecast')
 
 module CouchRest
   module Mixins
@@ -9,80 +8,45 @@ module CouchRest
       
       class IncludeError < StandardError; end
       
-      include ::CouchRest::More::Typecast
-
       def self.included(base)
         base.class_eval <<-EOS, __FILE__, __LINE__ + 1
-            extlib_inheritable_accessor(:properties) unless self.respond_to?(:properties)
+            extend CouchRest::InheritableAttributes
+            couchrest_inheritable_accessor(:properties) unless self.respond_to?(:properties)
             self.properties ||= []
         EOS
         base.extend(ClassMethods)
         raise CouchRest::Mixins::Properties::IncludeError, "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 (base.new.respond_to?(:[]) && base.new.respond_to?(:[]=))
       end
-      
-      def apply_defaults
+
+      # Returns the Class properties
+      #
+      # ==== Returns
+      # Array:: the list of properties for model's class
+      def properties
+        self.class.properties
+      end
+
+      def read_attribute(property)
+        self[property.to_s]
+      end
+
+      def write_attribute(property, value)
+        prop = property.is_a?(::CouchRest::Property) ? property : self.class.properties.detect {|p| p.to_s == property.to_s}
+        raise "Missing property definition for #{property.to_s}" unless prop
+        self[prop.to_s] = prop.cast(self, value)
+      end
+
+      def apply_all_property_defaults
         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
         self.class.properties.each do |property|
-          key = property.name.to_s
-          # let's make sure we have a default
-          unless property.default.nil?
-              if property.default.class == Proc
-                self[key] = property.default.call
-              else
-                self[key] = Marshal.load(Marshal.dump(property.default))
-              end
-            end
-        end
-      end
-      
-      def cast_keys
-        return unless self.class.properties
-        self.class.properties.each do |property|
-          cast_property(property)
+          write_attribute(property, property.default_value)
         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 = property.type[0]
-          self[key] = [self[key]] unless self[key].is_a?(Array)
-          arr = self[key].collect do |value|
-            value = typecast_value(value, klass, property.init_method)
-            associate_casted_to_parent(value, assigned)
-            value
-          end
-          # allow casted_by calls to be passed up chain by wrapping in CastedArray
-          self[key] = klass != String ? ::CouchRest::CastedArray.new(arr) : arr
-          self[key].casted_by = self if self[key].respond_to?(:casted_by)
-        else
-          self[key] = typecast_value(self[key], property.type, property.init_method)
-          associate_casted_to_parent(self[key], 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 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
-      
      
       module ClassMethods
         
-        def property(name, *options)
+        def property(name, *options, &block)
           opts = { }
           type = options.shift
           if type.class != Hash
@@ -93,21 +57,29 @@ module CouchRest
           end
           existing_property = self.properties.find{|p| p.name == name.to_s}
           if existing_property.nil? || (existing_property.default != opts[:default])
-            define_property(name, opts)
+            define_property(name, opts, &block)
           end
         end
         
         protected
         
           # This is not a thread safe operation, if you have to set new properties at runtime
-          # make sure to use a mutex.
-          def define_property(name, options={})
+          # make sure a mutex is used.
+          def define_property(name, options={}, &block)
             # check if this property is going to casted
-            options[:casted] = !!(options[:cast_as] || options[:type])
-            property = CouchRest::Property.new(name, (options.delete(:cast_as) || options.delete(:type)), options)
+            type = options.delete(:type) || options.delete(:cast_as)
+            if block_given?
+              type = Class.new(Hash) do
+                include CastedModel
+              end
+              type.class_eval { yield type }
+              type = [type] # inject as an array
+            end
+            property = CouchRest::Property.new(name, type, options)
             create_property_getter(property) 
             create_property_setter(property) unless property.read_only == true
             properties << property
+            property
           end
           
           # defines the getter for the property (and optional aliases)
@@ -115,18 +87,15 @@ module CouchRest
             # meth = property.name
             class_eval <<-EOS, __FILE__, __LINE__ + 1
               def #{property.name}
-                self['#{property.name}']
+                read_attribute('#{property.name}')
               end
             EOS
 
             if ['boolean', TrueClass.to_s.downcase].include?(property.type.to_s.downcase)
               class_eval <<-EOS, __FILE__, __LINE__
                 def #{property.name}?
-                  if self['#{property.name}'].nil? || self['#{property.name}'] == false
-                    false
-                  else
-                    true
-                  end
+                  value = read_attribute('#{property.name}')
+                  !(value.nil? || value == false)
                 end
               EOS
             end
@@ -143,8 +112,7 @@ module CouchRest
             property_name = property.name
             class_eval <<-EOS
               def #{property_name}=(value)
-                self['#{property_name}'] = value
-                cast_property_by_name('#{property_name}')
+                write_attribute('#{property_name}', value)
               end
             EOS
 

data/lib/couchrest/{typecast.rb → mixins/typecast.rb}

@@ -1,7 +1,6 @@
 require 'time'
 require 'bigdecimal'
 require 'bigdecimal/util'
-require File.join(File.dirname(__FILE__), 'property')
 
 class Time                       
   # returns a local time value much faster than Time.parse
@@ -23,19 +22,19 @@ class Time
 end
 
 module CouchRest
-  module More
+  module Mixins
     module Typecast
 
-      def typecast_value(value, klass, init_method)
+      def typecast_value(value, property) # klass, init_method)
         return nil if value.nil?
-        klass = klass.constantize unless klass.is_a?(Class)
+        klass = property.type_class
         if value.instance_of?(klass) || klass == Object
           value
         elsif [String, TrueClass, Integer, Float, BigDecimal, DateTime, Time, Date, Class].include?(klass)
           send('typecast_to_'+klass.to_s.downcase, value)
         else
           # Allow the init_method to be defined as a Proc for advanced conversion
-          init_method.is_a?(Proc) ? init_method.call(value) : klass.send(init_method, value)
+          property.init_method.is_a?(Proc) ? property.init_method.call(value) : klass.send(property.init_method, value)
         end
       end
 

data/lib/couchrest/property.rb

@@ -1,47 +1,93 @@
+
+require File.join(File.dirname(__FILE__), 'mixins', 'typecast')
+
 module CouchRest
 
   # Basic attribute support for adding getter/setter + validation
   class Property
+
+    include ::CouchRest::Mixins::Typecast
+
     attr_reader :name, :type, :read_only, :alias, :default, :casted, :init_method, :options
 
-    # attribute to define
+    # Attribute to define.
+    # All Properties are assumed casted unless the type is nil.
     def initialize(name, type = nil, options = {})
       @name = name.to_s
+      @casted = true
       parse_type(type)
       parse_options(options)
       self
     end
 
+    def to_s
+      name
+    end
+
+    # Cast the provided value using the properties details.
+    def cast(parent, value)
+      return value unless casted
+      if type.is_a?(Array)
+        # Convert to array if it is not already
+        value = [value].compact unless value.is_a?(Array)
+        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 ? ::CouchRest::CastedArray.new(arr, self) : arr
+        value.casted_by = parent if value.respond_to?(:casted_by)
+      elsif !value.nil?
+        value = cast_value(parent, value)
+      end
+      value
+    end
+
+    # Cast an individual value, not an array
+    def cast_value(parent, value)
+      raise "An array inside an array cannot be casted, use CastedModel" if value.is_a?(Array)
+      value = typecast_value(value, self)
+      associate_casted_value_to_parent(parent, value)
+    end
+
+    def default_value
+      return if default.nil?
+      if default.class == Proc
+        default.call
+      else
+        Marshal.load(Marshal.dump(default))
+      end
+    end
+
+    # Always provide the basic type as a class. If the type 
+    # is an array, the class will be extracted.
+    def type_class
+      return String unless casted # This is rubbish, to handle validations
+      return @type_class unless @type_class.nil?
+      base = @type.is_a?(Array) ? @type.first : @type
+      base = String if base.nil?
+      base = TrueClass if base.is_a?(String) && base.downcase == 'boolean'
+      @type_class = base.is_a?(Class) ? base : base.constantize
+    end
+
     private
 
+      def associate_casted_value_to_parent(parent, value)
+        value.casted_by = parent if value.respond_to?(:casted_by)
+        value
+      end
+
       def parse_type(type)
         if type.nil?
-          @type = String
-        elsif type.is_a?(Array) && type.empty?
-          @type = [Object]
+          @casted = false
+          @type = nil 
         else
-          base_type = type.is_a?(Array) ? type.first : type
-          if base_type.is_a?(String)
-            if base_type.downcase == 'boolean'
-              base_type = TrueClass 
-            else
-              begin
-                base_type = base_type.constantize
-              rescue  # leave base type as a string and convert in more/typecast
-              end
-            end
-          end
-          @type = type.is_a?(Array) ? [base_type] : base_type 
+          @type = type
         end
       end
 
       def parse_options(options)
-        return if options.empty?
         @validation_format  = options.delete(:format)     if options[:format]
         @read_only          = options.delete(:read_only)  if options[:read_only]
         @alias              = options.delete(:alias)      if options[:alias]
         @default            = options.delete(:default)    unless options[:default].nil?
-        @casted             = options[:casted] ? true : false
         @init_method        = options[:init_method] ? options.delete(:init_method) : 'new'
         @options            = options
       end

data/lib/couchrest/validation.rb

@@ -48,8 +48,10 @@ module CouchRest
   module Validation
     
     def self.included(base)
-      base.extlib_inheritable_accessor(:auto_validation)
       base.class_eval <<-EOS, __FILE__, __LINE__ + 1
+          extend CouchRest::InheritableAttributes
+          couchrest_inheritable_accessor(:auto_validation)
+
           # Callbacks
           define_callbacks :validate
           
@@ -80,10 +82,9 @@ module CouchRest
         end
       EOS
       base.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-        def self.define_property(name, options={})
-          super
-          auto_generate_validations(properties.last) if properties && properties.size > 0
-          autovalidation_check = true
+        def self.define_property(name, options={}, &block)
+          property = super
+          auto_generate_validations(property) unless property.nil?
         end
       RUBY_EVAL
     end