hurley 0.1

data/lib/hurley/connection.rb

@@ -0,0 +1,123 @@
+begin
+  require "net/https"
+rescue LoadError
+  warn "Warning: no such file to load -- net/https. Make sure openssl is installed if you want ssl support"
+  require "net/http"
+end
+require "zlib"
+
+module Hurley
+  class Connection
+    def call(request)
+      net_http_connection(request) do |http|
+        begin
+          Response.new(request) do |res|
+            http_res = perform_request(http, request, res)
+            res.status_code = http_res.code.to_i
+            http_res.each_header do |key, value|
+              res.header[key] = value
+            end
+
+            # net/http only raises exception on 407 with ssl...?
+            if res.status_code == 407
+              raise ConnectionFailed, %(407 "Proxy Authentication Required")
+            end
+          end
+        rescue *NET_HTTP_EXCEPTIONS => err
+          if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
+            raise SSLError, err
+          else
+            raise ConnectionFailed, err
+          end
+        end
+      end
+
+    rescue ::Timeout::Error => err
+      raise Timeout, err
+    end
+
+    private
+
+    def net_http_connection(request)
+      http = if proxy = request.options.proxy
+        Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password)
+      else
+        Net::HTTP
+      end.new(request.url.host, request.url.port)
+
+      configure_ssl(http, request) if request.url.scheme == Hurley::HTTPS
+
+      if t = request.options.timeout
+        http.read_timeout = http.open_timeout = t
+      end
+
+      if t = request.options.open_timeout
+        http.open_timeout = t
+      end
+
+      yield http
+    end
+
+    def net_http_request(request)
+      http_req = Net::HTTPGenericRequest.new(
+        request.verb.to_s.upcase, # request method
+        !!request.body,           # is there a request body
+        :head != request.verb,    # is there a response body
+        request.url.request_uri,  # request uri path
+        request.header,           # request headers
+      )
+
+      if body = request.body_io
+        http_req.body_stream = body
+      end
+
+      http_req
+    end
+
+    def perform_request(http, request, res)
+      if :get == request.verb
+        # prefer `get` to `request` because the former handles gzip (ruby 1.9)
+        http_res = http.get(request.url.request_uri, request.header.to_hash) do |chunk|
+          res.receive_body(chunk)
+        end
+        http_res
+      else
+        http_res = http.request(net_http_request(request))
+        res.receive_body(http_res.body)
+        http_res
+      end
+    end
+
+    def configure_ssl(http, request)
+      ssl = request.ssl_options
+      http.use_ssl = true
+      http.verify_mode = ssl.openssl_verify_mode
+      http.cert_store = ssl.openssl_cert_store
+
+      http.cert = ssl.openssl_client_cert if ssl.openssl_client_cert
+      http.key = ssl.openssl_client_key if ssl.openssl_client_key
+      http.ca_file = ssl.ca_file if ssl.ca_file
+      http.ca_path = ssl.ca_path if ssl.ca_path
+      http.verify_depth = ssl.verify_depth if ssl.verify_depth
+      http.ssl_version = ssl.version if ssl.version
+    end
+
+    NET_HTTP_EXCEPTIONS = [
+      EOFError,
+      Errno::ECONNABORTED,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::EHOSTUNREACH,
+      Errno::EINVAL,
+      Errno::ENETUNREACH,
+      Net::HTTPBadResponse,
+      Net::HTTPHeaderSyntaxError,
+      Net::ProtocolError,
+      SocketError,
+      Zlib::GzipFile::Error,
+    ]
+
+    NET_HTTP_EXCEPTIONS << OpenSSL::SSL::SSLError if defined?(OpenSSL)
+    NET_HTTP_EXCEPTIONS << Net::OpenTimeout if defined?(Net::OpenTimeout)
+  end
+end

data/lib/hurley/header.rb

