wrest 0.0.9 → 0.1.0

data/lib/wrest/curl/request.rb

@@ -0,0 +1,95 @@
+# Copyright 2009 Sidu Ponnappa
+
+# 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 Wrest::Curl
+  # This represents a HTTP request. Typically you will never need to instantiate
+  # one of these yourself - you can use one of the more conveient APIs via Wrest::Uri
+  # or Wrest::Http::Get etc. instead.
+  class Request
+    attr_reader :http_request, :uri, :body, :headers, :username, :password, :follow_redirects,
+    :follow_redirects_limit, :timeout, :connection, :parameters, :auth_type
+    # Valid tuples for the options are:
+    # :username => String, defaults to nil
+    # :password => String, defaults to nil
+    # :follow_redirects => Boolean, defaults to true for Get, false for anything else
+    # :follow_redirects_limit =>  Integer, defaults to 5. This is the number of redirects
+    #                             that Wrest will automatically follow before raising an
+    #                             Wrest::Exceptions::AutoRedirectLimitExceeded exception.
+    #                             For example, if you set this to 1, the very first redirect
+    #                             will raise the exception.
+    # :timeout => The period, in seconds, after which a Timeout::Error is raised
+    #             in the event of a connection failing to open. Defaulted to 60 by Uri#create_connection.
+    # :connection => The HTTP Connection object to use. This is how a keep-alive connection can be
+    #             used for multiple requests. Not yet fully implemented for Curl.
+    #
+    # Curl specific options:
+    # :auth_type => This is a curl specific option and can be one of :basic, :digest, or :any. The default is :basic.
+    def initialize(wrest_uri, http_verb, parameters = {}, body = nil, headers = {}, options = {})
+      @uri = wrest_uri
+      @headers = headers.stringify_keys
+      @parameters = parameters      
+      @body = body
+            
+      @options = options.clone
+      @auth_type = @options[:auth_type] || :basic      
+      @username = @options[:username]
+      @password = @options[:password]
+      @follow_redirects = (@options[:follow_redirects] ||= false)
+
+      @follow_redirects_limit = (@options[:follow_redirects_limit] ||= 5)
+      @timeout = @options[:timeout] || 60
+      @connection = @options[:connection]
+      
+      @http_request = Patron::Request.new
+      @http_request.action = http_verb
+      @http_request.upload_data = body
+      @http_request.headers = headers
+      @http_request.username = username
+      @http_request.password = password
+      @http_request.auth_type = auth_type
+      @http_request.url = parameters.empty? ? uri.to_s : "#{uri.to_s}?#{parameters.to_query}"
+      @http_request.max_redirects = follow_redirects_limit if follow_redirects
+      @http_request.timeout = @timeout
+    end
+
+    # Makes a request and returns a Wrest::Http::Response.
+    # Data about the request is and logged to Wrest.logger
+    # The log entry contains the following information:
+    #
+    # --> indicates a request
+    # <-- indicates a response
+    #
+    # The type of request is mentioned in caps, followed by a hash
+    # uniquely uniquely identifying a particular request/response pair.
+    # In a multi-process or multi-threaded scenario, this can be used
+    # to identify request-response pairs.
+    #
+    # The request hash is followed by a connection hash; requests using the
+    # same connection (effectively a keep-alive connection) will have the
+    # same connection hash.
+    #
+    # This is followed by the response code, the payload size and the time taken.
+    def invoke
+      response = nil
+
+      @connection ||= Patron::Session.new
+      raise ArgumentError, "Empty URL" if http_request.url.empty?      
+
+      prefix = "#{http_request.action.to_s.upcase} #{http_request.hash} #{connection.hash}"
+
+      Wrest.logger.debug "--> (#{prefix}) #{http_request.url}"
+      time = Benchmark.realtime { response =  Wrest::Curl::Response.new(connection.handle_request(http_request))}
+      Wrest.logger.debug "<-- (#{prefix}) %s (%d bytes %.2fs)" % [response.message, response.body ? response.body.length : 0, time]
+      
+      response
+      rescue Patron::TimeoutError => e
+        raise Wrest::Exceptions::Timeout.new(e)
+    end
+  end
+end

