restfully 0.6.3 → 0.7.0.pre

data/lib/restfully/media_type/application_json.rb

@@ -0,0 +1,21 @@
+require 'json'
+
+module Restfully
+  module MediaType
+
+    class ApplicationJson < AbstractMediaType
+      class JSONParser
+        def self.load(io, *args)
+          JSON.load(io)
+        end
+        def self.dump(object, *args)
+          JSON.dump(object)
+        end
+      end
+      set :signature, "application/json"
+      set :parser, JSONParser
+    end
+
+  end
+
+end

data/lib/restfully/media_type/application_vnd_bonfire_xml.rb

@@ -0,0 +1,177 @@
+require 'xml'
+
+module Restfully
+  module MediaType
+    class ApplicationVndBonfireXml < AbstractMediaType
+      NS = "http://api.bonfire-project.eu/doc/schemas/occi"
+      HIDDEN_TYPE_KEY = "__type__"
+
+      def collection?
+        !!(property("items") && property("total") && property("offset"))
+      end
+
+      class Parser
+        class << self
+          def load(io, *args)
+            if io.respond_to?(:read)
+              io = io.read
+            end
+            xml = XML::Document.string(io.to_s)
+            load_xml(xml.root).merge(HIDDEN_TYPE_KEY => xml.root.name)
+          end
+
+
+          def dump(object, opts = {})
+            root_name = if object[HIDDEN_TYPE_KEY]
+              object[HIDDEN_TYPE_KEY]
+            elsif opts[:uri]
+              # OK, this is ugly
+              opts[:uri].path.to_s.split("/").last.gsub(/s$/,'')
+            else
+              fail "Can't infer a name for the root element for object: #{object.inspect}"
+            end
+            xml = XML::Document.new
+            xml.root = XML::Node.new(root_name)
+            xml.root["xmlns"] = NS
+            dump_object(object, xml.root)
+            xml.to_s
+          end
+
+          protected
+
+          def load_xml(element)
+            h = {}
+            element.each_element do |e|
+              next if e.empty?
+              if e.name == 'items' && element.name == 'collection'
+                h['total'] = e.attributes['total'].to_i
+                h['offset'] = e.attributes['offset'].to_i
+                h['items'] = []
+                e.each_element do |e2|
+                  h['items'] << load_xml(e2).merge(HIDDEN_TYPE_KEY => e2.name)
+                end
+                # if no total specified, total equals the number of items
+                h['total'] = h['items'].length if h['total'] == 0
+              else
+                load_xml_element(e, h)
+              end
+            end
+            if element.attributes["href"]
+              h["link"] ||= []
+              h["link"].push({
+                "href" => element.attributes["href"],
+                "rel" => "self"
+              })
+            end
+            h
+          end
+
+          # We use <tt>HIDDEN_TYPE_KEY</tt> property to keep track of the root name.
+          def load_xml_element(element, h)
+            if element.attributes? && href = element.attributes.find{|attr|
+              attr.name == "href"
+            }
+              single_or_array(h, element.name, element.attributes.inject({}) {|memo, attr| memo[attr.name] = attr.value; memo})
+              #build_resource(href.value))
+            else
+              if element.children.any?(&:element?)
+                single_or_array(h, element.name, load_xml(element))
+              else
+                value = element.content.strip
+                unless value.empty?
+                  single_or_array(h, element.name, value)
+                end
+              end
+            end
+          end
+
+          def single_or_array(h, key, value)
+            if h.has_key?(key)
+              if h[key].kind_of?(Array)
+                h[key].push(value)
+              else
+                h[key] = [h[key], value]
+              end
+            elsif ["disk", "nic", "link"].include?(key)
+              h[key] = [value]
+            else
+              h[key] = value
+            end
+          end
+
+          # def build_resource(uri)
+          #   uri
+          # end
+
+          def dump_object(object, parent)
+            case object
+            when Restfully::Resource
+              dump_object({"href" => object.uri.to_s}, parent)
+            when Hash
+              if object.has_key?("href")
+                # only attributes
+                object.each{|kattr,vattr|
+                  parent.attributes[kattr.to_s] = vattr
+                }
+              else
+                object.each do |k,v|
+                  next if k == HIDDEN_TYPE_KEY
+                  node = XML::Node.new(k.to_s)
+                  parent << node
+                  dump_object(v, node)
+                end
+              end
+            when Array
+              dump_object(object[0], parent)
+              object[1..-1].each{|item|
+                node = XML::Node.new(parent.name)
+                dump_object(item, node)
+                parent.parent << node
+              }
+            else
+              parent << object.to_s
+            end
+          end
+        end
+      end
+
+      set :signature, "application/vnd.bonfire+xml"
+      set :parser, Parser
+
+      def extract_links
+        (property.delete("link") || []).map do |link|
+          l = Link.new(
+            :rel => link['rel'],
+            :type => link['type'] || self.class.default_type,
+            :href => link['href'],
+            :title => link["title"],
+            :id => link["title"]
+          )
+        end
+      end
+
+      def represents?(id)
+        property("id") == id.to_s || property("name") == id.to_s
+      end
+      
+      def complete?
+        if property.reject{|k,v| k==HIDDEN_TYPE_KEY}.empty? && links.find(&:self?)
+          false
+        else
+          true
+        end
+      end
+
+      # Only for collections
+      def each(*args, &block)
+        @items ||= (property("items") || []).map{|i|
+          self.class.new(self.class.serialize(i), @session)
+        }
+        @items.each(*args, &block)
+      end
+
+    end
+
+    register ApplicationVndBonfireXml
+  end
+end