@@ -0,0 +1,144 @@
+require "forwardable"
+
+module Hurley
+  class Header
+    def initialize(initial = nil)
+      @hash = {}
+      update(initial) if initial
+    end
+
+    extend Forwardable
+    def_delegators(:@hash,
+      :each,
+      :keys,
+      :size,
+    )
+
+    def [](key)
+      @hash[self.class.canonical(key)]
+    end
+
+    def []=(key, value)
+      @hash[self.class.canonical(key)] = value.to_s
+    end
+
+    def key?(key)
+      @hash.key?(self.class.canonical(key))
+    end
+
+    def delete(key)
+      @hash.delete(self.class.canonical(key))
+    end
+
+    def update(hash)
+      hash.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    def dup
+      self.class.new(@hash.dup)
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def inspect
+      "#<%s %s>" % [
+        self.class.name,
+        @hash.inspect,
+      ]
+    end
+
+    def self.canonical(input)
+      KEYS[input] || begin
+        key = input.to_s.tr(UNDERSCORE, DASH)
+        key.downcase!
+        key.gsub!(/(\A|\-)(\S)/) { |s| s.upcase! ; s }
+        key
+      end
+    end
+
+    def self.add_canonical_key(*canonicals)
+      canonicals.each do |canonical|
+        canonical.freeze
+        KEYS[canonical] = canonical
+        shortcut = canonical.downcase
+        KEYS[shortcut.freeze] = canonical
+        KEYS[shortcut.tr(DASH, UNDERSCORE).to_sym] = canonical
+      end
+    end
+
+    private
+
+    # hash of "shortcut key" => "canonical header key"
+    # string keys are converted to canonical header names:
+    #
+    # KEYS["content_type"] # => "Content-Type"
+    #
+    KEYS = {"ETag".freeze => "Etag".freeze}
+    DASH = "-".freeze
+    UNDERSCORE = "_".freeze
+
+    # Adds canonical header keys for common headers.
+    #
+    # KEYS[:content_type]  # => "Content-Type"
+    # KEYS["Content-Type"] # => "Content-Type"
+    # KEYS["content-type"] # => "Content-Type"
+    #
+    add_canonical_key(
+      "Accept",
+      "Access-Control-Allow-Credentials",
+      "Access-Control-Allow-Origin",
+      "Access-Control-Expose-Headers",
+      "Age",
+      "Authorization",
+      "Cache-Control",
+      "Connection",
+      "Content-Disposition",
+      "Content-Language",
+      "Content-Length",
+      "Content-MD5",
+      "Content-Range",
+      "Content-Security-Policy",
+      "Content-Type",
+      "Cookie",
+      "Date",
+      "Etag",
+      "Expect",
+      "Expires",
+      "From",
+      "Host",
+      "If-Modified-Since",
+      "If-None-Match",
+      "Last-Modified",
+      "Link",
+      "Location",
+      "Origin",
+      "Range",
+      "Referer",
+      "Refresh",
+      "Retry-After",
+      "Server",
+      "Set-Cookie",
+      "Status",
+      "String-Transport-Security",
+      "Trailer",
+      "Transfer-Encoding",
+      "User-Agent",
+      "Upgrade",
+      "Vary",
+      "Via",
+      "WWW-Authenticate",
+      "X-Content-Type-Options",
+      "X-Frame-Options",
+      "X-Powered-By",
+      "X-Served-By",
+      "X-Xss-Protection",
+    )
+
+    # Some weird exceptions
+    KEYS["ETag"] = "Etag"
+  end
+end

data/lib/hurley/multipart.rb