data/lib/wrest/curl/response.rb

@@ -0,0 +1,63 @@
+# Copyright 2009 Sidu Ponnappa
+
+# 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 Wrest #:nodoc:
+  module Curl #:nodoc:
+    # Decorates a response providing support for deserialisation.
+    class Response              
+      attr_reader :http_response
+      include HttpShared::Headers
+      
+      extend Forwardable
+      def_delegators  :@http_response, :body, :headers
+      
+      def initialize(http_response)
+        @http_response = http_response
+        initialize_http_header
+      end
+
+      def deserialise
+        deserialise_using(Wrest::Components::Translators.lookup(content_type))
+      end
+
+      def deserialise_using(translator)
+        translator.deserialise(@http_response)
+      end
+      
+      def code
+        @http_response.status
+      end
+      
+      def message
+        @http_response.status_line
+      end
+      
+      def content_length
+        self[H::ContentLength].try(:to_i)
+      end
+    
+      def content_type
+        self[H::ContentType].split(';').first
+      end
+            
+      # A null object implementation - invoking this method on
+      # a response simply returns the same response unless
+      # the response is a Redirection (code 3xx), in which case a 
+      # get is invoked on the url stored in the response headers
+      # under the key 'location' and the new Response is returned.
+      def follow(redirect_request_options = {})
+        self
+      end
+      
+      def connection_closed?
+        self[StandardHeaders::Connection].downcase == StandardTokens::Close.downcase
+      end
+    end
+  end
+end

data/lib/wrest/curl/session.rb

@@ -0,0 +1,57 @@
+# Copyright 2009 Sidu Ponnappa
+
+# 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 Wrest::Native
+  # This class is a wrapper for a keep-alive HTTP connection. It simply passes the
+  # same connection instance as an option to all Wrest::Http::Request instances created using it.
+  #
+  # If at any point the server closes an existing connection during a Session by returning a
+  # Connection: Close header the current connection is destroyed and a fresh one created for the next
+  # request.
+  #
+  # The Session constructor can accept either a String URI or a Wrest::Uri as a parameter. If you
+  # need HTTP authentication, you should use a Wrest::Uri.
+  class Session
+    attr_reader :uri
+    def initialize(uri)
+      @uri = uri.is_a?(String) ? uri.to_uri : uri
+      @default_headers = { StandardHeaders::Connection => StandardTokens::KeepAlive }
+
+      yield(self) if block_given?
+    end
+
+    def connection
+      @connection ||= @uri.create_connection
+    end
+
+    def get(path = '', parameters = {}, headers = {})
+      maybe_destroy_connection @uri[path, {:connection => self.connection}].get(parameters, headers.merge(@default_headers))
+    end
+
+    def post(path = '', body = '', headers = {}, params = {})
+      maybe_destroy_connection @uri[path, {:connection => self.connection}].post(body, headers.merge(@default_headers), params)
+    end
+    
+    def put(path = '', body = '', headers = {}, params = {})
+      maybe_destroy_connection @uri[path, {:connection => self.connection}].put(body, headers.merge(@default_headers), params)
+    end
+
+    def delete(path = '', parameters = {}, headers = {})
+      maybe_destroy_connection @uri[path, {:connection => self.connection}].delete(parameters, headers.merge(@default_headers))
+    end
+    
+    def maybe_destroy_connection(response)
+      if response.connection_closed?
+        Wrest.logger.warn "Connection #{@connection.hash} has been closed by the server"
+        @connection = nil 
+      end
+      response
+    end
+  end
+end

data/lib/wrest/curl.rb