data/lib/restfully/media_type/application_x_www_form_urlencoded.rb

@@ -0,0 +1,33 @@
+require 'rack/utils'
+
+module Restfully
+  module MediaType
+    
+    class ApplicationXWwwFormUrlencoded < AbstractMediaType
+      
+      class Parser
+        def self.load(object, *args)
+          if object.respond_to? :to_str
+            object = object.to_str
+          elsif object.respond_to? :to_io
+            object = object.to_io.read
+          else
+            object = object.read
+          end
+          ::Rack::Utils.parse_nested_query(object)
+        end
+        
+        def self.dump(object, *args)
+          ::Rack::Utils.build_nested_query(object)
+        end
+      end
+      
+      set :signature, "application/x-www-form-urlencoded"
+      set :parser, Parser
+    end
+  
+    register ApplicationXWwwFormUrlencoded
+    
+  end
+  
+end

data/lib/restfully/media_type/grid5000.rb

@@ -0,0 +1,67 @@
+require 'json'
+
+module Restfully
+  module MediaType
+    class Grid5000 < AbstractMediaType
+
+      set :signature, %w{
+        grid
+        site
+        cluster
+        node
+        nodeStatus
+        version
+        collection
+        timeseries
+        versions
+        user
+        metric
+        job
+        deployment
+        notification
+      }.map{|n|
+        "application/vnd.fr.grid5000.api.#{n}+json"
+      }.push(
+        "application/vnd.grid5000+json"
+      )
+      set :parser, ApplicationJson::JSONParser
+
+      def extract_links
+        (property.delete("links") || []).map do |link|
+          l = Link.new(
+            :rel => link['rel'],
+            :type => link['type'],
+            :href => link['href'],
+            :title => link["title"],
+            :id => link["title"]
+          )
+        end
+      end
+
+      def collection?
+        !!(property("items") && property("total") && property("offset"))
+      end
+
+      def meta
+        if collection?
+          property("items")
+        else
+          property
+        end
+      end
+
+      def represents?(id)
+        property("uid") == id.to_s || property("uid") == id.to_i
+      end
+
+      # Only for collections
+      def each(*args, &block)
+        (property("items") || []).map{|i|
+          self.class.new(self.class.serialize(i), @session)
+        }.each(*args, &block)
+      end
+
+    end
+    
+  end
+end

data/lib/restfully/media_type/wildcard.rb

@@ -0,0 +1,27 @@
+module Restfully
+  module MediaType
+
+    class Wildcard < AbstractMediaType
+      class IdentityParser
+        def self.load(object, *args)
+          if object.respond_to? :to_str
+            object = object.to_str
+          elsif object.respond_to? :to_io
+            object = object.to_io.read
+          else
+            object = object.read
+          end
+        end
+
+        def self.dump(object, *args)
+          object
+        end
+      end
+
+      set :signature, "*/*"
+      set :parser, IdentityParser
+    end
+
+  end
+
+end

data/lib/restfully/rack.rb

@@ -0,0 +1 @@
+require 'restfully/rack/basic_auth'

