restfulie 0.6.0 → 0.7.0

data/lib/restfulie/client/instance.rb

@@ -1,158 +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::Client::Instance
-      
-  # list of possible states to access
-  def existing_relations
-    @existing_relations ||= {}
-  end
-
-  # which content-type generated this data
-  attr_reader :_came_from
-  
-  # prepares a new request
-  def request
-    Restfulie::Client::RequestExecution.new(self.class, self)
-  end
-  
-  # parse arguments from a transition invocation (or relation)
-  # it will receive either zero, one or two args, if there are two args, return them
-  # if there is one hash arg, its the options, add a data = nil
-  # if there is one arg (not a hash), its the data, add a options = {}
-  # if there are no args, data is nil and options = {}
-  def parse_args_from_transition(args)
-    data = nil
-    if args.nil? || args.size==0
-      options = {}
-    elsif args.size==1
-      if args[0].kind_of?(Hash)
-        options = args[0]
-      else
-        data = args[0]
-        options = {}
-      end
-    elsif args.size==2
-      data = args[0]
-      options = args[1] || {}
-    end
-    [data, options]
-  end
-  
-  def invoke_remote_transition(name, args, block = nil)
-    
-    data, options = parse_args_from_transition(args)
-    
-    method = Restfulie::Client::Config.requisition_method_for options[:method], name
-    state = self.existing_relations[name]
-    
-    request = Restfulie::Client::RequestExecution.new(self.class, self).at(state["href"] || state[:href]).with(options[:headers])
-    request.do method, name, data
-
-  end
-
-  # inserts all links from this object as can_xxx and xxx methods
-  def add_transitions(links)
-    links.each do |t|
-      self.existing_relations[t["rel"] || t[:rel]] = t
-      self.add_state(t)
-    end
-    self.extend Restfulie::Client::State
-  end
-
-  # adds the specific information for one state change or related resource
-  def add_state(transition)
-    name = transition["rel"] || transition[:rel]
-  
-    # TODO: wrong, should be instance_eval
-    self.class.module_eval do
-    
-      def temp_method(*args, &block)
-        self.invoke_remote_transition(Restfulie::Client::Helper.current_method, args, block)
-      end
-    
-      alias_method name, :temp_method
-      undef :temp_method
-    end
-  end  
-
-  # returns a list of extended fields for this instance.
-  # extended fields are those unknown to this model but kept in a hash
-  # to allow forward-compatibility.
-  def extended_fields
-    @extended_fields ||= {}
-    @extended_fields
-  end
-
-  def method_missing(name, *args)
-    name = name.to_s if name.kind_of? Symbol
-
-    if name[-1,1] == "="
-      extended_fields[name.chop] = args[0] 
-    elsif name[-1,1] == "?"
-      found = extended_fields[name.chop]
-      return super(name,args) if found.nil?
-      parse(found)
-    else
-      found = extended_fields[name]
-      return super(name,args) if found.nil?
-      parse(transform(found))
-    end
-
-  end
-
-  def respond_to?(sym)
-    extended_fields[sym.to_s].nil? ? super(sym) : true
-  end
-
-  # redefines attribute definition allowing the invocation of method_missing
-  # when an attribute does not exist
-  def attributes=(values)
-    values.each do |key, value|
-      unless attributes.include? key
-        method_missing("#{key}=", value)
-        values.delete key
-      end
-    end
-    super(values)
-  end
-
-
-  # serializes the extended fields with the existing fields
-  def to_xml(options={})
-    super(options) do |xml|
-      extended_fields.each do |key,value|
-        xml.tag! key, value
-      end
-    end
-  end
-
-  private
-  
-  # transforms a value in a custom hash
-  def transform(value)
-    return CustomHash.new(value) if value.kind_of?(Hash) || value.kind_of?(Array)
-    value
-  end
-  
-  def parse(val)
-    raise "undefined method: '#{val}'" if val.nil?
-    val
-  end
-
-
-end

data/lib/restfulie/client/request_execution.rb