@@ -0,0 +1,49 @@
+# Copyright 2009 Sidu Ponnappa
+
+# 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.
+
+begin
+  gem 'patron', '>=0.4.4'
+rescue Gem::LoadError => e
+  Wrest.logger.debug "Patron >= 0.4.4 not found. Patron is necessary to use libcurl. To install Patron run `sudo gem install patron` (patron is not available on JRuby, but you shouldn't need it anyway)."
+  raise e
+end
+require 'patron'
+
+module Wrest #:nodoc:
+
+  # Contains all HTTP protocol related classes such as
+  # Get, Post, Request, Response etc. and uses Curl for
+  # better performance, but works only on CRuby and only on a *nix OS.
+  #
+  # This functionality is under development and the Wrest API
+  # may not cover using it fully.
+  #
+  # Note:
+  # * The Curl based APIs do *not* support the HTTP 'options' verb.
+  # * Since auto-redirect is natively supported by Curl, auto-redirect may 
+  #   behave differently from the native implementation for now.
+  module Curl
+    include Wrest::HttpShared
+  end
+end
+
+module Patron
+  class Session
+    public :handle_request
+  end
+end
+
+require "#{Wrest::Root}/wrest/curl/response"
+require "#{Wrest::Root}/wrest/curl/request"
+require "#{Wrest::Root}/wrest/curl/get"
+require "#{Wrest::Root}/wrest/curl/put"
+require "#{Wrest::Root}/wrest/curl/post"
+require "#{Wrest::Root}/wrest/curl/delete"
+require "#{Wrest::Root}/wrest/curl/options"
+# require "#{Wrest::Root}/wrest/curl/session"

data/lib/wrest/exceptions.rb

@@ -9,10 +9,25 @@ module Wrest
     # is requested. See Translators.
     class UnsupportedContentType < StandardError
     end
-    
+
     # Raised when a request auto redirects more times than are allowed
     # by its follow_redirects_limit. See Wrest::Http::Redirection.
     class AutoRedirectLimitExceeded < StandardError
     end
+
+    # Raised when a request is made when either RAILS_ENV or
+    # ENV['RAILS_ENV'] is set to 'test', which is the case when
+    # running tests/specs in a Rails application.
+    #
+    # See wrest/test/request_patches.
+    class RealRequestMadeInTestEnvironmet < StandardError
+    end
+
+    # Raised when a request times out
+    class Timeout < StandardError
+    end
+    
+    class UnsupportedHttpVerb < StandardError
+    end
   end
 end

data/lib/wrest/http_shared/headers.rb

