purzelrakete-restful 0.2.6 → 0.2.7

data/TODO.markdown

@@ -5,4 +5,5 @@ Refactor this shice. Seriously, this has devolved into some nasty-ass code.
 * move configuration object out of rails folder - this is general stuff. 
 * remove xml serialization here and test resource directly (in active_record_converter_test)
 * get rid of to_a warning
-* convert underscores to dashes (or not) in serializers instead of converter
+* convert underscores to dashes (or not) in serializers instead of converter
+* implement xml serialization of hashes

data/lib/restful.rb

@@ -3,6 +3,7 @@ require 'restful/rails/active_record/configuration'
 require 'restful/rails/active_record/metadata_tools'
 require 'restful/rails/action_controller'
 require 'restful/converters/active_record'
+require 'restful/apimodel/map'
 require 'restful/apimodel/resource'
 require 'restful/apimodel/attribute'
 require 'restful/apimodel/collection'

data/lib/restful/apimodel/resource.rb

@@ -3,40 +3,16 @@
 #
 module Restful
   module ApiModel
-    class Resource
-      attr_accessor :base, :path, :url, :values, :name, :type
+    class Resource < Map
+      attr_accessor :base, :path, :url
       
       def initialize(name, url)
+        super(name)
+        
         self.url = url[:url]
         self.path = url[:path]
         self.base = url[:base]                
-        self.name = name
         self.type = :resource
-        self.values = []
-      end
-      
-      def links
-        self.values.select { |attribute| attribute.type == :link }
-      end
-      
-      def simple_attributes
-        self.values.select { |attribute| attribute.type == :simple_attribute }        
-      end
-      
-      def collections
-        self.values.select { |attribute| attribute.type == :collection }
-      end
-      
-      # invoke serialization
-      def serialize(type)
-        serializer = Restful::Serializers::Base.serializer(type)
-        serializer.serialize(self)
-      end
-      
-      # invoke deserialization
-      def deserialize_from(type)
-        serializer = Restful::Serializers::Base.serializer(type)
-        serializer.deserialize(self)
       end
       
       def full_url

data/lib/restful/rails/active_record/configuration.rb

@@ -39,11 +39,11 @@ module Restful
             add_to_whitelist = []
 
             if config && config.is_a?(Hash) && config.keys.size == 1 && includes = config[:include] 
-              add_to_whitelist = [*includes]
+              add_to_whitelist = [*includes].map { |el| el.is_a?(String) ? el.to_sym : el  }
               config = nil
             end
             
-            config ||= self.class.restful_config if self.class.respond_to?(:restful_config)
+            config ||= self.class.restful_config.clone if self.class.respond_to?(:restful_config)
             config ||= []
             
             if config && !config.is_a?(Config)
@@ -51,11 +51,12 @@ module Restful
             end
             
             if self.class.respond_to?(:restful_config)
-              config.whitelisted = self.class.restful_config.whitelisted if config.whitelisted.empty?
+              config.whitelisted = Array.new(self.class.restful_config.whitelisted) if config.whitelisted.empty?
               config.restful_options.merge! self.class.restful_config.restful_options
             end
             
             config.whitelisted += add_to_whitelist
+            config.whitelisted = config.whitelisted.uniq
             
             # array
             if self.is_a?(Array)
@@ -66,11 +67,19 @@ module Restful
               
               element_name = elements.first ? elements.first.name.pluralize : "nil-classes"
               
-              collection = returning Restful.collection(element_name, elements, :array) do |collection|
+              returning Restful.collection(element_name, elements, :array) do |collection|
                 collection.total_entries = self.total_entries if self.respond_to?(:total_entries)
-              end          
-
-              collection    
+              end
+                        
+            elsif self.is_a?(Hash)
+              elements = self.map do |k,v|
+                value = v.respond_to?(:to_restful) ? Restful::Converters::ActiveRecord.convert(v, v.class.restful_config) : v
+                Restful::ApiModel::Attribute.new(k, value, :map)
+              end
+              
+              map = Restful::ApiModel::Map.new("hash")
+              map.values =  elements
+              map
             else
               Restful::Converters::ActiveRecord.convert(self, config)
             end

