rets-sarmiena 0.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+pkg/
+*.swp
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# rets Changelog
+
+### 0.0.1 / 2011-03-24
+
+* Project Created

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rets-sarmiena.gemspec
+gemspec

data/Manifest.txt

@@ -0,0 +1,23 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+bin/rets
+lib/rets.rb
+lib/rets/authentication.rb
+lib/rets/client.rb
+lib/rets/metadata.rb
+lib/rets/metadata/containers.rb
+lib/rets/metadata/lookup_type.rb
+lib/rets/metadata/resource.rb
+lib/rets/metadata/rets_class.rb
+lib/rets/metadata/root.rb
+lib/rets/metadata/table.rb
+lib/rets/parser/compact.rb
+lib/rets/parser/multipart.rb
+test/fixtures.rb
+test/helper.rb
+test/test_client.rb
+test/test_metadata.rb
+test/test_parser_compact.rb
+test/test_parser_multipart.rb

data/README.md

@@ -0,0 +1,42 @@
+# rets
+
+* http://github.com/estately/rets
+
+## DESCRIPTION:
+
+A pure-ruby library for fetching data from [RETS] servers.
+
+[RETS]: http://www.rets.org
+
+## REQUIREMENTS:
+
+* [net-http-persistent]
+* [nokogiri]
+
+[net-http-persistent]: http://seattlerb.rubyforge.org/net-http-persistent/
+[nokogiri]: http://nokogiri.org
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 Estately, Inc. <opensource@estately.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/rets

