restfulie 0.5.0 → 0.6.0

data/lib/restfulie/server/controller.rb

@@ -1,35 +1,88 @@
+#
+#  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 = {})
-       cache_info = {:etag => resource}
-       cache_info[:last_modified] = resource.updated_at.utc if resource.respond_to? :updated_at
-       if stale? cache_info
-         options[:controller] = self
-     
-         respond_to do |format|
-           add_media_responses(format, 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
 
- 
-   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)
+     # returns the name of this controllers collection
+     def collection_name
+       self.class.name[/(.*)Controller/,1]
      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)
+     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
-   end
 
     # adds support to rendering resources, i.e.:
     # render :resource => @order, :with => { :except => [:paid_at] }

data/lib/restfulie/server/instance.rb

@@ -1,50 +1,102 @@
-module Restfulie
-  module Server
-    module Instance
-
-      # 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[0], t[1], t[2], nil) if t.kind_of? Array
-          all << t
-        end
-        all
-      end
+#
+#  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. 
+#
 
-      # 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
+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
 
-      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)
+  # 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
+  
+end

data/lib/restfulie/server/marshalling.rb

@@ -1,3 +1,19 @@
+#
+#  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
   

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

@@ -0,0 +1,54 @@
+#
+#  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

data/lib/restfulie/server/opensearch.rb

@@ -0,0 +1,18 @@
+#
+#  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. 
+#
+
+require 'restfulie/server/opensearch/description'

data/lib/restfulie/server/restfulie_controller.rb

@@ -1,3 +1,20 @@
+#
+#  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
@@ -39,14 +56,40 @@ module Restfulie
         head :ok
       end
 
+      # updates a resouce
+      def update
+        type = model_type
+
+        @loaded = type.find(params[:id])
+        return head(:status => 405) unless @loaded.can? :update
+
+        return head(415) unless fits_content(type, request.headers['CONTENT_TYPE'])
+
+        @model = Hash.from_xml(request.body.string)[model_name]
+        pre_update(@model) if self.respond_to?(:pre_update)
+        
+        if @loaded.update_attributes(@model)
+          render_resource @loaded
+        else
+          render :xml => @loaded.errors, :status => :unprocessable_entity
+        end
+      end
+
       # returns the model for this controller
       def model_type
         self.class.name[/(.*)Controller/,1].singularize.constantize
       end
+      
+      # retrieves the model name
+      def model_name
+        self.class.name[/(.*)Controller/,1].singularize.underscore
+      end
     
       def fits_content(type, content_type)
         Restfulie::MediaType.supports?(content_type) &&
-                type.media_type_representations.include?(content_type)
+                (type.respond_to?(:media_type_representations) ?
+                type.media_type_representations.include?(content_type) :
+                Restfulie::MediaType.default_representations.include?(content_type))
       end
     
     end

data/lib/restfulie/server/transition.rb

@@ -1,3 +1,20 @@
+#
+#  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
@@ -8,13 +25,27 @@ module Restfulie
       attr_writer :options
       attr_accessor :result
       
-      def initialize(name, options = {}, result = nil, body = nil)
+      def initialize(*args)
+        args[0].kind_of?(Array) ? from_array(*args) : from(*args)
+      end
+      
+      private
+      def from_array(array)
+        @name = array[0]
+        @options = array.length>0 ? array[1] : nil
+        @result = array.length>1 ? array[2] : nil
+        @body = nil
+      end
+      
+      def from(name, options = {}, result = nil, body = nil)
         @name = name
         @options = options
         @result = result
         @body = body
       end
       
+      public
+      
       def action
         @options || {}
       end

data/lib/restfulie/unmarshalling.rb

@@ -1,15 +1,31 @@
-# module Hashi
-#   class CustomHash
-#     # uses_restfulie
-#     def initialize(h)
-#       @hash = h
-#       link = h['link']
-#       add_transitions([link]) if link.kind_of? Hash
-#       add_transitions(link) if link.kind_of? Array
-#     end
-#   end
-# end
+#
+#  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 Hashi
+  class CustomHash
+    def initialize(hash = {})
+      @internal_hash = hash
+      link = hash['link'] if hash.kind_of? Hash
+      add_transitions([link]) if link.kind_of? Hash
+      add_transitions(link) if link.kind_of? Array
+    end
+  end
+end
+
 # module Jeokkarak
 #   module Base
 #     alias_method :old_from_hash_parse, :from_hash_parse
@@ -27,48 +43,63 @@ module Restfulie
     # basic code from Matt Pulver
     # found at http://www.xcombinator.com/2008/08/11/activerecord-from_xml-and-from_json-part-2/
     # addapted to support links
+    
     def from_hash( hash )
       h = hash ? hash.dup : {}
       links = nil