@@ -1,321 +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. 
-#
-
-require 'restfulie/client/extensions/http'
-
-module Restfulie
-  module Client
-    
-    # extension to all answers that allows you to access the web response
-    module WebResponse
-      attr_accessor :web_response
-    end
-    
-    # some error ocurred while processing the request
-    class ResponseError < Exception
-    end
-    
-    # Handles response answered by servers by accessing the specific callback for a http response code.
-    module ResponseHandler
-      
-      class << self
-
-        # registers a new callback for a specific range of response codes
-        #
-        # Restfulie::Client::ResponseHandler.register(400, 599) do |restfulie_response|
-        #   # returns the original reponse object
-        #   restfulie_response.response
-        # end
-        def register(min_code, max_code, &block)
-          (min_code..max_code).each do |code|
-            handlers[code] = block
-          end
-        end
-
-        # callback that returns the http response object
-        def pure_response_return(restfulie_response)
-          restfulie_response.response
-        end
-
-        # callback that raises a ResponseError
-        def raise_error(restfulie_response)
-          raise Restfulie::Client::ResponseError.new(restfulie_response.response)
-        end
-
-        # callback that parses the response media type and body,
-        # returning a deserialized representation of the resource.
-        # note that this will also set the _came_from instance variable with the content type
-        # this resource was represented, in order to allow further requests to prefer this content type.
-        def parse_entity(restfulie_response)
-          response = restfulie_response.response
-          content_type = response.content_type
-          type = Restfulie::MediaType.type_for(content_type)
-          if content_type[-3,3]=="xml"
-            result = type.from_xml response.body
-          elsif content_type[-4,4]=="json"
-            result = type.from_json response.body
-          else
-            result = generic_parse_entity restfulie_response
-          end
-          result.instance_variable_set :@_came_from, content_type
-          result
-        end
-
-        # callback taht executes a GET request to the response Location header.
-        # this is the typical callback for 200 response codes.
-        def retrieve_resource_from_location(restfulie_response)
-          restfulie_response.type.from_web restfulie_response.response["Location"]
-        end
-
-        # given a restfulie response, extracts the response code and invoke the registered callback.
-        def handle(restfulie_response)
-          handlers[restfulie_response.response.code.to_i].call(restfulie_response)
-        end
-        
-        def generic_parse_entity(restfulie_response)
-          response = restfulie_response.response
-          content_type = response.content_type
-          type = Restfulie::MediaType.type_for(content_type)
-          method = "from_#{content_type}".to_sym
-          raise Restfulie::UnsupportedContentType.new("unsupported content type '#{content_type}' because '#{type}.#{method.to_s}' was not found") unless type.respond_to? method
-          type.send(method, response.body)
-        end
-
-        private
-        def handlers
-          @handlers ||= {}
-        end
-        
-        def register_func(min, max, proc)
-          register(min, max) { |r| proc.call(r) }
-        end
-
-      end
-      
-      register_func( 100, 599, Proc.new{ |r| pure_response_return r} )
-      register_func( 200, 200, Proc.new{ |r| parse_entity r} )
-      register_func( 301, 301, Proc.new{ |r| retrieve_resource_from_location r} )
-      
-    end
-
-    
-    # TODO there should be a response for each method type
-    class Response
-      
-      attr_reader :type, :response
-      
-      def initialize(type, response)
-        @type = type
-        @response = response
-      end
-
-      # TODO remote_post can probably be moved, does not need to be on the object's class itself
-      # the expected_content_type is used in case a redirection takes place
-      def parse_post(expected_content_type)
-        code = @response.code
-        if code=="301" && @type.follows.moved_permanently? == :all
-          result = @type.remote_post_to(@response["Location"], @response.body)
-          enhance(result)
-        elsif code=="201"
-          Restfulie.at(@response["Location"]).accepts(expected_content_type).get
-        else
-          final_parse
-        end
-      end
-      
-      # gets a result object and enhances it with web response methods
-      # by extending WebResponse and defining the attribute web_response
-      def enhance(result)
-        @response.previous = result.web_response if result.respond_to? :web_response
-        result.extend Restfulie::Client::WebResponse
-        result.web_response = @response
-        result
-      end
-      
-      # parses this response using the correct ResponseHandler and enhances it
-      def final_parse
-        enhance Restfulie::Client::ResponseHandler.handle(@response)
-      end
-
-      # detects which type of method invocation it was and act accordingly
-      # TODO this should be called by RequestExcution, not instance
-      def parse(method, invoking_object, content_type)
-
-        return enhance(invoking_object) if @response.code == "304"
-
-        # return block.call(@response) if block
-
-        return final_parse if method == Net::HTTP::Get
-        return parse_post(content_type) if method == Net::HTTP::Post
-        final_parse
-        
-      end
-      
-    end
-
-    class RequestExecution
-      
-      def initialize(type)
-        initialize(type, nil)
-      end
-
-      def initialize(type, invoking_object)
-        @type = type
-        @content_type = "application/xml"
-        @accepts = "application/xml"
-        @invoking_object = invoking_object
-      end
-
-      def at(uri)
-        @uri = uri
-        self
-      end
-      
-      # sets the Content-type AND Accept headers for this request
-      def as(content_type)
-        @content_type = content_type
-        @accepts = content_type
-        self
-      end
-      
-      # sets the Accept header for this request
-      def accepts(content_type)
-        @accepts = content_type
-        self
-      end
-      
-      def with(headers)
-        @headers = headers
-        self
-      end
-
-      # asks to create this content on the server (post it)
-      def create(content)
-        post(content)
-      end
-      
-      # executes an http request using the specified verb
-      #
-      # example:
-      # do(Net::HTTP::Get, 'self', nil)
-      # do(Net::HTTP::Post, 'payment', '<payment/>')
-      def do(verb, relation_name, body = nil)
-        url, http_request = prepare_request(verb, relation_name, body)
-        response = execute_request(url, http_request)
-        Restfulie::Client::Response.new(@type, response).parse(verb, @invoking_object, "application/xml")
-      end
-      
-      private
-      def execute_request(url, http_request)
-        cached = Restfulie.cache_provider.get(url, http_request) 
-        return cached if cached
-
-        response = Net::HTTP.new(url.host, url.port).request(http_request)
-        Restfulie.cache_provider.put(url, http_request, response)
-      end
-      
-      public
-      
-      def prepare_request(verb, relation_name, body = nil)
-        url = URI.parse(@uri)
-        req = verb.new(url.path)
-        add_basic_request_headers(req, relation_name)
-        
-        if body
-          req.body = body
-          req.add_field("Content-type", "application/xml") if req.get_fields("Content-type").nil?
-        end
-        [url, req]
-      end
-      
-      # post this content to the server
-      def post(content)
-        remote_post_to(@uri, content)
-      end
-      
-      # retrieves information from the server using a GET request
-      def get(options = {})
-        from_web(@uri, options)
-      end
-      
-      def add_headers_to(hash)
-        hash[:headers] = {} unless hash[:headers]
-        hash[:headers]["Content-type"] = @content_type
-        hash[:headers]["Accept"] = @accepts
-        hash
-      end
-      
-      def change_to_state(name, args)
-        if !args.empty? && args[args.size-1].kind_of?(Hash)
-          add_headers_to(args[args.size-1])
-        else
-          args << add_headers_to({})
-        end
-        @invoking_object.invoke_remote_transition name, args
-      end
-      
-      # invokes an existing relation or delegates to the existing definition of method_missing
-      def method_missing(name, *args)
-        if @invoking_object && @invoking_object.existing_relations[name.to_s]
-          change_to_state(name.to_s, args)
-        else
-          super(name, args)
-        end
-      end
-
-      def add_basic_request_headers(req, name = nil)
-        
-        req.add_field("Accept", @accepts) unless @accepts.nil?
-        
-        @headers.each do |key, value|
-          req.add_field(key, value)
-        end if @headers
-        
-        req.add_field("Accept", @invoking_object._came_from) if req.get_fields("Accept")==["*/*"]
-        
-        if @type && name && @type.is_self_retrieval?(name) && @invoking_object.respond_to?(:web_response)
-          req.add_field("If-None-Match", @invoking_object.web_response.etag) if !@invoking_object.web_response.etag.nil?
-          req.add_field("If-Modified-Since", @invoking_object.web_response.last_modified) if !@invoking_object.web_response.last_modified.nil?
-        end
-        
-      end
-
-      private
-      def remote_post_to(uri, content)
-        
-        url = URI.parse(uri)
-        req = Net::HTTP::Post.new(url.path)
-        req.body = content
-        add_basic_request_headers(req)
-        req.add_field("Content-type", @content_type)
-
-        response = Net::HTTP.new(url.host, url.port).request(req)
-        Restfulie::Client::Response.new(@type, response).parse_post(@content_type)
-      end
-
-      def from_web(uri, options = {})
-        uri = URI.parse(uri)
-        req = Net::HTTP::Get.new(uri.path)
-        options.each { |key,value| req[key] = value }
-        add_basic_request_headers(req)
-        res = Net::HTTP.new(uri.host, uri.port).request(req)
-        Restfulie::Client::Response.new(@type, res).final_parse
-      end
-      
-    end
-  end
-end

data/lib/restfulie/client/state.rb

@@ -1,36 +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 Client
-  
-    # adds respond_to and has_state methods to resources
-    module State
-    
-      # overrides the respond_to? method to check if this method is contained or was defined by a state
-      def respond_to?(sym)
-        has_state(sym.to_s) || super(sym)
-      end
-
-      # returns true if this resource has a state named name
-      def has_state(name)
-        !@existing_relations[name].nil?
-      end
-    end
-  end
-end

data/lib/restfulie/media_type.rb

@@ -1,143 +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. 
-#
-
-require 'restfulie/media_type_control'
-
-module Restfulie
-  
-  # represents an error when we are unable to support the desired content type
-  class UnsupportedContentType < Exception
-    
-    attr_reader :msg
-    def initialize(msg)
-      @msg = msg
-    end
-    
-    def to_s
-      @msg
-    end
-    
-  end
-
-  module MediaType
-    
-    # returns the decoder type for a specific content type
-    def self.type_for(content_type)
-      if Restfulie::MediaType.supports? content_type
-        Restfulie::MediaType.media_type(content_type)
-      else
-        Restfulie::MediaType::DefaultMediaTypeDecoder
-      end
-    end
-
-    # TODO removethis nasty method
-    def self.rendering_type(name, type)
-      Restfulie::MediaType.media_types[name] || Type.new(name,type)
-    end
-  
-    # TODO remove this method
-    def self.custom_type(name, type, l)
-      Restfulie::MediaType.media_types[name] || CustomType.new(name, type, l)
-    end
-  
-    class Type
-      attr_reader :name, :type
-      def initialize(name, type)
-        @name = name
-        @type = type
-      end
-      def short_name
-        name.gsub(/\//,'_').gsub(/\+/,'_').gsub(/\./,'_')
-      end
-    
-      def format_name
-        name[/(.*[\+\/])?(.*)/,2]
-      end
-      def execute_for(controller, resource, options, render_options)
-        response = ["xml", "json"].include?(format_name) ? resource.send(:"to_#{format_name}", options) : resource
-        render(controller, response, render_options)
-      end
-      def render(controller, response, options)
-        options[:text] = response
-        options[:content_type] = name
-        controller.render options
-      end
-    end
-  
-    class CustomType < Type
-      def initialize(name, type, l)
-        super(name, type)
-        @lambda = l
-      end
-      def execute_for(controller, resource, options, render_options)
-        @lambda.call
-      end
-    end
-    
-    # from rails source code
-    def self.constantize(camel_cased_word)
-     unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
-       raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
-     end
-
-     Object.module_eval("::#{$1}", __FILE__, __LINE__)
-    end
-
-    module DefaultMediaTypeDecoder
-    
-      def self.from_xml(xml)
-        hash = Hash.from_xml xml
-        from_hash(hash)
-      end
-      
-      def self.from_hash(hash)
-
-        type = Restfulie::MediaType.constantize(hash.keys.first.camelize) rescue Hashi
-
-        result = type.from_hash hash.values.first
-        return nil if result.nil?
-        result
-        
-      end
-      
-      def self.from_json(json)
-        hash = safe_json_decode(json)
-        type = hash.keys.first.camelize.constantize
-        type.from_hash(hash.values.first)
-      end
-
-      def self.from_html(body)
-        Hashi::CustomHash.new :body => body
-      end
-    
-      def self.from_xhtml(body)
-        Hashi::CustomHash.new :body => body
-      end
-    
-    end
-  end
-  
-end
-
-def safe_json_decode(json)
-  return {} if !json
-  begin
-    ActiveSupport::JSON.decode json
-  rescue ; {} end
-end
-
-require 'restfulie/media_type_defaults'