georgepalmer-couch_foo 0.7.3 → 0.7.4

data/README.rdoc

@@ -35,7 +35,7 @@ Basic operations are the same as ActiveRecord:
   class Address < CouchFoo::Base
     property :number, Integer
     property :street, String
-    property :postcode # Any generic type is fine as long as .to_json can be called on it
+    property :postcode # Any generic type is fine as long as .to_json and class.from_json(json) can be called on it
   end 
 
   address1 = Address.create(:number => 3, :street => "My Street", :postcode => "secret") # Create address

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 7
-:patch: 3
+:patch: 4

data/lib/couch_foo/attribute_methods.rb

@@ -191,15 +191,7 @@ module CouchFoo
     # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
     # "2004-12-12" in a data type is cast to a date object, like Date.new(2004, 12, 12)).
     def read_attribute(attr_name)
-      if !(value = @attributes[attr_name.to_s]).nil?
-        if type = type_for_property(attr_name.to_sym)
-          convert_to_type(value, type)
-        else
-          value
-        end
-      else
-        nil
-      end
+      convert_to_type(@attributes[attr_name.to_s], type_for_property(attr_name.to_sym))
     end
 
     def read_attribute_before_type_cast(attr_name)
@@ -211,7 +203,7 @@ module CouchFoo
     def write_attribute(attr_name, value)
       attr_name = attr_name.to_s
       @attributes_cache.delete(attr_name)
-      @attributes[attr_name] = value
+      @attributes[attr_name] = convert_to_json(value, type_for_property(attr_name.to_sym))
     end
 
     def query_attribute(attr_name)
@@ -259,15 +251,46 @@ module CouchFoo
     end
 
     protected
-    # Converts a value to its type, or if not specified tries calling to_json on the value before
+    def convert_to_json(value, type)
+      return nil if value.nil?
+
+      #Not keen on type hack for case statement
+      case type.to_s
+        when "String"
+          value.to_s
+        when "Integer"
+          value.to_i
+        when "Float"
+          value.to_f
+        when "DateTime"
+          DateTime.parse(value.to_s).strftime("%Y/%m/%d %H:%M:%S +0000")
+        when "Time"
+          Time.at(value.to_f).strftime("%Y/%m/%d %H:%M:%S +0000")
+        when "Date"
+          Date.new(value.year, value.month, value.day).strftime("%Y/%m/%d %H:%M:%S +0000")
+        when "TrueClass"
+          convert_boolean(value)
+        when "Boolean"
+          convert_boolean(value)
+        else
+          # Calling to_json on Array or Hash makes them strings = bad
+          if value.is_a?(Array) || value.is_a?(Hash)
+            value
+          else
+            value.to_json rescue value
+          end
+      end
+    end
+
+    # Converts a value to its type, or if not specified tries calling from_json on the value before
     # falling back on just using the value
     def convert_to_type(value, type)
       return nil if value.nil?
-      
+
       #Not keen on type hack for case statement
       case type.to_s
         when "String"
-          value
+          value.to_s
         when "Integer"
           value.to_i
         when "Float"
@@ -283,7 +306,7 @@ module CouchFoo
         when "Boolean"
           convert_boolean(value)
         else
-          value.to_json rescue value
+          type.from_json(value) rescue value
       end
     end
 

data/lib/couch_foo/base.rb

@@ -109,7 +109,7 @@ module CouchFoo
   #   class Address < CouchFoo::Base
   #     property :number, Integer
   #     property :street, String
-  #     property :postcode # Any generic type is fine as long as .to_json can be called on it
+  #     property :postcode # Any generic type is fine as long as .to_json and class.from_json(json) can be called on it
   #   end
   #
   # Documents have three more properties that get added automatically.  _id and _rev are CouchDB
@@ -1030,9 +1030,11 @@ module CouchFoo
       
       # Set a property for the document.  These can be passed a type and options hash.  If no type
       # is passed a #to_json method is called on the ruby object and the result stored in the 
-      # database.  If a type is passed then the object is cast before storing in the database.  This
-      # does not guarantee that the object is the correct type (use the validaters for that), it
-      # merely tries to convert the current type to the desired one - for example:
+      # database.  When it is retrieved from the database a class.from_json(json) method is called
+      # on it or if that doesn't exist it just uses the value.  If a type is passed then the object
+      # is cast before storing in the database.  This does not guarantee that the object is the
+      # correct type (use the validaters for that), it merely tries to convert the current type to
+      # the desired one - for example:
       # '123' => 123 # useful
       # 'a' => 0 # probably not desired behaviour
       # The later would fail with a validator