-      h.each do |key,value|
-        case value.class.to_s
-        when 'Array'
-          if key=="link"
-            links = h[key]
-            h.delete("link")
-          else
-            h[key].map! { |e| reflect_on_association(key.to_sym ).klass.from_hash e }
-          end
-        when /\AHash(WithIndifferentAccess)?\Z/
-          if key=="link"
-            links = [h[key]]
-            h.delete("link")
+      h.each do |key, value|
+        if key == "link"
+          links = value.instance_of?(Array) ? h[key] : [h[key]]
+        elsif [Array, Hash].include? value.class
+          klazz = get_the_class(key)
+          if value.instance_of?(Array)
+            h[key].map! { |e| (klazz || Hashi::CustomHash).send(:from_hash, e) }
+          elsif value.instance_of?(Hash)
+            h[key] = klazz.array_from_hash(value)
           else
-            h[key] = reflect_on_association(key.to_sym ).klass.from_hash value
+            h[key] = klazz.from_hash value
           end
         end
-        h.delete("xmlns") if key=="xmlns"
-      end
-      result = self.new h
-      if !(links.nil?) && self.include?(Restfulie::Client::Instance)
-        result.add_transitions(links)
-      end
-      result
-    end
-  end
-end  
-
-module ActiveRecord
-  class Base
-    extend Restfulie::Unmarshalling
+         h.delete key if ["xmlns", "link"].include?(key)
+       end
+       
+       result = make_new_object h
+       result.add_transitions(links) if !(links.nil?) && self.include?(Restfulie::Client::Instance)
+       result
+     end
+     
+     # creates an array of this type based on a hash created using rails Hash.from_xml method
+     # because Hash.from_xml returns some no-cute hash structure when dealing with aligned elements
+     # we had to support it in a variety of ways.
+     # usage example:
+     #
+       # hash = {"player" => {"name" => "guilherme silveira"}}
+       # player = Player.array_from_hash(hash)
+       # puts player[0].name
+       # 
+       # hash = {"player" => [{"name" => "guilherme silveira"}, {"name" => "andre de santi"}]}
+       # player = Player.array_from_hash(hash)
+       # puts player[0].name
+       # puts player[1].name
+     def array_from_hash(hash)
+       
+       return self.from_hash(hash) unless (hash.size == 1 && hash.keys.first == self.to_s.underscore)
+       
+       children = hash.values.first
+       
+       return [self.from_hash(children)] unless children.instance_of?(Array)
 
-    def self.from_json(json)
+       children.map { |child| self.from_hash(child) }
+       
+     end
+     
+    def from_json(json)
       from_hash(safe_json_decode(json).values.first)
     end
 
     # The xml has a surrounding class tag (e.g. ship-to),
     # but the hash has no counterpart (e.g. 'ship_to' => {} )
-    def self.from_xml(xml)
+    def from_xml(xml)
       hash = Hash.from_xml xml
       head = hash[self.to_s.underscore]
       result = self.from_hash head
@@ -77,9 +108,20 @@ module ActiveRecord
       result
     end
     
+    private
+    def make_new_object(hash = {})
+      obj = self.new
+      hash.keys.each { |key| obj.send("#{key}=", hash[key]) }
+      obj
+    end
+    
+    def get_the_class(name)
+      respond_to?(:reflect_on_association) ? reflect_on_association(name.to_sym).klass.to_s.constantize : nil
+    end
   end
-end
+end  
 
+private
 def safe_json_decode(json)
   return {} if !json
   begin

data/lib/restfulie.rb

@@ -1,3 +1,22 @@
+#
+#  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. 
+#
+
+require 'restfulie/logger'
+
 require 'net/http'
 require 'uri'
 require 'vendor/jeokkarak/jeokkarak'
@@ -13,9 +32,13 @@ require 'restfulie/server/marshalling'
 require 'restfulie/server/transition'
 require 'restfulie/server/restfulie_controller'
 require 'restfulie/server/atom_media_type'
+require 'restfulie/unmarshalling'
 
-module Restfulie
+# Author:: Guilherme Silveira (mailto:guilherme.silveira@caelum.com.br)
 
+# This module controls global options for the Restfulie framework.
+module Restfulie
+  
   # Sets this class as a restfulie class.
   # You may pass a block defining your own transitions.
   #
@@ -37,6 +60,8 @@ module Restfulie
     extend Restfulie::MediaTypeControl
     include Restfulie::Server::Instance
     include Restfulie::Server::Marshalling
+    extend Restfulie::Unmarshalling #TODO still needs testing. e.g. server model has from_xml
+    #TODO and need to test (de)serialization with both AR and no-AR
     
     self.send :define_method, :following_transitions do
       transitions = []
@@ -49,4 +74,4 @@ end
 
 Object.extend Restfulie
 
-require 'restfulie/unmarshalling'
+include ActiveSupport::CoreExtensions::Hash