restfulie 0.6.0 → 0.7.0

data/lib/restfulie/media_type_control.rb

@@ -1,115 +0,0 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-
-# extends Rails mime type
-
-module Mime
-  class << self
-    # alias_method :old_const_set, :const_set
-    
-    # ignores setting the contest again
-    # def const_set(a,b)
-      # super(a,b) unless Mime.const_defined?(a)
-    # end
-  end
-end
-
-module Restfulie
-  
-  module MediaTypeControl
-    
-    # defines a custom media_type for this type
-    def media_type(*args)
-      args.each do |name|
-        custom_representations << name
-        type = Restfulie::MediaType.rendering_type(name, self)
-        Restfulie::MediaType.register(type)
-      end
-    end
-    
-    # returns the list of media types available for this resource to be deserialized from
-    def media_types
-      Restfulie::MediaType.default_types + MediaType.medias_for(self)
-    end
-    
-    # returns a list of media types that this resource can be serialized to
-    def media_type_representations
-      custom_representations + Restfulie::MediaType.default_representations.dup
-    end
-    
-    private
-    
-    # this model's custom representations. those representations were added through media_type definitions
-    def custom_representations
-      @custom_representations ||= []
-    end
-    
-  end
-  
-
-  def register(string, symbol, mime_type_synonyms = [], extension_synonyms = [], skip_lookup = false)
-    SET << Mime.const_get(symbol.to_s.upcase)
-
-    ([string] + mime_type_synonyms).each { |string| LOOKUP[string] = SET.last } unless skip_lookup
-    ([symbol.to_s] + extension_synonyms).each { |ext| EXTENSION_LOOKUP[ext] = SET.last }
-  end
-
-  module MediaType
-    
-    class << self
-    
-      def register(type)
-        silence_warnings do
-          Mime::Type.register(type.name, type.short_name.to_sym)
-        end
-        
-        media_types[type.name] = type
-      end
-    
-      # TODO rename to type for mt
-      def media_type(name)
-        name = normalize(name)
-        raise Restfulie::UnsupportedContentType.new("unsupported content type '#{name}'") if media_types[name].nil?
-        media_types[name].type
-      end
-    
-      def supports?(name)
-        name = normalize(name)
-        !media_types[name].nil?
-      end
-    
-      def normalize(name)
-        name[/[^;]*/]
-      end
-    
-      def media_types
-        @media_types ||= {}
-      end
-    
-      # TODO move to MediaTypeControl.custom_media_types
-      def medias_for(type)
-        found = {}
-        type.media_type_representations.each do |key|
-          found[key] = media_types[key]
-        end
-        found.values
-      end
-      
-    end
-    
-  end
-  
-end

data/lib/restfulie/media_type_defaults.rb

@@ -1,51 +0,0 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-
-module Restfulie
-  
-  module MediaType
-    def self.HtmlType
-      custom_type('html', DefaultMediaTypeDecoder, lambda {})
-    end
-    def self.TextHtmlType
-      custom_type('text/html', DefaultMediaTypeDecoder, lambda {})
-    end
-  
-    # TODO rename it and move it
-    def self.default_types
-      [Restfulie::MediaType.HtmlType,
-        Restfulie::MediaType.TextHtmlType,
-        rendering_type('application/xml', self),
-        rendering_type('application/json', self),
-        rendering_type('xml', self),
-        rendering_type('json', self)]
-    end
-    
-    # Default representations: every object can be serialized to those types
-    def self.default_representations
-      ['html','text/html','application/xml','application/json','xml','json']
-    end
-
-    # TODO should allow aliases...
-    register(Restfulie::MediaType.HtmlType)
-    register(Restfulie::MediaType.TextHtmlType)
-    register(rendering_type('application/xml', DefaultMediaTypeDecoder))
-    register(rendering_type('application/json', DefaultMediaTypeDecoder))
-    register(rendering_type('xml', DefaultMediaTypeDecoder))
-    register(rendering_type('json', DefaultMediaTypeDecoder))
-  end
-end

data/lib/restfulie/server/atom_media_type.rb

@@ -1,115 +0,0 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-
-module Restfulie
-  
-  module Server
-    
-    class AtomMediaType < Restfulie::MediaType::Type
-      def initialize(name, type)
-        super(name, type)
-      end
-      def execute_for(controller, resource, options, render_options)
-        response = ["atom"].include?(format_name) ? resource.send(:"to_#{format_name}", options) : resource
-        render(controller, response, render_options)
-      end
-    end
-    
-  end
-  
-  Restfulie::MediaType.register(Restfulie::MediaType.rendering_type('application/atom+xml', Server::AtomMediaType))
-  
-end
-
-class Array
-  extend Restfulie::MediaTypeControl
-  media_type "application/atom+xml"
-  
-  def to_atom(options = {}, &block)
-    AtomFeed.new(self).title(options[:title]).to_atom(options[:controller], block)
-  end
-  
-end
-
-class AtomFeed
-  def initialize(feed)
-    @feed = feed
-    @title = "feed"
-  end
-  
-  def title(title)
-    @title = title
-    self
-  end
-  
-  def to_atom(controller, block = nil)
-    last_modified = updated_at
-    id = id_for(controller)
-    xml = items_to_atom_xml(controller, block)
-    """<?xml version=\"1.0\"?>
-      <feed xmlns=\"http://www.w3.org/2005/Atom\">
-        <id>#{id}</id>
-        <title type=\"text\">#{@title}</title>
-        <updated>"""  + last_modified.strftime("%Y-%m-%dT%H:%M:%S-08:00") + """</updated>
-        <author><name>#{@title}</name></author>
-        #{self_link(controller)}
-        #{xml}
-      </feed>"""
-  end
-  
-  def id_for(controller)
-    @id || controller.url_for({})
-  end
-  
-  def id(*id)
-    @id = id
-    self
-  end
-  
-  def self_link(controller, what = {})
-    uri = controller.url_for(what)
-    "<link rel=\"self\" href=\"#{uri}\"/>"
-  end
-  
-  def updated_at
-    @feed.updated_at
-  end
-  
-  def items_to_atom_xml(controller, serializer = nil)
-    xml = ""
-    @feed.each do |item|
-      uri = controller.url_for(item)
-      media_type = item.class.respond_to?(:media_type_representations) ? item.class.media_type_representations[0] : 'application/xml'
-      item_xml = serializer.nil? ? item.to_xml(:controller => controller, :skip_instruct => true) : serializer.call(item)
-      xml += """          <entry>
-            <id>#{uri}</id>
-            <title type=\"text\">#{item.class.name}</title>
-            <updated>#{modification_for(item).strftime("%Y-%m-%dT%H:%M:%S-08:00")}</updated>
-            #{self_link(controller, item)}
-            <content type=\"#{media_type}\">
-              #{item_xml}
-            </content>
-          </entry>\n"""
-    end
-    xml
-  end
-  
-  def modification_for(item)
-    item.respond_to?(:updated_at) ? item.updated_at : Time.now
-  end
-
-end

data/lib/restfulie/server/base.rb

@@ -1,91 +0,0 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-
-module Restfulie
-  module Server
-    module Base
-
-      # returns the definition for the transaction
-      def existing_transition(name)
-        transitions[name]
-      end
-    
-      # returns a hash of all possible transitions: Restfulie::Server::Transition
-      def transitions
-        @transitions ||= {}
-      end
-
-      # returns a hash of all possible states
-      def states
-        @states ||= {}
-      end
-
-      # adds a new state to the list of possible states
-      def state(name, options = {})
-        options[:allow] = [options[:allow]] unless options[:allow].kind_of? Array
-        states[name] = options
-      end
-      
-      # defines a new transition. the transition options works in the same way
-      # that following_transition definition does.
-      def transition(name = nil, options = {}, result = nil, &body)
-        return TransitionBuilder.new(self) if name.nil?
-      
-        transition = Restfulie::Server::Transition.new(name, options, result, body)
-        transitions[name] = transition
-
-        define_execution_method(self, name, result)
-        define_can_method(self, name)
-      end
-      
-      class TransitionBuilder
-        def initialize(type)
-          @type = type
-        end
-        def method_missing(name, *args)
-          @transition = Restfulie::Server::Transition.new(name)
-          @type.transitions[name] = @transition
-          @type.define_can_method(@type, name)
-          self
-        end
-        
-        def at(options)
-          @transition.options = options
-        end
-        
-        def results_in(result)
-          @transition.result = result
-        end
-        
-      end
- 
-      def define_execution_method(type, name, result) 
-        type.send(:define_method, name) do |*args|
-          self.status = result.to_s unless result.nil?
-        end unless type.respond_to?(name)
-      end
- 
-      def define_can_method(type, name) 
-        type.send(:define_method, "can_#{name}?") do
-          transitions = self.available_transitions[:allow]
-          transitions.include? name
-        end unless type.respond_to?("can_#{name}?")
-      end
- 
-    end
-  end
-end