data/lib/restfully/rack/basic_auth.rb

@@ -0,0 +1,26 @@
+require 'base64'
+
+module Restfully
+  module Rack
+    class BasicAuth
+      def initialize(app, username, password)
+        @app = app
+        @username = username
+        @password = password
+      end
+      
+      def call(env)
+        env['HTTP_AUTHORIZATION'] = [
+          "Basic",
+          Base64.encode64([
+            @username,
+            @password
+          ].join(":"))
+        ].join(" ")
+        
+        @app.call(env)
+      end
+      
+    end # class BasicAuth
+  end # module Rack
+end

data/lib/restfully/resource.rb

@@ -1,256 +1,193 @@
 module Restfully
-  
   # This class represents a Resource, which can be accessed and manipulated
   # via HTTP methods.
-  # 
+  #
   # The <tt>#load</tt> method must have been called on the resource before
   # trying to access its attributes or links.
-  # 
+  #
   class Resource
-    
-    attr_reader :uri, 
-                :session, 
-                :links, 
-                :title, 
-                :properties, 
-                :executed_requests
-    
-    # == Description
-    # Creates a new Resource.
-    # <tt>uri</tt>:: a URI object representing the URI of the resource
-    #                (complete, absolute or relative URI)
-    # <tt>session</tt>:: an instantiated Restfully::Session object
-    # <tt>options</tt>:: a hash of options (see below)
-    # == Options
-    # <tt>:title</tt>:: an optional title for the resource
-    def initialize(uri, session, options = {})
-      options = options.symbolize_keys
-      @uri = uri.kind_of?(URI) ? uri : URI.parse(uri.to_s)
+    attr_reader :response, :request, :session
+
+    def initialize(session, response, request)
       @session = session
-      @title = options[:title]
-      reset
+      @response = response
+      @request = request
+      @associations = {}
     end
-    
-    # Resets all the inner objects of the resource
-    # (you must call <tt>#load</tt> if you want to repopulate the resource).
-    def reset
-      @executed_requests = Hash.new
-      @links = Hash.new
-      @properties = Hash.new
-      @status = :stale
-      self
-    end
-    
+
     # == Description
-    # Returns the value corresponding to the specified key, 
+    # Returns the value corresponding to the specified key,
     # among the list of resource properties
-    # 
+    #
     # == Usage
     #   resource["uid"]
     #   => "rennes"
     def [](key)
-      @properties[key]
+      media_type.property(key)
     end
-    
-    def respond_to?(method, *args)
-      @links.has_key?(method.to_s) || super(method, *args)
+
+    def uri
+      request.uri
+    end
+
+    def media_type
+      response.media_type
+    end
+
+    def collection?
+      media_type.collection?
     end
     
-    def method_missing(method, *args)
-      if link = @links[method.to_s]
-        session.logger.debug "Loading link #{method}, args=#{args.inspect}"
-        link.load(*args)
-      else
-        super(method, *args)
-      end
+    def kind
+      collection? ? "Collection" : "Resource"
     end
     
-    # == Description
-    # Executes a GET request on the resource, and populate the list of its
-    # properties and links
-    # <tt>options</tt>:: list of options to pass to the request (see below)
-    # == Options
-    # <tt>:reload</tt>:: if set to true, a GET request will be triggered 
-    #                    even if the resource has already been loaded [default=false]
-    # <tt>:query</tt>:: a hash of query parameters to pass along the request. 
-    #                   E.g. : resource.load(:query => {:from => (Time.now-3600).to_i, :to => Time.now.to_i})
-    # <tt>:headers</tt>:: a hash of HTTP headers to pass along the request. 
-    #                     E.g. : resource.load(:headers => {'Accept' => 'application/json'})
-    # <tt>:body</tt>:: if you already have the unserialized response body of this resource, 
-    #                  you may pass it so that the GET request is not triggered.
+    def signature(closed=true)
+      s = "#<#{kind}:0x#{object_id.to_s(16)}"
+      s += " uri=#{uri.to_s}"
+      s += ">" if closed
+      s
+    end
+
     def load(options = {})