@@ -0,0 +1,350 @@
+#
+# Header module.
+#
+# Provides access to headers in the mixed-into class as a hash-like
+# object, except with case-insensitive keys.  Also provides
+# methods for accessing commonly-used header values in a more
+# convenient format.
+#
+# Sourced from Net::HTTP and then modified to be generic
+module Wrest
+  module HttpShared
+    module Headers
+
+      def initialize_http_header
+        headers.each do |key, value|
+          headers[key.downcase] = value.strip
+        end
+      end
+
+      # Returns the header field corresponding to the case-insensitive key.
+      # For example, a key of "Content-Type" might return "text/html"
+      def [](key)
+        headers[key] || headers[key.downcase]
+      end
+
+      # # Sets the header field corresponding to the case-insensitive key.
+      # def []=(key, val)
+      #   unless val
+      #     headers.delete key.downcase
+      #     return val
+      #   end
+      #   headers[key.downcase] = [val]
+      # end
+      #
+      # # [Ruby 1.8.3]
+      # # Adds header field instead of replace.
+      # # Second argument +val+ must be a String.
+      # # See also #[]=, #[] and #get_fields.
+      # #
+      # #   request.add_field 'X-My-Header', 'a'
+      # #   p request['X-My-Header']              #=> "a"
+      # #   p request.get_fields('X-My-Header')   #=> ["a"]
+      # #   request.add_field 'X-My-Header', 'b'
+      # #   p request['X-My-Header']              #=> "a, b"
+      # #   p request.get_fields('X-My-Header')   #=> ["a", "b"]
+      # #   request.add_field 'X-My-Header', 'c'
+      # #   p request['X-My-Header']              #=> "a, b, c"
+      # #   p request.get_fields('X-My-Header')   #=> ["a", "b", "c"]
+      # #
+      # def add_field(key, val)
+      #   if headers.key?(key.downcase)
+      #     headers[key.downcase].push val
+      #   else
+      #     headers[key.downcase] = [val]
+      #   end
+      # end
+      #
+      # # [Ruby 1.8.3]
+      # # Returns an array of header field strings corresponding to the
+      # # case-insensitive +key+.  This method allows you to get duplicated
+      # # header fields without any processing.  See also #[].
+      # #
+      # #   p response.get_fields('Set-Cookie')
+      # #     #=> ["session=al98axx; expires=Fri, 31-Dec-1999 23:58:23",
+      # #          "query=rubyscript; expires=Fri, 31-Dec-1999 23:58:23"]
+      # #   p response['Set-Cookie']
+      # #     #=> "session=al98axx; expires=Fri, 31-Dec-1999 23:58:23, query=rubyscript; expires=Fri, 31-Dec-1999 23:58:23"
+      # #
+      # def get_fields(key)
+      #   return nil unless headers[key.downcase]
+      #   headers[key.downcase].dup
+      # end
+      #
+      # # Returns the header field corresponding to the case-insensitive key.
+      # # Returns the default value +args+, or the result of the block, or nil,
+      # # if there's no header field named key.  See Hash#fetch
+      # def fetch(key, *args, &block)   #:yield: +key+
+      #   a = headers.fetch(key.downcase, *args, &block)
+      #   a.join(', ')
+      # end
+      #
+      # # Iterates for each header names and values.
+      # def each_header   #:yield: +key+, +value+
+      #   headers.each do |k,va|
+      #     yield k, va.join(', ')
+      #   end
+      # end
+      #
+      # alias each each_header
+      #
+      # # Iterates for each header names.
+      # def each_name(&block)   #:yield: +key+
+      #   headers.each_key(&block)
+      # end
+      #
+      # alias each_key each_name
+      #
+      # # Iterates for each capitalized header names.
+      # def each_capitalized_name(&block)   #:yield: +key+
+      #   headers.each_key do |k|
+      #     yield capitalize(k)
+      #   end
+      # end
+      #
+      # # Iterates for each header values.
+      # def each_value   #:yield: +value+
+      #   headers.each_value do |va|
+      #     yield va.join(', ')
+      #   end
+      # end
+      #
+      # # Removes a header field.
+      # def delete(key)
+      #   headers.delete(key.downcase)
+      # end
+      #
+      # # true if +key+ header exists.
+      # def key?(key)
+      #   headers.key?(key.downcase)
+      # end
+      #
+      # # Returns a Hash consist of header names and values.
+      # def to_hash
+      #   headers.dup
+      # end
+      #
+      # # As for #each_header, except the keys are provided in capitalized form.
+      # def each_capitalized
+      #   headers.each do |k,v|
+      #     yield capitalize(k), v.join(', ')
+      #   end
+      # end
+      #
+      # alias canonical_each each_capitalized
+      #
+      # def capitalize(name)
+      #   name.split(/-/).map {|s| s.capitalize }.join('-')
+      # end
+      # private :capitalize
+      #
+      # # Returns an Array of Range objects which represents Range: header field,
+      # # or +nil+ if there is no such header.
+      # def range
+      #   return nil unless headers['range']
+      #   self['Range'].split(/,/).map {|spec|
+      #     m = /bytes\s*=\s*(\d+)?\s*-\s*(\d+)?/i.match(spec) or
+      #     raise HTTPHeaderSyntaxError, "wrong Range: #{spec}"
+      #     d1 = m[1].to_i
+      #     d2 = m[2].to_i
+      #     if    m[1] and m[2] then  d1..d2
+      #     elsif m[1]          then  d1..-1
+      #     elsif          m[2] then -d2..-1
+      #     else
+      #       raise HTTPHeaderSyntaxError, 'range is not specified'
+      #     end
+      #   }
+      # end
+      #
+      # # Set Range: header from Range (arg r) or beginning index and
+      # # length from it (arg idx&len).
+      # #
+      # #   req.range = (0..1023)
+      # #   req.set_range 0, 1023
+      # #
+      # def set_range(r, e = nil)
+      #   unless r
+      #     headers.delete 'range'
+      #     return r
+      #   end
+      #   r = (r...r+e) if e
+      #   case r
+      #   when Numeric
+      #     n = r.to_i
+      #     rangestr = (n > 0 ? "0-#{n-1}" : "-#{-n}")
+      #   when Range
+      #     first = r.first
+      #     last = r.last
+      #     last -= 1 if r.exclude_end?
+      #     if last == -1
+      #       rangestr = (first > 0 ? "#{first}-" : "-#{-first}")
+      #     else
+      #       raise HTTPHeaderSyntaxError, 'range.first is negative' if first < 0
+      #       raise HTTPHeaderSyntaxError, 'range.last is negative' if last < 0
+      #       raise HTTPHeaderSyntaxError, 'must be .first < .last' if first > last
+      #       rangestr = "#{first}-#{last}"
+      #     end
+      #   else
+      #     raise TypeError, 'Range/Integer is required'
+      #   end
+      #   headers['range'] = ["bytes=#{rangestr}"]
+      #   r
+      # end
+      #
+      # alias range= set_range
+      #
+      # # Returns an Integer object which represents the Content-Length: header field
+      # # or +nil+ if that field is not provided.
+      # def content_length
+      #   return nil unless key?('Content-Length')
+      #   len = self['Content-Length'].slice(/\d+/) or
+      #   raise HTTPHeaderSyntaxError, 'wrong Content-Length format'
+      #   len.to_i
+      # end
+      #
+      # def content_length=(len)
+      #   unless len
+      #     headers.delete 'content-length'
+      #     return nil
+      #   end
+      #   headers['content-length'] = [len.to_i.to_s]
+      # end
+      #
+      # # Returns "true" if the "transfer-encoding" header is present and
+      # # set to "chunked".  This is an HTTP/1.1 feature, allowing the
+      # # the content to be sent in "chunks" without at the outset
+      # # stating the entire content length.
+      # def chunked?
+      #   return false unless headers['transfer-encoding']
+      #   field = self['Transfer-Encoding']
+      #   (/(?:\A|[^\-\w])chunked(?![\-\w])/i =~ field) ? true : false
+      # end
+      #
+      # # Returns a Range object which represents Content-Range: header field.
+      # # This indicates, for a partial entity body, where this fragment
+      # # fits inside the full entity body, as range of byte offsets.
+      # def content_range
+      #   return nil unless headers['content-range']
+      #   m = %r<bytes\s+(\d+)-(\d+)/(\d+|\*)>i.match(self['Content-Range']) or
+      #   raise HTTPHeaderSyntaxError, 'wrong Content-Range format'
+      #   m[1].to_i .. m[2].to_i + 1
+      # end
+      #
+      # # The length of the range represented in Content-Range: header.
+      # def range_length
+      #   r = content_range() or return nil
+      #   r.end - r.begin
+      # end
+      #
+      # # Returns a content type string such as "text/html".
+      # # This method returns nil if Content-Type: header field does not exist.
+      # def content_type
+      #   return nil unless main_type()
+      #   if sub_type()
+      #     "#{main_type()}/#{sub_type()}"
+      #   else
+      #     main_type()
+      #   end
+      # end
+      #
+      # # Returns a content type string such as "text".
+      # # This method returns nil if Content-Type: header field does not exist.
+      # def main_type
+      #   return nil unless headers['content-type']
+      #   self['Content-Type'].split(';').first.to_s.split('/')[0].to_s.strip
+      # end
+      #
+      # # Returns a content type string such as "html".
+      # # This method returns nil if Content-Type: header field does not exist
+      # # or sub-type is not given (e.g. "Content-Type: text").
+      # def sub_type
+      #   return nil unless headers['content-type']
+      #   main, sub = *self['Content-Type'].split(';').first.to_s.split('/')
+      #   return nil unless sub
+      #   sub.strip
+      # end
+      #
+      # # Returns content type parameters as a Hash as like
+      # # {"charset" => "iso-2022-jp"}.
+      # def type_params
+      #   result = {}
+      #   list = self['Content-Type'].to_s.split(';')
+      #   list.shift
+      #   list.each do |param|
+      #     k, v = *param.split('=', 2)
+      #     result[k.strip] = v.strip
+      #   end
+      #   result
+      # end
+      #
+      # # Set Content-Type: header field by +type+ and +params+.
+      # # +type+ must be a String, +params+ must be a Hash.
+      # def set_content_type(type, params = {})
+      #   headers['content-type'] = [type + params.map{|k,v|"; #{k}=#{v}"}.join('')]
+      # end
+      #
+      # alias content_type= set_content_type
+      #
+      # # Set header fields and a body from HTML form data.
+      # # +params+ should be a Hash containing HTML form data.
+      # # Optional argument +sep+ means data record separator.
+      # #
+      # # This method also set Content-Type: header field to
+      # # application/x-www-form-urlencoded.
+      # #
+      # # Example:
+      # #    http.form_data = {"q" => "ruby", "lang" => "en"}
+      # #    http.form_data = {"q" => ["ruby", "perl"], "lang" => "en"}
+      # #    http.set_form_data({"q" => "ruby", "lang" => "en"}, ';')
+      # #
+      # def set_form_data(params, sep = '&')
+      #   self.body = params.map {|k, v| encode_kvpair(k, v) }.flatten.join(sep)
+      #   self.content_type = 'application/x-www-form-urlencoded'
+      # end
+      #
+      # alias form_data= set_form_data
+      #
+      # def encode_kvpair(k, vs)
+      #   Array(vs).map {|v| "#{urlencode(k)}=#{urlencode(v.to_s)}" }
+      # end
+      # private :encode_kvpair
+      #
+      # def urlencode(str)
+      #   str.dup.force_encoding('ASCII-8BIT').gsub(/[^a-zA-Z0-9_\.\-]/){'%%%02x' % $&.ord}
+      # end
+      # private :urlencode
+      #
+      # # Set the Authorization: header for "Basic" authorization.
+      # def basic_auth(account, password)
+      #   headers['authorization'] = [basic_encode(account, password)]
+      # end
+      #
+      # # Set Proxy-Authorization: header for "Basic" authorization.
+      # def proxy_basic_auth(account, password)
+      #   headers['proxy-authorization'] = [basic_encode(account, password)]
+      # end
+      #
+      # def basic_encode(account, password)
+      #   'Basic ' + ["#{account}:#{password}"].pack('m').delete("\r\n")
+      # end
+      # private :basic_encode
+      #
+      # def connection_close?
+      #   tokens(headers['connection']).include?('close') or
+      #   tokens(headers['proxy-connection']).include?('close')
+      # end
+      #
+      # def connection_keep_alive?
+      #   tokens(headers['connection']).include?('keep-alive') or
+      #   tokens(headers['proxy-connection']).include?('keep-alive')
+      # end
+      #
+      # def tokens(vals)
+      #   return [] unless vals
+      #   vals.map {|v| v.split(',') }.flatten\
+      #   .reject {|str| str.strip.empty? }\
+      #   .map {|tok| tok.strip.downcase }
+      # end
+    end
+  end
+end

data/lib/wrest/http_shared/standard_headers.rb

@@ -0,0 +1,21 @@
+# Copyright 2009 Sidu Ponnappa
+
+# 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 Wrest #:nodoc:
+  module HttpShared #:nodoc:
+    module StandardHeaders
+      Connection = 'connection'
+      ContentType = 'content-type'
+      ContentLength = 'content-length'
+      IfNoneMatch = 'if-none-match'
+    end
+  end
+end
+
+

data/lib/wrest/http_shared/standard_tokens.rb

@@ -0,0 +1,18 @@
+# Copyright 2009 Sidu Ponnappa
+
+# 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 Wrest #:nodoc:
+  module HttpShared #:nodoc:
+    module StandardTokens
+      Close = 'close'
+      KeepAlive = 'keep-alive'
+      FormEncoded = 'application/x-www-form-urlencoded'
+    end
+  end
+end