data/lib/restfulie/server/controller.rb

@@ -1,122 +0,0 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-module Restfulie::Server::Cache
-  
-  class Config
-
-    def allow(seconds)
-      @max_age = seconds
-      self
-    end
-
-    def max_age
-      @max_age ||= 0
-    end
-  end
-end
-
-module ActionController
-  class Base
-
-    def self.cache
-      @cache_config ||= Restfulie::Server::Cache::Config.new
-    end
-
-    # renders an specific resource to xml
-    # using any extra options to render it (invoke to_xml).
-    def render_resource(resource, options = {}, render_options = {})
-
-      response.headers['Cache-control'] = "max-age=#{self.class.cache.max_age}"
-       return nil unless stale? resource.cache_info
-
-       return render(render_options) if render_options[:text]
-
-       options[:controller] = self
-       respond_to do |format|
-         add_media_responses(format, resource, options, render_options)
-       end
-
-     end
-
-     # renders a resource collection, making full use of atom support
-     def render_collection(collection, &block)
-       if block
-         content = collection.to_atom(:title =>collection_name, :controller => self) do |item|
-           block.call item
-         end
-       else
-         content = collection.to_atom(:title => collection_name, :controller => self)
-       end
-       render_resource collection, nil, {:content_type => 'application/atom+xml', :text => content}
-     end
-
-     # returns the name of this controllers collection
-     def collection_name
-       self.class.name[/(.*)Controller/,1]
-     end
-
-     def add_media_responses(format, resource, options, render_options)
-       types = Restfulie::MediaType.default_types
-       types = resource.class.media_types if resource.class.respond_to? :media_types
-       types.each do |media_type|
-         add_media_response(format, resource, media_type, options, render_options)
-       end
-     end
-
-     def add_media_response(format, resource, media_type, options, render_options)
-       controller = self
-       format.send media_type.short_name.to_sym do
-         media_type.execute_for(controller, resource, options, render_options)
-       end
-     end
-
-    # adds support to rendering resources, i.e.:
-    # render :resource => @order, :with => { :except => [:paid_at] }
-    alias_method :old_render, :render
-    def render(options = nil, extra_options = {}, &block)
-      resource = options[:resource] unless options.nil?
-      unless resource.nil?
-        render_resource(resource, options[:with])
-      else
-        old_render(options, extra_options)
-      end
-    end
-    
-    # renders a created resource including its required headers:
-    # Location and 201
-    def render_created(resource, options = {})
-      location= url_for resource
-      render_resource resource, options, {:status => :created, :location => location}
-    end
-  end
-  
-  module MimeResponds
-    class Responder
-      attr_reader :mime_type_priority
-      alias_method :old_respond, :respond unless method_defined?(:old_respond)
-      def respond
-        RestfulieResponder.new.respond(self)
-      end
-    end
-    
-    class RestfulieResponder
-      def respond(instance)
-        instance.old_respond unless instance.mime_type_priority.include? "html"
-      end
-    end
-  end
-end

data/lib/restfulie/server/instance.rb