@@ -0,0 +1,235 @@
+# Taken from multipart-post gem: https://github.com/nicksieger/multipart-post
+# Removes coupling with net/http
+
+module Hurley
+  # Convenience methods for dealing with files and IO that are to be uploaded.
+  class UploadIO
+    # Create an upload IO suitable for including in the body hash of a
+    # Hurley::Request.
+    #
+    # Can take two forms. The first accepts a filename and content type, and
+    # opens the file for reading (to be closed by finalizer).
+    #
+    # The second accepts an already-open IO, but also requires a third argument,
+    # the filename from which it was opened (particularly useful/recommended if
+    # uploading directly from a form in a framework, which often save the file to
+    # an arbitrarily named RackMultipart file in /tmp).
+    #
+    # Usage:
+    #
+    #     UploadIO.new("file.txt", "text/plain")
+    #     UploadIO.new(file_io, "text/plain", "file.txt")
+    #
+    attr_reader :content_type, :original_filename, :local_path, :io, :opts
+
+    def initialize(filename_or_io, content_type, filename = nil, opts = {})
+      io = filename_or_io
+      local_path = nil
+      if io.respond_to?(:read)
+        # in Ruby 1.9.2, StringIOs no longer respond to path
+        # (since they respond to :length, so we don't need their local path, see parts.rb:41)
+        local_path = filename_or_io.respond_to?(:path) ? filename_or_io.path : DEFAULT_LOCAL_PATH
+      else
+        io = File.open(filename_or_io)
+        local_path = filename_or_io
+      end
+
+      filename ||= local_path
+
+      @content_type = content_type
+      @original_filename = File.basename(filename)
+      @local_path = local_path
+      @io = io
+      @opts = opts
+    end
+
+    def method_missing(*args)
+      @io.send(*args)
+    end
+
+    def respond_to?(meth, include_all = false)
+      @io.respond_to?(meth, include_all) || super(meth, include_all)
+    end
+
+    DEFAULT_LOCAL_PATH = "local.path".freeze
+  end
+
+  # Internal helper classes for generating multipart bodies.
+  module Multipart
+    module Part #:nodoc:
+      def self.new(boundary, name, value, header = nil)
+        header ||= {}
+        if file?(value)
+          FilePart.new(boundary, name, value, header)
+        else
+          ParamPart.new(boundary, name, value, header)
+        end
+      end
+
+      def self.file?(value)
+        value.respond_to?(:content_type) && value.respond_to?(:original_filename)
+      end
+
+      def to_io
+        @io
+      end
+    end
+
+    class ParamPart
+      include Part
+
+      def initialize(boundary, name, value, header)
+        @part = build_part(boundary, name, value, header)
+        @io = StringIO.new(@part)
+      end
+
+      def length
+        @part.bytesize
+      end
+
+      private
+
+      def build_part(boundary, name, value, header)
+        ctype = if type = header[:content_type]
+          CTYPE_FORMAT % type
+        end
+
+        PART_FORMAT % [
+          boundary,
+          name.to_s,
+          ctype,
+          value.to_s,
+        ]
+      end
+
+      CTYPE_FORMAT = "Content-Type: %s\r\n"
+      PART_FORMAT = <<-END
+--%s\r
+Content-Disposition: form-data; name="%s"\r
+%s\r
+%s\r
+END
+    end
+
+    # Represents a part to be filled from file IO.
+    class FilePart
+      include Part
+
+      attr_reader :length
+
+      def initialize(boundary, name, io, header)
+        file_length = io.respond_to?(:length) ?  io.length : File.size(io.local_path)
+
+        @head = build_head(boundary, name, io.original_filename, io.content_type, file_length,
+                           io.respond_to?(:opts) ? io.opts.merge(header) : header)
+
+        @length = @head.bytesize + file_length + FOOT.length
+        @io = CompositeReadIO.new(@length, StringIO.new(@head), io, StringIO.new(FOOT))
+      end
+
+      private
+
+      def build_head(boundary, name, filename, type, content_len, header)
+        content_id = if cid = header[:content_id]
+          CID_FORMAT % cid
+        end
+
+
+        HEAD_FORMAT % [
+          boundary,
+          header[:content_disposition] || DEFAULT_DISPOSITION,
+          name.to_s,
+          filename.to_s,
+          content_len.to_i,
+          content_id,
+          header[:content_type] || type,
+          header[:content_transfer_encoding] || DEFAULT_TR_ENCODING,
+        ]
+      end
+
+      DEFAULT_TR_ENCODING = "binary".freeze
+      DEFAULT_DISPOSITION = "form-data".freeze
+      FOOT = "\r\n".freeze
+      CID_FORMAT = "Content-ID: %s\r\n"
+      HEAD_FORMAT = <<-END
+--%s\r
+Content-Disposition: %s; name="%s"; filename="%s"\r
+Content-Length: %d\r
+%sContent-Type: %s\r
+Content-Transfer-Encoding: %s\r
+\r
+END
+    end
+
+    # Represents the epilogue or closing boundary.
+    class EpiloguePart
+      include Part
+
+      attr_reader :length
+
+      def initialize(boundary)
+        @part = "--#{boundary}--\r\n\r\n"
+        @io = StringIO.new(@part)
+        @length = @part.bytesize
+      end
+    end
+  end
+
+  # Concatenate together multiple IO objects into a single, composite IO object
+  # for purposes of reading as a single stream.
+  #
+  # Usage:
+  #
+  #     crio = CompositeReadIO.new(StringIO.new('one'), StringIO.new('two'), StringIO.new('three'))
+  #     puts crio.read # => "onetwothree"
+  class CompositeReadIO
+    attr_reader :length
+
+    def initialize(length = nil, *ios)
+      @ios = ios.flatten
+
+      if length.respond_to?(:read)
+        @ios.unshift(length)
+      else
+        @length = length || -1
+      end
+
+      @index = 0
+    end
+
+    def read(length = nil, outbuf = nil)
+      got_result = false
+      outbuf = outbuf ? outbuf.replace("") : ""
+
+      while io = current_io
+        if result = io.read(length)
+          got_result ||= !result.nil?
+          result.force_encoding(BINARY) if result.respond_to?(:force_encoding)
+          outbuf << result
+          length -= result.length if length
+          break if length == 0
+        end
+        advance_io
+      end
+
+      (!got_result && length) ? nil : outbuf
+    end
+
+    def rewind
+      @ios.each { |io| io.rewind }
+      @index = 0
+    end
+
+    private
+
+    def current_io
+      @ios[@index]
+    end
+
+    def advance_io
+      @index += 1
+    end
+
+    BINARY = "BINARY".freeze
+  end
+end