purzelrakete-restful 0.2.1 → 0.2.2

data/README.markdown

@@ -31,8 +31,7 @@ Some example configurations:
 restful_publish :name, :pets, :restful_options => { :expansion => :expanded } # default on level 1-2: expanded. default above: collapsed. 
 restful_publish :name, :pets, :wallet => :contents, :restful_options => { :expansion => :expanded } # combined options and expansion rules
 restful_publish :name, :pets, :restful_options => { :collapsed => :pets } # collapsed pets, even though they are on the second level. 
-restful_publish :name, :pets, :restful_options => { :expanded => [:pets, :wallet] }
-restful_publish :name, :pets, :restful_options => { :pets_page => 1, :pets_per_page => 100, :collapsed => :pets }
+restful_publish :name, :pets, :restful_options => { :force_expanded => [:pets, :wallet] }
 
 # Pet
 restful_publish :name, :person # expands person per default because it is on the second level. Does not expand person.pets.first.person, since this is higher than second level.
@@ -42,7 +41,9 @@ Rails-like
 
 This format sticks to xml_simple, adding links as `<association-name-restful-url>` nodes of type "link".
 
-`Person.last.to_restful.serialize(:xml)` results in something like...
+
+`Person.last.to_restful.serialize(:xml)` OR
+`Person.last.to_restful_xml` results in something like...
 
   <?xml version="1.0" encoding="UTF-8"?>
   <person>