data/lib/restful/serializers/base.rb

@@ -29,6 +29,8 @@ module Restful
       end
       
       def formatted_value(value)
+        return value unless value.respond_to?(:value)
+        
         return nil if value.value.blank? && value.extended_type != :false_class
         case value.extended_type
         when :datetime

data/lib/restful/serializers/hash_serializer.rb

@@ -10,9 +10,13 @@ module Restful
       serializer_name :hash
       
       def serialize(resource, options = {})
-        resource.is_a?(Restful::ApiModel::Collection) ?
-          serialize_collection(resource) :
+        case resource
+        when Restful::ApiModel::Collection then serialize_collection(resource)
+        when Restful::ApiModel::Resource   then serialize_tuples(resource.values, resource.full_url)
+        when Restful::ApiModel::Map        then serialize_map(resource)
+        else
           serialize_tuples(resource.values, resource.full_url)
+        end
       end
 
       private      
@@ -27,6 +31,13 @@ module Restful
           values
         end
         
+        def serialize_map(map)
+          map.values.inject({}) do |memo, attribute|
+            memo[attribute.name] = serialize_value(attribute.value)
+            memo
+          end
+        end
+        
         def serialize_tuples(tuples, url)
           tuples.inject({ "restful_url" => url }) do |params, value|
             params[value.name.to_s.tr("-", "_").to_sym] = serialize_value(value)

data/lib/restful/serializers/xml_serializer.rb

@@ -17,6 +17,8 @@ module Restful
         xml = options[:builder] || Builder::XmlMarkup.new(:indent => 2)
         xml.instruct! unless options[:instruct].is_a?(FalseClass)
         
+        raise NotImplementedError.new("xml serialization of maps has not been implemented. ") if resource.class == Restful::ApiModel::Map
+        
         if resource.is_a?(Restful::ApiModel::Collection)
           add_collection(resource, xml, show_as_array = false)
         else        

data/restful.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "restful"
-  s.version = "0.2.6"
+  s.version = "0.2.7"
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Daniel Bornkessel", "Rany Keddo"] 
   s.date = "2009-08-11"

data/test/fixtures/people.json.yaml

@@ -67,4 +67,14 @@ bloggs_da_pet_hater:
       "name": "Joe Bloggs",
       "pets": [],
       "created_at": "<%= @person.created_at.xmlschema %>"
+    }
+    
+hash_with_person:
+  |
+    { 
+      "total_hits": 10, 
+      "a_person": {
+        "restful_url": "http://example.com:3000/people/<%= @person.to_param %>",
+        "name": "Joe Bloggs"
+      }
     }

data/test/rails/restful_publish_test.rb

@@ -26,6 +26,7 @@ context "restful publish" do
     @pet = @person.pets.create(:name => "Mietze")
 
     @pet.to_restful(:include => :owner).values.map(&:name).should.include :owner
+    Pet.restful_config.whitelisted.should.not.include? :owner
   end
 end
 

data/test/serializers/json_serializer_test.rb

@@ -69,4 +69,9 @@ context "json serializer" do
 
     json_should_eql_fixture(pets.to_restful_json, "pets", :pets_array_with_total_entries)
   end
+  
+  specify "should be able to serialize a map" do
+    Person.restful_publish(:name)
+    json_should_eql_fixture({ "total_hits" => 10, "a_person" => @person }.to_restful_json, "people", :hash_with_person)
+  end
 end

data/test/serializers/xml_serializer_test.rb

@@ -44,7 +44,7 @@ context "params serializer" do
     @person.pets.create(:species => "cat", :age => 100, :name => "motze")
     xml_should_eql_fixture(@person.to_restful_xml(:pets_ages_hash), "people", :hashy_person)
   end
-  
+    
   specify "should serialize collections correctly" do
     xml_should_eql_fixture(@person.pets.to_restful_xml, "pets", :pets_array)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: purzelrakete-restful
 version: !ruby/object:Gem::Version 
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors: 
 - Daniel Bornkessel