-      options = options.symbolize_keys
-      force_reload = !!options.delete(:reload)
-      stale! unless !force_reload && (request = executed_requests['GET']) && request['options'] == options && request['body']
-      if stale?
-        reset
-        if !force_reload && options[:body]
-          body = options[:body]
-          headers = {}
+      # Send a GET request only if given a different set of options
+      if @request.update!(options) || @request.no_cache?
+        @response = session.execute(@request)
+        if session.process(@response, @request)
+          @associations.clear
         else
-          response = session.get(uri, options)
-          body = response.body
-          headers = response.headers
-        end
-        executed_requests['GET'] = {
-          'options' => options, 
-          'body' =>  body,
-          'headers' => headers
-        }
-        executed_requests['GET']['body'].each do |key, value|
-          populate_object(key, value)
+          raise Error, "Cannot reload the resource"
         end
-        @status = :loaded
       end
-      self
+      
+      build
+    end
+    
+    def relationships
+      @associations.keys
+    end
+    
+    def properties
+      media_type.property.reject{|k,v|        
+        # do not return keys used for internal use
+        k.to_s =~ /^\_\_(.+)\_\_$/
+      }
     end
     
-    # Convenience function to make a resource.load(:reload => true)
     def reload
-      current_options = executed_requests['GET']['options'] rescue {}
-      stale!
-      self.load(current_options.merge(:reload => true))
+      load(:head => {'Cache-Control' => 'no-cache'})      
     end
-  
-    # == Description
-    # Executes a POST request on the resource, reload it and returns self if successful.
-    # If the response status is different from 2xx, raises a HTTP::ClientError or HTTP::ServerError.
-    # <tt>payload</tt>:: the input body of the request.
-    #                    It may be a serialized string, or a ruby object 
-    #                    (that will be serialized according to the given or default content-type).
-    # <tt>options</tt>:: list of options to pass to the request (see below)
-    # == Options
-    # <tt>:query</tt>:: a hash of query parameters to pass along the request. 
-    #                   E.g. : resource.submit("body", :query => {:param1 => "value1"})
-    # <tt>:headers</tt>:: a hash of HTTP headers to pass along the request. 
-    #                     E.g. : resource.submit("body", :headers => {:accept => 'application/json', :content_type => 'application/json'})
-    def submit(payload, options = {})
-      options = options.symbolize_keys
-      raise NotImplementedError, "The POST method is not allowed for this resource." unless http_methods.include?('POST')
-      raise ArgumentError, "You must pass a payload" if payload.nil?
-      headers = {
-        :content_type => (executed_requests['GET']['headers']['Content-Type'] || "application/x-www-form-urlencoded").split(/,/).sort{|a,b| a.length <=> b.length}[0],
-        :accept => (executed_requests['GET']['headers']['Content-Type'] || "text/plain")
-      }.merge(options[:headers] || {})
-      options = {:headers => headers}
-      options.merge!(:query => options[:query]) unless options[:query].nil?
-      response = session.post(self.uri, payload, options) # raises an exception if there is an error
-      stale!
-      if [201, 202].include?(response.status)
-        Resource.new(uri_for(response.headers['Location']), session).load
+
+    def submit(*args)
+      if allow?(:post)
+        payload, options = extract_payload_from_args(args)
+        session.post(request.uri, payload, options)
       else
-        reload
+        raise MethodNotAllowed
       end
     end
-    
-    # == Description
-    # Executes a DELETE request on the resource, and returns true if successful.
-    # If the response status is different from 2xx or 3xx, raises an HTTP::ClientError or HTTP::ServerError.
-    # <tt>options</tt>:: list of options to pass to the request (see below)
-    # == Options
-    # <tt>:query</tt>:: a hash of query parameters to pass along the request. 
-    #                   E.g. : resource.delete(:query => {:param1 => "value1"})
-    # <tt>:headers</tt>:: a hash of HTTP headers to pass along the request. 
-    #                     E.g. : resource.delete(:headers => {:accept => 'application/json'})
+
     def delete(options = {})
-      options = options.symbolize_keys
-      raise NotImplementedError, "The DELETE method is not allowed for this resource." unless http_methods.include?('DELETE')
-      response = session.delete(self.uri, options) # raises an exception if there is an error
-      stale!
-      (200..399).include?(response.status)
+      if allow?(:delete)
+        session.delete(request.uri)
+      else
+        raise MethodNotAllowed
+      end
     end
-    
-    
-    def stale!; @status = :stale;  end
-    def stale?; @status == :stale; end
 
