restful 0.2.20

data/lib/restful/serializers/hash_serializer.rb

@@ -0,0 +1,46 @@
+require 'restful/serializers/base'
+
+#
+#  Vanilla Hash.
+#
+module Restful
+  module Serializers
+    class HashSerializer < Base
+      
+      serializer_name :hash
+      
+      def serialize(obj, options = {})
+        case obj.type
+          when :link              then obj.value
+          when :simple_attribute  then serialize(obj.value)
+          when :collection        then serialize_collection(obj)
+          when :map               then serialize_array_of_apimodels(obj.values)
+          when :resource          then serialize_array_of_apimodels(obj.values, { "restful_url" => obj.full_url })
+          else
+            formatted_ruby_type(obj)
+          end
+      end
+      
+      private      
+        
+        def serialize_collection(collection)
+          if entries = collection.total_entries
+            { :total_entries => entries, collection.name => serialize_unpaginated_collection(collection) }
+          else
+            serialize_unpaginated_collection(collection)
+          end
+        end
+        
+        def serialize_unpaginated_collection(collection)
+          collection.value.map { |r| serialize(r) }
+        end
+        
+        def serialize_array_of_apimodels(apimodels, defaults = {})
+          apimodels.inject(defaults) do |memo, apimodel|
+            memo[apimodel.name.to_s.underscore.to_sym] = serialize(apimodel)
+            memo
+          end          
+        end
+    end
+  end
+end

data/lib/restful/serializers/json_serializer.rb

@@ -0,0 +1,18 @@
+require 'restful/serializers/base'
+require 'yajl'
+
+#
+#  AR params hash.
+#
+module Restful
+  module Serializers
+    class JsonSerializer < Base
+      
+      serializer_name :json
+      
+      def serialize(resource, options = {})
+        Yajl::Encoder.encode HashSerializer.new.serialize(resource, options)
+      end
+    end
+  end
+end

data/lib/restful/serializers/params_serializer.rb

@@ -0,0 +1,46 @@
+require 'restful/serializers/base'
+require 'builder'
+
+#
+#  AR params hash.
+#
+module Restful
+  module Serializers
+    class ParamsSerializer < Base
+      
+      serializer_name :params
+      
+      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 = []
+            resources.each do |resource|
+              array << serialize(resource)
+            end              
+            
+            params["#{paramify_keys(value.name)}_attributes".to_sym] = array
+          elsif value.type == :link
+            params[paramify_keys(value.name).to_sym] = Restful::Rails.tools.dereference(value.value)
+          elsif value.type == :resource
+            params["#{paramify_keys(value.name)}_attributes".to_sym] = serialize(value)
+          else # plain ole
+            params[paramify_keys(value.name).to_sym] = value.value # no need to format dates etc - just pass objects through. 
+          end
+        end
+        
+        params
+      end
+      
+      private
+      
+      def paramify_keys(original_key)
+        original_key.to_s.tr("-", "_")
+      end
+    end    
+  end
+end

data/lib/restful/serializers/xml_serializer.rb