@@ -66,7 +67,8 @@ This format sticks to xml_simple, adding links as `<association-name-restful-url
 Atom-like
 =========
 
-`Person.last.to_restful.serialize(:atom_like)` results in something like...
+`Person.last.to_restful.serialize(:atom_like)` OR
+`Person.last.to_restful_atom_like` results in something like...
 
   <?xml version="1.0" encoding="UTF-8"?>
   <person xml:base="http://example.com:3000">
@@ -89,13 +91,19 @@ Atom-like
 Params-like
 ===========
 
-`Person.last.to_restful.serialize(:params)` results in something like...
+`Person.last.to_restful.serialize(:params)` OR
+`Person.last.to_restful_params` results in something like...
 
   {:sex_attributes => {:sex=>"male"},
    :current_location=>"Under a tree",
    :name=>"Joe Bloggs",
    :pets_attributes=> [ {:person_id=>1, :name=>nil} ] 
   }
+  
+Other Serializers
+=================
+
+Hash. Spits out a plain ole hash, no nested attributes or such like. Useful for further conversions. 
 
 Deserializing
 =============
@@ -105,4 +113,4 @@ Use `Restful.from_atom_like(xml).serialize(:hash)` to convert from an atom-like
 Nested Attributes
 =================
 Serializing uses Rails 2.3 notation of nested attributes. For deserializing you will need Rails 2.3 for having nested attributes support and the respective model must have the 
-`accepts_nested_attributes_for :<table name>` set accordingly
+`accepts_nested_attributes_for :<table name>` set accordingly.

data/TODO.markdown

@@ -3,5 +3,6 @@ Refactor this shice. Seriously, this has devolved into some nasty-ass code.
 * the metamodel is kind of weird. make a better metamodel - how about just using activemodel?
 * remove requirement to call apiable in model classes; replace with restful_publish with no args (or with args.)
 * move configuration object out of rails folder - this is general stuff. 
-* remove xml serialzation here and test resource directly (in active_record_converter_test)
-* get rid of to_a warning
+* 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

data/init.rb

@@ -1 +1 @@
-require File.dirname(__FILE__) + "/rails/init"
+require File.dirname(__FILE__) + "/rails/init"

data/lib/restful/converters/active_record.rb

@@ -15,7 +15,6 @@ module Restful
             :path => model.restful_path,
             :url => model.restful_url
         })
-        
                 
         # simple attributes
         resource.values += Restful::Rails.tools.simple_attributes_on(model).map do |attribute|
@@ -41,7 +40,7 @@ module Restful
               end
             elsif model.class.reflections[key].macro == :has_one or model.class.reflections[key].macro == :belongs_to
 
-              if(config.expanded? && !nested) 
+              if(config.expanded?(key, nested)) 
                 convert_to_collection(model, key, nested_config, published) do |key, resources, extended_type|
                   returning(resources.first) do |res|
                     res.name = key
@@ -74,18 +73,18 @@ module Restful
         resource.values += (model.public_methods - Restful::Rails.tools.simple_attributes_on(model).keys.map(&:to_s)).map do |method_name|
           if config.published?(method_name.to_sym) and not published.include?(method_name.to_sym)
             value = model.send(method_name.to_sym)
-              sanitzed_method_name = method_name.tr("!?", "").tr("_", "-").to_sym
+              sanitized_method_name = method_name.tr("!?", "").tr("_", "-").to_sym
               
               if value.is_a? ::ActiveRecord::Base
-                if config.expanded? && !nested
+                if config.expanded?(method_name.to_sym, nested)
                   returning Restful::Rails.tools.expand(value, config.nested(method_name.to_sym)) do |expanded|
-                    expanded.name = sanitzed_method_name
+                    expanded.name = sanitized_method_name
                   end
                 else
-                  Restful.link("#{ sanitzed_method_name }-restful-url", Restful::Rails.api_hostname, value ? value.restful_path : "", compute_extended_type(model, key))
+                  Restful.link("#{ sanitized_method_name }-restful-url", Restful::Rails.api_hostname, value ? value.restful_path : "", compute_extended_type(model, key))
                 end
               else
-                Restful.attr(sanitzed_method_name, value, compute_extended_type(model, method_name))
+                Restful.attr(sanitized_method_name, value, compute_extended_type(model, method_name))
               end
           end
         end.compact
@@ -119,6 +118,8 @@ module Restful
               :string
             when :time 
               :datetime
+            when :date
+              :date
             else
               type_symbol
             end

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

@@ -42,6 +42,7 @@ module Restful
             end
             
             config.whitelisted = self.class.restful_config.whitelisted if config.whitelisted.empty?
+            config.restful_options.merge! self.class.restful_config.restful_options
             
             Restful::Converters::ActiveRecord.convert(self, config)
           end
@@ -75,9 +76,14 @@ module Restful
             @whitelisted.include?(key) || !!@whitelisted.select { |field| field.is_a?(Hash)  && field.keys.include?(key) }.first
           end
 
-          def expanded? # if nothing was set, this defaults to true. 
-            @restful_options[:expansion] != :collapsed
-          end       
+          def expanded?(key, nested = false) # if nothing was set, this defaults to true. 
+            force_expanded?(key) || (@restful_options[:expansion] != :collapsed && !nested)
+          end
+          
+          def force_expanded?(key)
+            force = [*@restful_options[:force_expand]]
+            force.include?(key)
+          end
 
           def nested?
             !!restful_options[:nested]

data/lib/restful/serializers/base.rb

@@ -28,6 +28,20 @@ module Restful
         self.serializers[key] = self
       end
       
+      def formatted_value(value)
+        return nil if value.value.blank? && value.extended_type != :false_class
+        case value.extended_type
+        when :datetime
+          value.value.xmlschema
+        when :time
+          value.value.xmlschema
+        when :date
+          value.value.to_s(:db)
+        else
+          value.value
+        end        
+      end
+      
       protected
         def transform_link_name(name)
           name.to_s.gsub /_id$/, "-restful-url"

data/lib/restful/serializers/hash_serializer.rb

@@ -8,6 +8,7 @@ module Restful
     class HashSerializer < Base
       
       serializer_name :hash
+
       
       def serialize(resource, options = {})
         params = {}
@@ -15,31 +16,32 @@ module Restful
         resource.values.each do |value|
           if value.type == :collection # serialize the stuffs
             resources = value.value
+            next if resources.empty?
             name = resources.first.name.pluralize
             
             array = []
-            resources.each { |r| array << serialize(r) } 
+            resources.each do |r|
+              array << serialize(r)
+            end
             
-            params["#{value.name}".to_sym] = array
+            params[hashify_key(value.name)] = array
           elsif value.type == :link
-            params[value.name] = Restful::Rails.tools.dereference(value.value)
+            params[hashify_key(value.name)] = Restful::Rails.tools.dereference(value.value)
           elsif value.type == :resource
-            params["#{value.name}".to_sym] = serialize(value)
+            params[hashify_key(value.name)] = serialize(value)
           else # plain ole
-            string_value = case value.extended_type
-            when :datetime
-              value.value.xmlschema
-            else
-              value.value
-            end
-            
-            params[value.name] = string_value
+            params[hashify_key(value.name)] = formatted_value(value)
           end
         end
         
         params["restful_url"] = resource.full_url
         params
       end
+      
+      private
+        def hashify_key(original_key)
+          original_key.to_s.tr("-", "_").to_sym
+        end
     end
   end
 end

data/lib/restful/serializers/params_serializer.rb

@@ -12,10 +12,10 @@ module Restful
       
       def serialize(resource, options = {})
         params = {}
-        
         resource.values.each do |value|
           if value.type == :collection # serialize the stuffs
             resources = value.value
+            next if resources.empty?
             name = resources.first.name.pluralize
             
             array = []
@@ -23,18 +23,24 @@ module Restful
               array << serialize(resource)
             end              
             
-            params["#{value.name.to_sym}_attributes".to_sym] = array
+            params["#{paramify_keys(value.name)}_attributes".to_sym] = array
           elsif value.type == :link
-            params[value.name] = Restful::Rails.tools.dereference(value.value)
+            params[paramify_keys(value.name).to_sym] = Restful::Rails.tools.dereference(value.value)
           elsif value.type == :resource
-            params["#{value.name.to_sym}_attributes".to_sym] = serialize(value)
+            params["#{paramify_keys(value.name)}_attributes".to_sym] = serialize(value)
           else # plain ole
-            params[value.name] = value.value
+            params[paramify_keys(value.name).to_sym] = value.value # no need to format dates etc - just pass objects through. 
           end
         end
         
         params
       end
-    end
+      
+      private
+      
+      def paramify_keys(original_key)
+        original_key.to_s.tr("-", "_")
+      end
+    end    
   end
 end

data/lib/restful/serializers/xml_serializer.rb

@@ -58,18 +58,20 @@ module Restful
         end
       
         def add_tag(builder, value)
-          string_value = case value.extended_type
-          when :datetime
-            value.value.xmlschema
+
+          if value.extended_type == :hash
+            build_hash(builder, value)
           else
-            value.value.to_s
+            builder.tag!(value.name.to_s.dasherize, formatted_value(value), decorations(value))
+          end
+        end
+        
+        def build_hash(builder, value)
+          builder.tag!(value.name.to_s.dasherize) do
+            value.value.each do |k, v|
+              builder.tag! k.to_s.dasherize, v
+            end            
           end
-          
-          builder.tag!(
-            value.name.to_s.dasherize,
-            string_value,
-            decorations(value)
-          )
         end
         
         def decorations(value)
@@ -91,6 +93,10 @@ module Restful
             decorations[:nil] = true
           end
           
+          if value.value.is_a?(FalseClass) || value.value.is_a?(TrueClass)
+            decorations[:type] = :boolean
+          end
+
           decorations
         end
         

data/restful.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "restful"
-  s.version = "0.2.1"
+  s.version = "0.2.2"
   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/converters/active_record_converter_test.rb

@@ -8,7 +8,7 @@ context "active record converter" do
     Person.restful_publish(:name, :wallet, :current_location, :pets => [:name, :species])
     Pet.restful_publish(:person_id, :name) # person_id gets converted to a link automagically.
     
-    @person = Person.create(:name => "Joe Bloggs", :current_location => "Under a tree")
+    @person = Person.create(:name => "Joe Bloggs", :current_location => "Under a tree", :birthday => "1976-04-03")
     @wallet = @person.wallet = Wallet.create!(:contents => "something in the wallet")
     @pet = @person.pets.create(:name => "Mietze", :species => "cat")
   end
@@ -17,6 +17,14 @@ context "active record converter" do
     reset_config
   end
   
+  specify "should be able to force expansion. force expanded attributes can never be collapsed. " do
+    Wallet.restful_publish(:contents)
+    Person.restful_publish(:name, :wallet, :current_location, { :pets => [:name, :species], :restful_options => { :force_expand => :wallet } })
+    Pet.restful_publish(:owner, :name)
+
+    @pet.to_restful
+  end
+  
   specify "should return link attributes from a model" do
     @pet.to_restful.links.map { |node| node.name }.sort.should.equal [:person_id]
   end
@@ -38,6 +46,11 @@ context "active record converter" do
     restful.collections.map { |node| node.name }.sort.should.equal [:pets]
   end
   
+  specify "should set correct type for date" do
+    restful = @person.to_restful :birthday
+    restful.simple_attributes.detect { |node| node.name == :birthday }.extended_type.should.== :date
+  end
+  
   specify "should be able to convert themselves to an apimodel containing all and only the attributes exposed by Model.publish_api" do    
     resource = @person.to_restful
     

data/test/fixtures/models/person.rb

@@ -13,5 +13,17 @@ class Person < ActiveRecord::Base
     "Hi. I'm currently in #{ current_location }"
   end  
   
+  def has_pets
+    pets.size > 0
+  end
+  
+  def pets_ages_hash
+   returning pets_hash = {} do
+     pets.each do |pet|
+       pets_hash[pet.name] = pet.age
+     end
+   end
+  end
+  
   apiable
 end

data/test/fixtures/people.json.yaml

@@ -13,4 +13,57 @@ bloggs:
         "name": "mietze" 
        }],
       "created_at": "<%= @person.created_at.xmlschema %>"
+    }
+
+bloggs_with_oldest_pet:
+  |
+    { 
+       "restful_url": "http://example.com:3000/people/<%= @person.to_param %>",
+       "oldest_pet": { 
+         "restful_url": "http://example.com:3000/pets/<%= @person.pets.first.to_param %>", 
+         "name": "mietze" 
+       }
+    }
+
+bloggs_with_birthday:
+  |
+    { 
+      "restful_url": "http://example.com:3000/people/<%= @person.to_param %>",
+      "birthday": "<%= @person.birthday.to_s(:db) %>"
+    }
+
+bloggs_with_pets_ages_hash:
+  |
+    { 
+      "restful_url": "http://example.com:3000/people/<%= @person.to_param %>",
+      "pets_ages_hash": {
+        "mietze": 200,
+        "motze": 100
+      }
+    }
+bloggs_with_has_pets:
+  |
+    { 
+      "restful_url": "http://example.com:3000/people/<%= @person.to_param %>",
+      "has_pets": true
+    }
+bloggs_with_hasno_pets:
+  |
+    { 
+      "restful_url": "http://example.com:3000/people/<%= @person.to_param %>",
+      "has_pets": false
+    }
+
+
+bloggs_da_pet_hater:
+  |
+    { 
+      "restful_url": "http://example.com:3000/people/<%= @person.to_param %>",
+      "wallet": { 
+        "restful_url": "http://example.com:3000/wallets/<%= @person.wallet.to_param %>",
+        "contents": "an old photo, 5 euros in coins" 
+      },
+      "current_location": "Under a tree",
+      "name": "Joe Bloggs",
+      "created_at": "<%= @person.created_at.xmlschema %>"
     }

data/test/fixtures/people.xml.yaml

@@ -37,7 +37,15 @@ with_oldest_pet_species:
         <species type="integer"><%= @person.oldest_pet.species %></species>
       </oldest-pet>
     </person>
-    
+
+joe_with_birthday:
+  |
+    <?xml version="1.0" encoding="UTF-8"?>
+    <person>
+      <restful-url type="link">http://example.com:3000/people/<%= @person.id %></restful-url>
+      <birthday type="date"><%= @person.birthday.to_s(:db) %></birthday>
+    </person>
+
 joe_with_zwiebelleder:    
   |
     <?xml version="1.0" encoding="UTF-8"?>
@@ -102,4 +110,14 @@ with_pets_and_expanded_wallet:
         <contents>an old photo, 5 euros in coins</contents>
       </wallet>
     </person>
-  
+    
+hashy_person:
+  |
+    <?xml version="1.0" encoding="UTF-8"?>
+    <person>
+      <restful-url type="link">http://example.com:3000/people/<%= @person.id %></restful-url>
+      <pets-ages-hash>
+        <mietze>200</mietze>
+        <motze>100</motze>
+      </pets-ages-hash>
+    </person>

data/test/serializers/json_serializer_test.rb

@@ -7,7 +7,7 @@ context "json serializer" do
     Pet.restful_publish(:name)
     Wallet.restful_publish(:contents)
     
-    @person = Person.create(:name => "Joe Bloggs", :current_location => "Under a tree")
+    @person = Person.create(:name => "Joe Bloggs", :current_location => "Under a tree", :birthday => "2009-09-19")
     @pet = @person.pets.create(:species => "cat", :age => 200, :name => "mietze")
     @wallet = @person.wallet = Wallet.new(:contents => "an old photo, 5 euros in coins")
     @person.save
@@ -18,4 +18,46 @@ context "json serializer" do
   specify "serialize to json" do
     json_should_eql_fixture(@person.to_restful_json, "people", :bloggs)
   end
+  
+  specify "should be able to serialize objects with empty collections" do
+    @person.pets = []
+    assert_nothing_raised do
+      json_should_eql_fixture(@person.to_restful_json, "people", :bloggs_da_pet_hater)
+    end
+  end
+
+  specify "should serialize date type correctly" do
+    json_should_eql_fixture(@person.to_restful_json(:birthday), "people", :bloggs_with_birthday)  
+  end
+  
+  specify "should not bug out on nil values in date fields" do
+    person = Person.create :created_at => nil, :birthday => nil, :last_login => nil
+    person.created_at = nil
+    expected = "{\"birthday\":null,\"restful_url\":\"http://example.com:3000/people/#{person.to_param}\",\"last_login\":null,\"created_at\":null}"
+    assert_nothing_raised do
+      actual = person.to_restful_json([:created_at, :birthday, :last_login])
+      json_should_eql(actual, expected)
+    end
+  end
+  
+  specify "should serialize hashes correctly" do
+    @person.pets.create(:species => "cat", :age => 100, :name => "motze")
+    json_should_eql_fixture(@person.to_restful_json(:pets_ages_hash), "people", :bloggs_with_pets_ages_hash)
+  end
+  
+  specify "should render boolean values correctly" do
+    json_should_eql_fixture(@person.to_restful_json(:has_pets), "people", :bloggs_with_has_pets)
+    @person.pets = []
+    @person.save!
+    json_should_eql_fixture(@person.to_restful_json(:has_pets), "people", :bloggs_with_hasno_pets)
+  end
+  
+  specify "should not ever use dashes as hash keys but underscores" do
+    assert_nothing_raised do
+      json_should_eql_fixture(@person.to_restful_json(:oldest_pet), "people", :bloggs_with_oldest_pet)
+    end
+  end
+  
+
+    
 end

data/test/serializers/params_serializer_test.rb

@@ -7,7 +7,7 @@ context "params serializer" do
     Pet.restful_publish(:name)
     Wallet.restful_publish(:contents)
     
-    @person = Person.create(:name => "Joe Bloggs", :current_location => "Under a tree")
+    @person = Person.create(:name => "Joe Bloggs", :current_location => "Under a tree", :birthday => "1942-01-11")
     @pet = @person.pets.create(:species => "cat", :age => 200, :name => "mietze")
     @wallet = @person.wallet = Wallet.new(:contents => "an old photo, 5 euros in coins")
     @person.save
@@ -17,6 +17,30 @@ context "params serializer" do
     reset_config
   end
   
+  specify "should be able to serialize objects empty collections" do
+    @person.pets = []
+    expected = 
+      {
+        :name => "Joe Bloggs",
+        :current_location => "Under a tree",
+        :created_at => @person.created_at,
+        :wallet_attributes=>{:contents=>"an old photo, 5 euros in coins"}
+      }
+
+    assert_nothing_raised do
+      actual = @person.to_restful.serialize :params
+      actual.should.== expected
+    end
+  end
+  
+  specify "should render correct date" do
+    actual = @person.to_restful(:birthday).serialize(:params)
+    
+    expected = { :birthday => @person.birthday.to_s(:db) }
+    
+    Person.create(expected).birthday.should.== @person.birthday
+  end
+  
   specify "serialize to params" do
     actual = @person.to_restful.serialize(:params)
   
@@ -32,6 +56,14 @@ context "params serializer" do
     actual.should.== expected
   end
   
+  specify "use correct key names for method that include '-' character" do
+    actual = @person.to_restful(:oldest_pet).serialize(:params)
+    
+    expected = { :oldest_pet_attributes => {:name => "mietze"} }
+    
+    actual.should.== expected
+  end
+  
   specify "serialize to an ar params hash" do    
     input = xml_fixture("pets")[:gracie]
     params = Restful.from_xml(input).serialize(:params)

data/test/serializers/xml_serializer_test.rb

@@ -6,7 +6,7 @@ context "params serializer" do
     Pet.restful_publish(:name)
     Wallet.restful_publish(:contents)
   
-    @person = Person.create(:name => "Joe Bloggs", :current_location => "Under a tree")
+    @person = Person.create(:name => "Joe Bloggs", :current_location => "Under a tree", :birthday => "1990-03-09")
     @pet = @person.pets.create(:species => "cat", :age => 200, :name => "mietze")
     @wallet = @person.wallet = Wallet.new(:contents => "an old photo, 5 euros in coins")
     @person.save
@@ -26,6 +26,10 @@ context "params serializer" do
     xml_should_eql(expected, actual)
   end
   
+  specify "should serialize date type correctly" do
+    xml_should_eql_fixture(@person.to_restful_xml(:birthday), "people", :joe_with_birthday)  
+  end
+  
   specify "should convert a NULL inner association such as person.wallet to a link with a null value" do
     @person.wallet = nil
 
@@ -35,4 +39,9 @@ context "params serializer" do
   specify "serialize to xml, rails style" do
     xml_should_eql_fixture(@person.to_restful_xml, "people", :with_pets_and_expanded_wallet)
   end
+  
+  specify "should serialize hashes correctly" 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
 end

data/test/test_helper.rb

@@ -43,6 +43,8 @@ silence_stream(STDOUT) do
       t.string :name
       t.string :current_location
       t.string :biography
+      t.date   :birthday
+      t.datetime :last_login
 
       t.timestamp :created_at      
       t.timestamp :updated_at
@@ -90,10 +92,25 @@ end
 def json_cmp(actual, expected)
   actual = Yajl::Parser.parse(actual)
   expected = Yajl::Parser.parse(expected)
-  
+  puts_hash_diff actual, expected
   actual == expected
 end
 
+def puts_hash_diff(hash1, hash2, indent = 0)
+  return if hash1 == hash2
+  
+  (hash1.keys + hash2.keys).uniq.each do |key|
+    next if hash1[key] == hash2[key]
+    print "  "*indent
+    if hash1[key].is_a? Hash or hash2[key].is_a? Hash
+      puts "=== #{key} is a Hash ==="
+      puts_hash_diff(hash1[key] || {}, hash2[key] || {}, indent+2)
+    else
+      printf "%-#{20-indent}s %#{50-indent}s != %-50s\n", key[0..19], hash1[key], hash2[key]
+    end
+  end
+end
+
 def xml_should_eql_fixture(actual, name, key)
   expected = Hpricot(xml_fixture(name)[key])
   actual = Hpricot(actual)

metadata

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