@@ -1,102 +0,0 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-
-module Restfulie::Server::Cache
-  
-  # returns specific cache information for this resource
-  # you may customize it and return a custom etag and last_modified fields
-  def cache_info
-    info = {:etag => self}
-    info[:etag] = self.etag if self.respond_to? :etag
-    info[:last_modified] = self.updated_at.utc if self.respond_to? :updated_at
-    info
-  end
-  
-end
-
-# acts_as_restfulie instances implement this module
-module Restfulie::Server::Instance
-
-  include Restfulie::Server::Cache
-  
-  # checks whether this resource can execute a transition or has such a relation
-  def can?(what)
-    what = what.to_sym if what.kind_of? String
-    all_following_transitions.each do |t|
-      return true if t.name == what
-    end
-    false
-  end
-
-  # returns a list of available transitions for this objects state
-  # TODO rename because it should never be used by the client...
-  def available_transitions
-    status_available = respond_to?(:status) && status!=nil
-    return {:allow => []} unless status_available
-    self.class.states[self.status.to_sym] || {:allow => []}
-  end
-  
-  # returns a list containing all available transitions for this object's state
-  def all_following_transitions
-    all = [] + available_transitions[:allow]
-    following_transitions.each do |t|
-      t = Restfulie::Server::Transition.new(t) if t.kind_of? Array
-      all << t
-    end
-    all
-  end
-
-  # checks if its possible to execute such transition and, if it is, executes it
-  def move_to(name)
-    raise "Current state #{status} is invalid in order to execute #{name}. It must be one of #{transitions}" unless available_transitions[:allow].include? name
-    self.class.transitions[name].execute_at self
-  end
-  
-  # gets all the links for each transition
-  def links(controller)
-    links = []
-    unless controller.nil?
-      all_following_transitions.each do |transition|
-        rel, uri = link_for(transition, controller)
-        links << {:rel => rel, :uri => uri}
-      end
-    end
-    links
-  end
-
-  private
-  # gets a link for this transition
-  def link_for(transition, controller) 
-    transition = self.class.existing_transition(transition.to_sym) unless transition.kind_of? Restfulie::Server::Transition
-    transition.link_for(self, controller)
-  end
-
-end
-
-class Array
-  
-  include Restfulie::Server::Cache
-
-  def updated_at
-    last = nil
-    each do |item|
-      last = item.updated_at if item.respond_to?(:updated_at) && (last.nil? || item.updated_at > last)
-    end
-    last || Time.now
-  end
-  
-end

data/lib/restfulie/server/marshalling.rb

@@ -1,47 +0,0 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-
-module Restfulie
-  
-  module Server
-  
-    module Marshalling
-  
-      # marshalls your object to json.
-      # adds all links if there are any available.
-      def to_json(options = {})
-        Hash.from_xml(to_xml(options)).to_json
-      end
-
-      # marshalls your object to xml.
-      # adds all links if there are any available.
-      def to_xml(options = {})
-        options[:skip_types] = true
-        super options do |xml|
-          links(options[:controller]).each do |link|
-            if options[:use_name_based_link]
-              xml.tag!(link[:rel], link[:uri])
-            else
-              xml.tag!('atom:link', 'xmlns:atom' => 'http://www.w3.org/2005/Atom', :rel => link[:rel], :href => link[:uri])
-            end
-          end
-        end
-      end
-    end
-
-  end  
-end

data/lib/restfulie/server/opensearch/description.rb

@@ -1,54 +0,0 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-
-module Restfulie
-  module OpenSearch
-    
-    class Description
-      
-      def self.define(attribute, xml_attribute)
-        
-        define_method("#{attribute.to_s}=") do |new_value|
-          self.instance_variable_set(xml_attribute, new_value)
-        end
-        
-        define_method(attribute.to_s) do |new_value|
-          self.instance_variable_get xml_attribute
-        end
-        
-      end
-      
-      define(:short_name, :@ShortName)
-      define(:description, :@Description)
-      define(:tags, :@Tags)
-      define(:contact, :@Contact)
-      
-      def initialize(name)
-        short_name = name
-        description = name
-        @types = []
-      end
-      
-      def accepts(content_type)
-        @types << content_type
-        self
-      end
-      
-    end
-    
-  end
-end