moviepilot-restful 0.2.18

data/lib/restful/serializers/xml_serializer.rb

@@ -0,0 +1,161 @@
+require 'restful/serializers/base'
+require "rexml/document"
+require 'builder'
+require 'ruby-debug'
+
+#
+#  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/lib/restful.rb

@@ -0,0 +1,65 @@
+require 'restful/rails'
+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'
+require 'restful/apimodel/link'
+require 'restful/serializers/xml_serializer'
+require 'restful/serializers/json_serializer'
+require 'restful/serializers/atom_like_serializer'
+require 'restful/serializers/params_serializer'
+require 'restful/serializers/hash_serializer'
+
+module Restful
+    
+  MAJOR = 0
+  MINOR = 1
+  REVISION = 2
+  VERSION = [MAJOR, MINOR, REVISION].join(".")
+  
+  #
+  #  Restful.from_xml, #from_atom_like. Methods correspond with
+  #  resgistered serializers. 
+  #
+  def self.method_missing(method, *args, &block)
+    if method.to_s.match(/^from_(.*)$/)
+      if serializer_clazz = Restful::Serializers::Base.serializers[type = $1.to_sym]
+        s = serializer_clazz.new
+        s.deserialize(args.first)
+      else
+        super
+      end
+    else
+      super
+    end
+  end
+  
+  #
+  #  Shortcuts past the namespaces
+  #
+  
+  def self.cfg(*options)
+    Restful::Rails::ActiveRecord::Configuration::Config.new(*options)
+  end
+  
+  def self.attr(*options)
+    Restful::ApiModel::Attribute.new(*options)    
+  end
+  
+  def self.link(*options)
+    Restful::ApiModel::Link.new(*options)
+  end
+  
+  def self.collection(*options)
+    Restful::ApiModel::Collection.new(*options)
+  end
+  
+  def self.resource(*options)
+    Restful::ApiModel::Resource.new(*options)
+  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.18"
+  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

data/test/fixtures/models/paginated_collection.rb

@@ -0,0 +1,3 @@
+class PaginatedCollection < Array
+  attr_accessor :total_entries, :name
+end

data/test/fixtures/models/person.rb

@@ -0,0 +1,29 @@
+class Person < ActiveRecord::Base
+  has_many :pets
+  has_one  :wallet
+
+  accepts_nested_attributes_for :pets
+  accepts_nested_attributes_for :wallet
+  
+  def oldest_pet
+    pets.first :order => "age DESC"
+  end
+  
+  def location_sentence
+    "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/models/pet.rb

@@ -0,0 +1,5 @@
+class Pet < ActiveRecord::Base
+  belongs_to :owner, :class_name => "Person", :foreign_key => "person_id"  
+
+  apiable
+end

data/test/fixtures/models/wallet.rb

@@ -0,0 +1,5 @@
+class Wallet < ActiveRecord::Base
+  belongs_to :person  
+
+  apiable
+end

data/test/fixtures/people.json.yaml

@@ -0,0 +1,107 @@
+bloggs: 
+  |
+    { 
+      "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",
+      "pets": [ { 
+        "restful_url": "http://example.com:3000/pets/<%= @person.pets.first.to_param %>", 
+        "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",
+      "pets": [],
+      "created_at": "<%= @person.created_at.xmlschema %>"
+    }
+    
+hash_with_person:
+  |
+    { 
+      "total_hits": 1, 
+      "a_person": {
+        "restful_url": "http://example.com:3000/people/<%= @person.to_param %>",
+        "name": "Joe Bloggs"
+      }
+    }
+    
+hash_with_people:
+  |
+    { 
+      "total_hits": 2, 
+      "people": [{
+        "restful_url": "http://example.com:3000/people/<%= @person.to_param %>",
+        "name": "Joe Bloggs"
+      },
+      {
+        "restful_url": "http://example.com:3000/people/<%= @person.to_param %>",
+        "name": "Joe Bloggs"
+      }]
+    }
+
+hash_with_rich_person:
+  |
+    {
+      "person": {
+        "restful_url": "http://example.com:3000/people/<%= @person.to_param %>",
+        "name": "Joe Bloggs", 
+        "wallet": {
+          "restful_url": "http://example.com:3000/wallets/<%= @person.wallet.to_param %>",
+          "contents": "<%= @person.wallet.contents %>"
+        }
+      }
+    }