@@ -0,0 +1,194 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "pp"
+
+require "rubygems"
+require "rets"
+
+class RetsCli
+  def self.parse(args)
+
+    actions = %w(metadata search object)
+    options = {:count => 5}
+
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: #{File.basename($0)} URL [options] [query]"
+
+      opts.separator ""
+      opts.separator "Authentication options:"
+
+      opts.on("-U", "--username USERNAME", "The username to authenticate with.") do |username|
+        options[:username] = username
+      end
+
+      opts.on("-P", "--password [PASSWORD]", "The password to authenticate with.","Prompts if no argument is provided.") do |password|
+        options[:password] = password #or prompt # TODO
+      end
+
+      opts.on("-A", "--agent AGENT", "User-Agent header to provide.") do |agent|
+        options[:agent] = agent
+      end
+
+      opts.on("-B", "--agent-password [PASSWORD]", "User-Agent password to provide.") do |ua_password|
+        options[:ua_password] = ua_password
+      end
+
+      opts.separator ""
+      opts.separator "Actions:"
+
+      opts.on("-p", "--capabilities", "Print capabilities of the RETS server.") do |capabilities|
+        options[:capabilities] = capabilities
+      end
+
+      opts.on("-a", "--action ACTION", actions, "Action to perform (#{actions.join(",")}).") do |action|
+        options[:action] = action
+      end
+
+      opts.on("-m", "--metadata [FORMAT]", %w(tree long short), "Print metadata.", "Format is short, long or tree.", "Defaults to short.") do |format|
+        options[:action] = "metadata"
+        options[:metadata_format] = format || "short"
+      end
+
+      opts.separator ""
+      opts.separator "Search action options:"
+
+      opts.on("-r", "--resource NAME", "Name of resource to search for.") do |name|
+        options[:resource] = name
+      end
+
+      opts.on("-c", "--class NAME", "Name of class to search for.") do |name|
+        options[:class] = name
+      end
+
+      opts.on("-n", "--number LIMIT", Integer, "Return LIMIT results. Defaults to 5.") do |limit|
+        options[:limit] = limit
+      end
+
+      opts.separator ""
+      opts.separator "Misc options:"
+
+      opts.on_tail("-v", "--verbose", "Be verbose.") do |verbose|
+        logger = Class.new do
+          def method_missing(method, *a, &b)
+            puts a
+          end
+        end
+
+        options[:logger] = logger.new
+      end
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+
+      opts.on_tail("--version", "Show version") do
+        puts Rets::VERSION
+        exit
+      end
+
+    end
+
+    begin
+      opts.parse!(args.empty? ? ["-h"] : args)
+    rescue OptionParser::InvalidArgument => e
+      abort e.message
+    end
+
+    options
+  end
+
+end
+
+options = RetsCli.parse(ARGV)
+url     = ARGV[0] or abort "Need login URL"
+query   = ARGV[1]
+
+client = Rets::Client.new(options.merge(:login_url => url))
+
+COUNT = Struct.new(:exclude, :include, :only).new(0,1,2)
+
+if options[:capabilities]
+  pp client.capabilities
+end
+
+case options[:action]
+  when "metadata" then
+    metadata = client.metadata
+
+    if options[:metadata_format] != "tree"
+      preferred_fields = %w(ClassName SystemName ResourceID StandardName VisibleName MetadataEntryID KeyField)
+
+
+      # All types except system
+      types = Rets::METADATA_TYPES.map { |t| t.downcase.to_sym } - [:system]
+
+      types.each do |type|
+        # if RowContainer ...
+        rows = metadata[type]
+
+        puts type.to_s.capitalize
+        puts "="*40
+
+        print_key_value = lambda do |k,v|
+          key   = "#{k}:".ljust(35)
+          value = "#{v}".ljust(35)
+
+          puts [key, value].join
+        end
+
+        rows.each do |row|
+          top, rest = row.partition { |k,v| preferred_fields.include?(k) }
+
+          top.each(&print_key_value)
+
+          rest.sort_by{|k,v|k}.each(&print_key_value) if options[:metadata_format] == "long"
+
+          puts
+        end
+
+        puts
+      end
+
+    # Tree format
+    else
+      metadata.print_tree
+    end
+
+  when "search" then
+    pp client.find(:all,
+                  :search_type => options[:resource],
+                  :class       => options[:class],
+                  :query       => query,
+                  :count       => COUNT.exclude,
+                  :limit       => options[:limit])
+
+  when "object" then
+
+    def write_objects(parts)
+      parts.each do |part|
+        cid = part.headers["content-id"].to_i
+        oid = part.headers["object-id"].to_i
+
+        File.open("tmp/#{cid}-#{oid}", "wb") do |f|
+          puts f.path
+
+          f.write part.body
+        end
+      end
+    end
+
+    parts = client.all_objects(
+      :resource    => "Property",
+      :resource_id => 90020062739, # id from KeyField for a given property
+      :object_type => "Photo"
+    )
+
+    parts.each { |pt| p pt.headers }
+
+    write_objects(parts)
+
+end
+
+

data/lib/rets-sarmiena.rb

@@ -0,0 +1,2 @@
+require "rets-sarmiena/version"
+require "rets"

data/lib/rets-sarmiena/version.rb

@@ -0,0 +1,5 @@
+module Rets
+  module Sarmiena
+    VERSION = "0.1.0"
+  end
+end

data/lib/rets.rb

@@ -0,0 +1,24 @@
+require 'net/http'
+require 'uri'
+require 'cgi'
+require 'digest/md5'
+
+require 'rubygems'
+require 'net/http/persistent'
+require 'nokogiri'
+
+module Rets
+  VERSION = '0.0.1'
+
+  AuthorizationFailure = Class.new(ArgumentError)
+  InvalidRequest       = Class.new(ArgumentError)
+  MalformedResponse    = Class.new(ArgumentError)
+  UnknownResponse      = Class.new(ArgumentError)
+end
+
+require 'rets/authentication'
+require 'rets/metadata'
+require 'rets/parser/compact'
+require 'rets/parser/multipart'
+
+require 'rets/client'

data/lib/rets/authentication.rb