@@ -0,0 +1,160 @@
+require 'restful/serializers/base'
+require "rexml/document"
+require 'builder'
+
+#
+#  Converts an APIModel to and from XML. 
+#
+module Restful
+  module Serializers
+    class XMLSerializer < Base
+      
+      serializer_name :xml
+      
+      def serialize(resource, options = {})
+          
+        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        
+          xml.tag!(*root_element(resource)) do
+            add_link_to(resource, xml, :self => true)
+
+            resource.values.each do |value|
+              if value.type == :collection # serialize the stuffs
+                add_collection(value, xml)
+              elsif value.type == :link
+                add_link_to(value, xml)
+              elsif value.type == :resource
+                serialize(value, {:instruct => false, :builder => xml})
+              else # plain ole
+                add_tag(xml, value)
+              end
+            end
+          end       
+        end
+      end
+      
+      # returns a resource, or collection of resources. 
+      def deserialize(xml, options = {})
+        build_resource(REXML::Document.new(xml).root)
+      end
+      
+      protected
+      
+        def add_collection(value, xml, show_as_array = true)
+          resources = value.value
+          if first_resource = resources.first
+            xml.tag!(first_resource.name.pluralize, (show_as_array ? collections_decorations : {})) do
+              resources.each do |resource|
+                serialize(resource,  { :instruct => false, :builder => xml })
+              end              
+            end
+          end
+        end
+      
+        def add_link_to(resource, builder, options = {})
+          is_self = !!options[:self]
+          
+          attributes = {:type => "link"}
+          attributes.merge!(:nil => "true") if resource.full_url.blank?
+          builder.tag!((is_self ? "restful-url" : transform_link_name(resource.name)), resource.full_url, attributes)
+        end
+      
+        def add_tag(builder, value)
+
+          if value.extended_type == :hash
+            build_hash(builder, value)
+          else
+            builder.tag!(value.name.to_s.dasherize, serialize_attribute(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
+        end
+        
+        def decorations(value)
+          decorations = {}
+
+          if value.extended_type == :binary
+            decorations[:encoding] = 'base64'
+          end
+
+          if value.extended_type != :string and value.extended_type != :notype
+            decorations[:type] = value.extended_type
+          end
+
+          if value.extended_type == :datetime
+            decorations[:type] = :datetime
+          end
+
+          if value.value.nil?
+            decorations[:nil] = true
+          end
+          
+          if value.value.is_a?(FalseClass) || value.value.is_a?(TrueClass)
+            decorations[:type] = :boolean
+          end
+
+          decorations
+        end
+        
+        def collections_decorations
+          { :type => "array" }
+        end
+        
+        def root_element(resource, options = {})
+          [resource.name]
+          end
+          
+        # turns a rexml node into a Resource
+        def build_resource(node)
+          resource = root_resource(node)
+          
+          node.elements.each do |el|
+            type = calculate_node_type(el)
+            resource.values << case type
+            
+            when :link : build_link(el, type)
+            when :datetime
+              Restful.attr(el.name, DateTime.parse(el.text), type)
+            when :resource
+              build_resource(el)
+            when :array
+              Restful.collection(el.name, el.elements.map { |child| build_resource(child) }, type)
+            else 
+              Restful.attr(el.name, el.text, type)
+            end
+          end
+
+          resource
+        end
+        
+        def calculate_node_type(el)
+          if el.children.size > 1 && el.attributes["type"].blank? 
+            return :resource
+          else
+            (el.attributes["type"] || "string").to_sym
+          end
+        end
+        
+        def build_link(el, type)
+          Restful.link(revert_link_name(el.name), nil, el.text, type)
+        end
+        
+        def root_resource(node)
+          url = node.delete_element("restful-url").try(:text)
+          Restful.resource(node.name, :url => url)
+        end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'restful'

data/restful.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name = "restful"
+  s.version = "0.2.20"
+  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"
+  s.email = "M4SSIVE@m4ssive.com"
+  s.extra_rdoc_files = %w{ README.markdown }
+  s.files = %w{ CHANGES.markdown init.rb lib/restful/apimodel/attribute.rb lib/restful/apimodel/collection.rb lib/restful/apimodel/link.rb lib/restful/apimodel/map.rb lib/restful/apimodel/resource.rb lib/restful/converters/active_record.rb lib/restful/rails/action_controller.rb lib/restful/rails/active_record/configuration.rb lib/restful/rails/active_record/metadata_tools.rb lib/restful/rails.rb lib/restful/serializers/atom_like_serializer.rb lib/restful/serializers/base.rb lib/restful/serializers/hash_serializer.rb lib/restful/serializers/json_serializer.rb lib/restful/serializers/params_serializer.rb lib/restful/serializers/xml_serializer.rb lib/restful.rb LICENSE.markdown rails/init.rb Rakefile README.markdown restful.gemspec test/converters/active_record_converter_test.rb test/converters/basic_types_converter_test.rb test/fixtures/models/paginated_collection.rb test/fixtures/models/person.rb test/fixtures/models/pet.rb test/fixtures/models/wallet.rb test/fixtures/people.json.yaml test/fixtures/people.xml.yaml test/fixtures/pets.json.yaml test/fixtures/pets.xml.yaml test/rails/active_record_metadata_test.rb test/rails/configuration_test.rb test/rails/restful_publish_test.rb test/serializers/atom_serializer_test.rb test/serializers/json_serializer_test.rb test/serializers/params_serializer_test.rb test/serializers/xml_serializer_test.rb test/test_helper.rb TODO.markdown }
+  s.has_rdoc = true
+  s.rdoc_options = ["--line-numbers", "--inline-source"]
+  s.homepage = "http://github.com/M4SSIVE/restful"
+  s.require_paths = %w{ lib }
+  s.requirements = %w{ brianmario-yajl-ruby }
+  s.rubygems_version = "1.3.1"
+  s.summary = "api niceness. "
+end

data/test/converters/active_record_converter_test.rb

@@ -0,0 +1,147 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+#
+#  FIXME: remove xml serialzation here and test resource directly. 
+#
+context "active record converter" do
+  setup 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", :birthday => "1976-04-03")
+    @wallet = @person.wallet = Wallet.create!(:contents => "something in the wallet")
+    @pet = @person.pets.create(:name => "Mietze", :species => "cat")
+  end
+  
+  teardown do
+    reset_config
+  end
+  
+  specify "should publish link and not resource when :oldest_pet_restful_url, where oldest_pet is a defined method" do
+    Person.restful_publish(:oldest_pet_restful_url)
+    @person.to_restful.links.size.should.== 1
+    @person.to_restful.links.first.name.should.== "oldest-pet-restful-url"
+  end
+  
+  specify "should publish link and not a nested resource with :wallet_restful_url" do
+    Person.restful_publish(:wallet_restful_url)  
+    @person.to_restful.links.size.should.== 1
+    @person.to_restful.links.first.name.should.== "wallet-restful-url"
+    @person.to_restful.links.first.value.should.== @wallet.restful_url
+  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
+  
+  specify "should convert a NULL inner association such as person.wallet to a link with a null value" do
+    @person.wallet = nil
+    
+    wallet = @person.to_restful(:restful_options => { :expansion => :collapsed }).links.select { |link| link.name == "wallet-restful-url" }.first
+    wallet.should.not.== nil
+    wallet.value.should.== nil
+  end
+  
+  specify "should return plain attributes from a model" do
+    @pet.to_restful.simple_attributes.map { |node| node.name }.should.equal [:name]
+  end
+  
+  specify "should return collections attributes from a model" do
+    restful = @person.to_restful
+    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
+    
+    resource.simple_attributes.select { |node| node.name == :name }.should.not.blank
+    resource.simple_attributes.select { |node| node.name == :biography }.should.blank
+
+    mietze = @person.to_restful.collections .select { |node| node.name == :pets }.first.value.first
+    mietze.simple_attributes.size.should.== 2
+    mietze.simple_attributes.select { |node| node.name == :name }.should.not.blank
+    mietze.simple_attributes.select { |node| node.name == :species }.should.not.blank
+  end
+
+  specify "should be able to convert themselves to an apimodel containing all and only the attributes exposed by Model.publish_api. this holds true if to_restful is called with some configuration options. " do    
+    resource = @person.to_restful(:restful_options => { :nested => false })
+    resource.simple_attributes.select { |node| node.name == :name }.should.not.blank
+    resource.simple_attributes.select { |node| node.name == :biography }.should.blank
+
+    mietze = resource.collections .select { |node| node.name == :pets }.first.value.first
+    mietze.simple_attributes.size.should.== 2
+    mietze.simple_attributes.select { |node| node.name == :name }.should.not.blank
+    mietze.simple_attributes.select { |node| node.name == :species }.should.not.blank
+  end
+  
+  specify "should be able to override to_restful published fields by passing them into the method" do
+    api = @person.to_restful(:pets)
+
+    api.simple_attributes.should.blank?
+    api.collections.map { |node| node.name }.sort.should.equal [:pets]
+  end
+  
+  specify "should be able to handle relations that are nil/null" do
+    @person.wallet = nil
+    @person.save!
+    @person.reload
+
+    assert_nothing_raised do
+      @person.to_restful
+    end
+  end
+
+  specify "should be able to expand a :belongs_to relationship" do
+    xml_should_eql_fixture(@pet.to_restful_xml(:owner), "pets", :nameless_pet)
+  end
+
+  specify "should return collapsed resources by default when :expansion => :collapsed is passed" do
+    Person.restful_publish(:name, :wallet, :restful_options => { :expansion => :collapsed })
+    xml_should_eql_fixture(@person.to_restful_xml, "people", :joe_bloggs)
+  end
+
+  specify "should be able to export content generated by methods that return strings" do
+    xml_should_eql_fixture(@person.to_restful_xml(:location_sentence), "people", :no_wallet)
+  end
+
+  specify "should be able to export content generated by methods (not attributes) and compute the correct style" do 
+    xml_should_eql_fixture(@person.to_restful_xml(:oldest_pet), "people", :with_oldest_pet)
+  end
+
+  specify "should be able to export content generated by methods (not attributes) while filtering with a nested configuration" do
+    xml_should_eql_fixture(@person.to_restful_xml(:oldest_pet => [:species]), "people", :with_oldest_pet_species)    
+  end
+
+  specify "should create element with nil='true' attribute if no relation is set" do 
+    @person.wallet = nil
+    @person.save
+
+    xml_should_eql_fixture(@person.to_restful_xml(:wallet), "people", :joe_with_zwiebelleder)
+  end
+
+  specify "should include attributes when include parameter is passed to to_restful" do
+    Person.restful_publish(:name)
+    Pet.restful_publish(:name)
+    
+    @person = Person.create
+    @pet = @person.pets.create(:name => "Mietze")
+
+    @pet.to_restful(:include => :owner).values.map(&:name).should.include :owner
+    Pet.restful_config.whitelisted.include?(:owner).should.equal false
+  end
+  
+end
+

data/test/converters/basic_types_converter_test.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+context "basic types converter" do
+  
+  teardown { reset_config }
+  
+  specify "should be able to convert a hash to a resource map" do
+    Person.restful_publish(:name)
+    resource = { "zeperson" => @person = Person.create(:name => "fuddzle") }.to_restful
+    resource.should.is_a?(Restful::ApiModel::Map)
+    
+    attrs = resource.simple_attributes
+    attrs.size.should.== 1
+    attrs.first.name.should.== "zeperson"
+    
+    attrs.first.value.values.first.value.== "fuddzle"
+  end
+
+  specify "should raise exception if not all array contents respond to .to_restful" do
+    Person.restful_publish(:name)
+    
+    should.raise(TypeError) do
+      [""].to_restful
+    end
+  end
+  
+  specify "should convert an empty array to a restful collection" do
+    collection = [].to_restful
+    collection.name.should.== "nil-classes"
+  end  
+  
+  specify "should infer array name from first element class" do
+    collection = [Pet.new].to_restful
+    collection.name.should.== "pets"
+  end
+  
+  specify "should infer array name from first element base_class if it is an active_record object" do
+    collection = [Emu.new, Pet.new].to_restful
+    collection.name.should.== "pets"
+  end
+
+  specify "should convert an array to a restful collection" do
+    Person.restful_publish(:name)
+    
+    collection = [Person.create(:name => "Joe Bloggs")].to_restful
+    collection.name.should.== "people"
+    collection.value.size.should.== 1
+    collection.value.first.simple_attributes.first.value.should.== "Joe Bloggs"
+  end  
+  
+  specify "should set total_entries on the restful collection if the array responds to this" do
+    Person.restful_publish(:name)
+    people = PaginatedCollection.new([Person.create(:name => "Joe Bloggs")])
+    people.total_entries = 1001
+
+    collection = people.to_restful
+    collection.total_entries.should.== 1001
+  end
+  
+  specify "should set name on collection if array responds to .name and has this set" do
+    Person.restful_publish(:name)
+    people = PaginatedCollection.new()
+    people.total_entries = 0
+    people.name = "people"
+
+    collection = people.to_restful
+    collection.name.should.== "people"
+  end
+end
+
+context "basic types converter :includes" do
+  
+  specify "should include extra attributes for hashes" do
+    Person.restful_publish(:name)
+    Pet.restful_publish(:name)
+    
+    @person = Person.create
+    @pet = @person.pets.create(:name => "Mietze")
+
+    map = { :pet => @pet }.to_restful(:include => :owner)
+    map.values.first.name.should.== :pet
+    map.values.first.value.values.map(&:name).should.include :owner
+    
+    Pet.restful_config.whitelisted.include?(:owner).should.equal false
+  end
+  
+  specify "should include extra attributes for arrays" do
+    Person.restful_publish(:name)
+    Pet.restful_publish(:name)
+    
+    @person = Person.create
+    @pet = @person.pets.create(:name => "Mietze")
+
+    collection = [@pet].to_restful(:include => :owner)
+    collection.value.first.values.map(&:name).should.include :owner
+    
+    Pet.restful_config.whitelisted.include?(:owner).should.equal false
+  end
+end