-    
-    # == Description
-    # Returns the list of allowed HTTP methods on the resource.
-    # == Usage
-    #   resource.http_methods    
-    #   => ['GET', 'POST']
-    # 
-    def http_methods
-      reload if executed_requests['GET'].nil? || executed_requests['GET']['headers'].nil? || executed_requests['GET']['headers'].empty?
-      (executed_requests['GET']['headers']['Allow'] || "GET").split(/,\s*/)
+    def update(*args)
+      if allow?(:put)
+        payload, options = extract_payload_from_args(args)
+        session.put(request.uri, payload, options)
+      else
+        raise MethodNotAllowed
+      end
     end
-    
-    def uri_for(path)
-      uri.merge(URI.parse(path.to_s))
+
+    def allow?(method)
+      response.allow?(method)
     end
-    
-    def inspect(*args)
-      @properties.inspect(*args)
+
+    def inspect
+      if media_type.complete?
+        properties.inspect
+      else
+        "{...}"
+      end
     end
     
     def pretty_print(pp)
-      pp.text "#<#{self.class}:0x#{self.object_id.to_s(16)}"
-      pp.text " uid=#{self['uid'].inspect}" if self.class == Resource
+      pp.text signature(false)
       pp.nest 2 do
-        pp.breakable
-        pp.text "@uri="
-        uri.pretty_print(pp)
-        if @links.length > 0
+        if relationships.length > 0
           pp.breakable
-          pp.text "LINKS"
+          pp.text "RELATIONSHIPS"
           pp.nest 2 do
-            @links.to_a.each_with_index do |(key, value), i|
+            pp.breakable
+            pp.text "#{relationships.join(", ")}"
+          end
+        end  
+        pp.breakable
+        if collection?
+          # display items
+          pp.text "ITEMS (#{offset}..#{offset+length})/#{total}"
+          pp.nest 2 do
+            self.each do |item|
               pp.breakable
-              pp.text "@#{key}=#<#{value.class}:0x#{value.object_id.to_s(16)}>"
-              pp.text "," if i < @links.length-1
+              pp.text item.signature(true)
             end
-          end  
-        end
-        if @properties.length > 0
-          pp.breakable
+          end
+        else
           pp.text "PROPERTIES"
           pp.nest 2 do
-            @properties.to_a.each_with_index do |(key, value), i|
+            properties.each do |key, value|
               pp.breakable
               pp.text "#{key.inspect}=>"
               value.pretty_print(pp)
-              pp.text "," if i < @properties.length-1
             end
           end
         end
         yield pp if block_given?
       end
       pp.text ">"
-    end   
-    
-    protected
-    def populate_object(key, value)
-      case key
-      when "links"
-        value.each{|link| define_link(Link.new(link))}
-      else
-        case value
-        when Hash
-          @properties.store(key, SpecialHash.new.replace(value)) unless @links.has_key?(key)
-        when Array
-          @properties.store(key, SpecialArray.new(value))
-        else
-          @properties.store(key, value)
-        end
-      end
     end
-    def define_link(link)
-      if link.valid?
-        case link.rel
-        when 'parent'
-          @links['parent'] = Resource.new(uri.merge(link.href), session)
-        when 'collection'
-          @links[link.title] = Collection.new(uri.merge(link.href), session, :title => link.title)
-        when 'member'
-          @links[link.title] = Resource.new(uri.merge(link.href), session, :title => link.title)
-        when 'self'
-          # we do nothing
+
+    def build
+      # only build once
+      if @associations.empty?
+        extend Collection if collection?
+
+        response.links.each do |link|
+          @associations[link.id] = nil
+          
+          self.class.class_eval do
+            define_method link.id do |*args|
+              @associations[link.id] ||= session.get(link.href, :head => {
+                'Accept' => link.type
+              }).load(*args)
+            end
+          end
+          
         end
-      else 
-        session.logger.warn link.errors.join("\n")
       end
+      self
+    end
+
+    protected
+    def extract_payload_from_args(args)
+      options = args.extract_options!
+      head = options.delete(:headers) || options.delete(:head)
+      query = options.delete(:query)
+
+      payload = args.shift || options
+      
+      options = {
+        :head => head, :query => query
+      }
+      
+      [payload, options]
     end
     
-  end # class Resource
-end # module Restfully
+
+  end
+end