@@ -0,0 +1,59 @@
+module Rets
+  # Adapted from dbrain's Net::HTTP::DigestAuth gem, and RETS4R auth
+  # in order to support RETS' usage of digest authentication.
+  module Authentication
+    def build_auth(digest_authenticate, uri, nc = 0, method = "POST")
+      user     = CGI.unescape uri.user
+      password = CGI.unescape uri.password
+
+      digest_authenticate =~ /^(\w+) (.*)/
+
+      params = {}
+      $2.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+
+      cnonce = Digest::MD5.hexdigest "%x" % (Time.now.to_i + rand(65535))
+
+      digest = calculate_digest(
+        user, password, params['realm'], params['nonce'], method, uri.request_uri, params['qop'], cnonce, nc
+      )
+
+      header = [
+        %Q(Digest username="#{user}"),
+        %Q(realm="#{params['realm']}"),
+        %Q(qop="#{params['qop']}"),
+        %Q(uri="#{uri.request_uri}"),
+        %Q(nonce="#{params['nonce']}"),
+        %Q(nc=#{('%08x' % nc)}),
+        %Q(cnonce="#{cnonce}"),
+        %Q(response="#{digest}"),
+        %Q(opaque="#{params['opaque']}"),
+      ]
+
+      header.join(", ")
+    end
+
+    def calculate_digest(user, password, realm, nonce, method, uri, qop, cnonce, nc)
+      a1 = Digest::MD5.hexdigest "#{user}:#{realm}:#{password}"
+      a2 = Digest::MD5.hexdigest "#{method}:#{uri}"
+
+      if qop
+        Digest::MD5.hexdigest("#{a1}:#{nonce}:#{'%08x' % nc}:#{cnonce}:#{qop}:#{a2}")
+      else
+        Digest::MD5.hexdigest("#{a1}:#{nonce}:#{a2}")
+      end
+    end
+
+    def calculate_user_agent_digest(user_agent, user_agent_password, session_id, version)
+      product, _ = user_agent.split("/")
+
+      a1 = Digest::MD5.hexdigest "#{product}:#{user_agent_password}"
+
+      Digest::MD5.hexdigest "#{a1}::#{session_id}:#{version}"
+    end
+
+    def build_user_agent_auth(*args)
+      %Q(Digest "#{calculate_user_agent_digest(*args)}")
+    end
+
+  end
+end

data/lib/rets/client.rb

@@ -0,0 +1,483 @@
+module Rets
+  Session = Struct.new(:authorization, :capabilities, :cookies)
+
+  class Client
+    COUNT = Struct.new(:exclude, :include, :only).new(0,1,2)
+    DEFAULT_OPTIONS = { :persistent => true }
+
+    include Authentication
+
+    attr_accessor :uri, :options, :authorization, :logger
+    attr_writer   :capabilities, :metadata
+
+    def initialize(options)
+      @capabilities = nil
+      @cookies      = nil
+      @metadata     = Metadata::Root.new(self)
+
+      uri          = URI.parse(options[:login_url])
+
+      uri.user     = options.key?(:username) ? CGI.escape(options[:username]) : nil
+      uri.password = options.key?(:password) ? CGI.escape(options[:password]) : nil
+
+      self.options = DEFAULT_OPTIONS.merge(options)
+      self.uri     = uri
+
+      self.logger = options[:logger] || FakeLogger.new
+
+      self.session  = options[:session]  if options[:session]
+      @cached_metadata = options[:metadata] || nil
+    end
+
+
+    # Attempts to login by making an empty request to the URL
+    # provided in initialize. Returns the capabilities that the
+    # RETS server provides, per http://retsdoc.onconfluence.com/display/rets172/4.10+Capability+URL+List.
+    def login
+      request(uri.path)
+      capabilities
+    end
+
+    # Finds records.
+    #
+    # [quantity]  Return the first record, or an array of records.
+    #             Uses a symbol <tt>:first</tt> or <tt>:all</tt>, respectively.
+    #
+    # [opts]  A hash of arguments used to construct the search query,
+    #         using the following keys:
+    #
+    # <tt>:search_type</tt>::  Required. The resource to search for.
+    # <tt>:class</tt>::        Required. The class of the resource to search for.
+    # <tt>:query</tt>::        Required. The DMQL2 query string to execute.
+    # <tt>:limit</tt>::        The number of records to request from the server.
+    # <tt>:resolve</tt>::      Provide resolved values that use metadata instead
+    #                          of raw system values.
+    #
+    # Any other keys are converted to the RETS query format, and passed
+    # to the server as part of the query. For instance, the key <tt>:offset</tt>
+    # will be sent as +Offset+.
+    #
+    def find(quantity, opts = {})
+      case quantity
+        when :first  then find_every(opts.merge(:limit => 1)).first
+        when :all    then find_every(opts)
+        else raise ArgumentError, "First argument must be :first or :all"
+      end
+    end
+
+    def count(opts = {})
+      response = find_every(opts.merge(:count => COUNT.only))
+      Parser::Compact.parse_count response.body
+    end
+
+    alias search find
+
+    def find_every(opts = {})
+      search_uri = capability_url("Search")
+
+      resolve = opts.delete(:resolve)
+
+      extras = fixup_keys(opts)
+
+      defaults = {"QueryType" => "DMQL2", "Format" => "COMPACT"}
+
+      query = defaults.merge(extras)
+
+      body = build_key_values(query)
+
+      headers = build_headers.merge(
+        "Content-Type"   => "application/x-www-form-urlencoded",
+        "Content-Length" => body.size.to_s
+      )
+
+      results = if opts[:count] == COUNT.only
+        request(search_uri.path, body, headers)
+      else
+        request_with_compact_response(search_uri.path, body, headers)
+      end
+
+      if resolve
+        rets_class = find_rets_class(opts[:search_type], opts[:class])
+        decorate_results(results, rets_class)
+      else
+        results
+      end
+    end
+
+    def find_rets_class(resource_name, rets_class_name)
+      metadata.build_tree[resource_name].find_rets_class(rets_class_name)
+    end
+
+    def decorate_results(results, rets_class)
+      results.map do |result|
+        decorate_result(result, rets_class)
+      end
+    end
+
+    def decorate_result(result, rets_class)
+      result.each do |key, value|
+        result[key] = rets_class.find_table(key).resolve(value.to_s)
+      end
+    end
+
+
+    # Returns an array of all objects associated with the given resource.
+    def all_objects(opts = {})
+      objects("*", opts)
+    end
+
+    # Returns an array of specified objects.
+    def objects(object_ids, opts = {})
+      response = case object_ids
+        when String then fetch_object(object_ids, opts)
+        when Array  then fetch_object(object_ids.join(","), opts)
+        else raise ArgumentError, "Expected instance of String or Array, but got #{object_ids.inspect}."
+      end
+
+      create_parts_from_response(response)
+    end
+
+    def create_parts_from_response(response)
+      content_type = response["content-type"]
+
+      if content_type.include?("multipart")
+        boundary = content_type.scan(/boundary="(.*?)"/).to_s
+
+        parts = Parser::Multipart.parse(response.body, boundary)
+
+        logger.debug "Found #{parts.size} parts"
+
+        return parts
+      else
+        # fake a multipart for interface compatibility
+        headers = {}
+        response.each { |k,v| headers[k] = v }
+
+        part = Parser::Multipart::Part.new(headers, response.body)
+
+        return [part]
+      end
+    end
+
+    # Returns a single object.
+    #
+    # resource     RETS resource as defined in the resource metadata.
+    # object_type  an object type defined in the object metadata.
+    # resource_id  the KeyField value of the given resource instance.
+    # object_id    can be "*", or a comma delimited string of one or more integers.
+    def object(object_id, opts = {})
+      response = fetch_object(object_id, opts)
+
+      response.body
+    end
+
+    def fetch_object(object_id, opts = {})
+      object_uri = capability_url("GetObject")
+
+      body = build_key_values(
+        "Resource" => opts[:resource],
+        "Type"     => opts[:object_type],
+        "ID"       => "#{opts[:resource_id]}:#{object_id}",
+        "Location" => 0
+      )
+
+      headers = build_headers.merge(
+        "Accept"         => "image/jpeg, image/png;q=0.5, image/gif;q=0.1",
+        "Content-Type"   => "application/x-www-form-urlencoded",
+        "Content-Length" => body.size.to_s
+      )
+
+      request(object_uri.path, body, headers)
+    end
+
+    # Changes keys to be camel cased, per the RETS standard for queries.
+    def fixup_keys(hash)
+      fixed_hash = {}
+
+      hash.each do |key, value|
+        camel_cased_key = key.to_s.capitalize.gsub(/_(\w)/) { $1.upcase }
+
+        fixed_hash[camel_cased_key] = value
+      end
+
+      fixed_hash
+    end
+
+    def metadata
+      if @cached_metadata && @cached_metadata.current?(capabilities["MetadataTimestamp"], capabilities["MetadataVersion"])
+        self.metadata = @cached_metadata
+      end
+      @metadata
+    end
+
+    def metadata_for(type)
+        @metadata.for(type)
+    end
+
+    def retrieve_metadata_type(type)
+      metadata_uri = capability_url("GetMetadata")
+
+      body = build_key_values(
+        "Format" => "COMPACT",
+        "Type"   => "METADATA-#{type}",
+        "ID"     => "0"
+      )
+
+      headers = build_headers.merge(
+        "Content-Type"   => "application/x-www-form-urlencoded",
+        "Content-Length" => body.size.to_s
+      )
+
+      response = request(metadata_uri.path, body, headers)
+
+      response.body
+    end
+
+    def raw_request(path, body = nil, headers = build_headers, &reader)
+      logger.info "posting to #{path}"
+
+      post = Net::HTTP::Post.new(path, headers)
+      post.body = body.to_s
+
+      logger.debug ""
+      logger.debug format_headers(headers)
+      logger.debug body.to_s
+
+      connection_args = [Net::HTTP::Persistent === connection ? uri : nil, post].compact
+
+      response = connection.request(*connection_args) do |res|
+        res.read_body(&reader)
+      end
+
+      handle_cookies(response)
+
+      logger.debug "Response: (#{response.class})"
+      logger.debug ""
+      logger.debug format_headers(response.to_hash)
+      logger.debug ""
+      logger.debug "Body:"
+      logger.debug response.body
+
+      return response
+    end
+
+    def request(*args, &block)
+      handle_response(raw_request(*args, &block))
+    end
+
+    def request_with_compact_response(path, body, headers)
+      response = request(path, body, headers)
+
+      Parser::Compact.parse_document response.body
+    end
+
+    def extract_digest_header(response)
+      authenticate_headers = response.get_fields("www-authenticate")
+      authenticate_headers.detect {|h| h =~ /Digest/}
+    end
+
+    def handle_unauthorized_response(response)
+      self.authorization = build_auth(extract_digest_header(response), uri, tries)
+
+      response = raw_request(uri.path)
+
+      if Net::HTTPUnauthorized === response
+        raise AuthorizationFailure, "Authorization failed, check credentials?"
+      else
+        self.capabilities = extract_capabilities(Nokogiri.parse(response.body))
+      end
+    end
+
+    def handle_response(response)
+
+      if Net::HTTPUnauthorized === response # 401
+        handle_unauthorized_response(response)
+
+      elsif Net::HTTPSuccess === response # 2xx
+        begin
+          if !response.body.empty?
+            xml = Nokogiri::XML.parse(response.body, nil, nil, Nokogiri::XML::ParseOptions::STRICT)
+
+            reply_text = xml.xpath("/RETS").attr("ReplyText").value
+            reply_code = xml.xpath("/RETS").attr("ReplyCode").value.to_i
+
+            if reply_code.nonzero?
+              raise InvalidRequest, "Got error code #{reply_code} (#{reply_text})."
+            end
+          end
+
+        rescue Nokogiri::XML::SyntaxError => e
+          logger.debug "Not xml"
+
+        end
+
+      else
+        raise UnknownResponse, "Unable to handle response #{response.class}"
+      end
+
+      return response
+    end
+
+
+    def handle_cookies(response)
+      if cookies?(response)
+        self.cookies = response.get_fields('set-cookie')
+        logger.info "Cookies set to #{cookies.inspect}"
+      end
+    end
+
+    def cookies?(response)
+      response['set-cookie']
+    end
+
+    def cookies=(cookies)
+      @cookies ||= {}
+
+      cookies.each do |cookie|
+        cookie.match(/(\S+)=([^;]+);?/)
+
+        @cookies[$1] = $2
+      end
+
+      nil
+    end
+
+    def cookies
+      return if @cookies.nil? or @cookies.empty?
+
+      @cookies.map{ |k,v| "#{k}=#{v}" }.join("; ")
+    end
+
+
+    def session=(session)
+      self.authorization = session.authorization
+      self.capabilities  = session.capabilities
+      self.cookies       = session.cookies
+    end
+
+    def session
+      Session.new(authorization, capabilities, cookies)
+    end
+
+
+    # The capabilies as provided by the RETS server during login.
+    #
+    # Currently, only the path in the endpoint URLs is used[1]. Host,
+    # port, other details remaining constant with those provided to
+    # the constructor.
+    #
+    # [1] In fact, sometimes only a path is returned from the server.
+    def capabilities
+      @capabilities || login
+    end
+
+    def capability_url(name)
+      url = capabilities[name]
+
+      begin
+        capability_uri = URI.parse(url)
+      rescue URI::InvalidURIError => e
+        raise MalformedResponse, "Unable to parse capability URL: #{url.inspect}"
+      end
+
+      capability_uri
+    end
+
+    def extract_capabilities(document)
+      raw_key_values = document.xpath("/RETS/RETS-RESPONSE").text.strip
+
+      h = Hash.new{|h,k| h.key?(k.downcase) ? h[k.downcase] : nil }
+
+      # ... :(
+      # Feel free to make this better. It has a test.
+      raw_key_values.split(/\n/).
+        map  { |r| r.split(/=/, 2) }.
+        each { |k,v| h[k.strip.downcase] = v }
+
+      h
+    end
+
+
+
+    def connection
+      @connection ||= options[:persistent] ?
+        persistent_connection :
+        Net::HTTP.new(uri.host, uri.port)
+    end
+
+    def persistent_connection
+      conn = Net::HTTP::Persistent.new
+
+      def conn.idempotent?(*)
+	true
+      end
+
+      conn
+    end
+
+
+    def user_agent
+      options[:agent] || "Client/1.0"
+    end
+
+    def rets_version
+      options[:version] || "RETS/1.7.2"
+    end
+
+    def build_headers
+      headers = {
+        "User-Agent"   => user_agent,
+        "Host"         => "#{uri.host}:#{uri.port}",
+        "RETS-Version" => rets_version
+      }
+
+      headers.merge!("Authorization" => authorization) if authorization
+      headers.merge!("Cookie" => cookies)              if cookies
+
+      if options[:ua_password]
+        headers.merge!(
+          "RETS-UA-Authorization" => build_user_agent_auth(
+            user_agent, options[:ua_password], "", rets_version))
+      end
+
+      headers
+    end
+
+    def build_key_values(data)
+      data.map{|k,v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join("&")
+    end
+
+
+
+    def tries
+      @tries ||= 1
+
+      (@tries += 1) - 1
+    end
+
+    class FakeLogger
+      def fatal(*); end
+      def error(*); end
+      def warn(*);  end
+      def info(*);  end
+      def debug(*); end
+    end
+
+    def format_headers(headers)
+      out = []
+
+      headers.each do |name, value|
+        if Array === value
+          value.each do |v|
+            out << "#{name}: #{v}"
+          end
+        else
+          out << "#{name}: #{value}"
+        end
+      end
+
+      out.join("\n")
+    end
+
+  end
+end