@@ -1046,10 +1048,11 @@ module CouchFoo
       #   property :number, Integer
       #   property :paid, TrueClass, :default => false
       #   property :notes, String
-      #   property :acl
+      #   property :acl # or acl, Object is equivalent
+      #   property :price, Price
       # end  
-      def property(name, type = nil, options = {})
-        logger.warn("Using type as a column name may issue unexpected behaviour") if name == :type
+      def property(name, type = Object, options = {})
+        logger.warn("Using type as a property name may issue unexpected behaviour") if name == :type
         properties.delete_if{|e| e.name == name} # Subset properties override
         properties << Property.new(name, type, options[:default])
       end
@@ -1295,25 +1298,17 @@ module CouchFoo
               allocate
             end
 
-        object.instance_variable_set("@attributes", check_document_types(document))
+        object.instance_variable_set("@attributes", check_document_attributes(document))
         object.instance_variable_set("@attributes_cache", Hash.new)
         object
       end
       
-      # Checks that the document only contains types that are listed as properties.  Also converts 
-      # Date, DateTime and Time types into ruby objects (as we write them to the database in a JSON
-      # format suitable for sorting)
-      def check_document_types(record)
-        property_types.each do |property, type|
-          value = record[property.to_s]
-          if (type == Date || type == DateTime || type == Time)
-            record[property.to_s] = type.send(:parse, value) rescue nil
-          else
-            # Seems pointless but ensures we get attributes for properties that have been added to
-            # model since document last saved 
-            record[property.to_s] = value
-          end
-        end
+      # Checks that the document only contains types that are listed as properties
+      def check_document_attributes(record)
+        # Add new properties
+        (property_names.map{|p| p.to_s} - record.keys).each {|k| record[k] = nil}
+
+        # Remove old properties
         record.reject!{|key, value| !(unchangeable_property_names + property_names).include?(key.to_sym)}
         record
       end
@@ -1941,7 +1936,7 @@ module CouchFoo
     
     def update
       begin
-        response = self.class.database.save(attributes_for_save)
+        response = self.class.database.save(attributes_before_type_cast)
         @attributes["_rev"] = response['rev']
         1
       rescue Exception => e
@@ -1953,7 +1948,7 @@ module CouchFoo
     def create
       @attributes["_id"] = self.class.get_uuid
       begin
-        response = self.class.database.save(attributes_for_save.reject{|key,value| key == "_rev"})
+        response = self.class.database.save(attributes_before_type_cast.reject{|key,value| key == "_rev"})
         @attributes["_rev"] = response['rev']
         @new_record = false
         @attributes["_id"]
@@ -1964,18 +1959,6 @@ module CouchFoo
       end
     end
     
-    # Attributes but with date/time types convert to JSON sortable format.  This creates a copy of
-    # the original attributes for saving so doesn't alter the attributes accessible to the user
-    def attributes_for_save
-      attrs = attributes
-      self.class.property_types.each do |name, type|
-        if (type == Date || type == DateTime || type == Time)
-          attrs[name.to_s] = attrs[name.to_s].strftime("%Y/%m/%d %H:%M:%S +0000") if attrs[name.to_s]
-        end
-      end
-      attrs
-    end
-    
     # Sets the attribute used for inheritance to this class name if this is not the CouchFoo::Base 
     # descendent.  Considering the hierarchy Reply < Message < ActiveRecord::Base, this makes it 
     # possible to do Reply.new without having to set <tt>Reply[Reply.inheritance_column] = "Reply"</tt>

data/lib/couch_foo/view_methods.rb

@@ -122,6 +122,7 @@ module CouchFoo
         search_fields = options.delete(:use_key)
         if search_fields
           search_fields = [search_fields] unless search_fields.is_a?(Array)
+          search_fields = search_fields.sort_by{|f| f.to_s}
         else
           search_fields = options[:conditions].to_a.sort_by{|f| f.first.to_s}.map(&:first)
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: georgepalmer-couch_foo
 version: !ruby/object:Gem::Version 
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors: 
 - George Palmer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-05 00:00:00 -08:00
+date: 2009-02-06 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency