http 0.5.1 → 0.6.0.pre

data/lib/http/content_type.rb

@@ -0,0 +1,27 @@
+module HTTP
+  ContentType = Struct.new(:mime_type, :charset) do
+    MIME_TYPE_RE = %r{^([^/]+/[^;]+)(?:$|;)}
+    CHARSET_RE   = /;\s*charset=([^;]+)/i
+
+    class << self
+      # Parse string and return ContentType struct
+      def parse(str)
+        new mime_type(str), charset(str)
+      end
+
+    private
+
+      # :nodoc:
+      def mime_type(str)
+        md = str.to_s.match MIME_TYPE_RE
+        md && md[1].to_s.strip.downcase
+      end
+
+      # :nodoc:
+      def charset(str)
+        md = str.to_s.match CHARSET_RE
+        md && md[1].to_s.strip.gsub(/^"|"$/, '')
+      end
+    end
+  end
+end

data/lib/http/errors.rb

@@ -0,0 +1,13 @@
+module HTTP
+  # Generic error
+  class Error < StandardError; end
+
+  # Generic Request error
+  class RequestError < Error; end
+
+  # Generic Response error
+  class ResponseError < Error; end
+
+  # Request to do something when we're in the wrong state
+  class StateError < ResponseError; end
+end

data/lib/http/headers.rb

@@ -0,0 +1,154 @@
+require 'forwardable'
+
+require 'http/headers/mixin'
+
+module HTTP
+  class Headers
+    extend Forwardable
+    include Enumerable
+
+    # Matches HTTP header names when in "Canonical-Http-Format"
+    CANONICAL_HEADER = /^[A-Z][a-z]*(-[A-Z][a-z]*)*$/
+
+    # :nodoc:
+    def initialize
+      @pile = []
+    end
+
+    # Sets header
+    #
+    # @return [void]
+    def set(name, value)
+      delete(name)
+      add(name, value)
+    end
+    alias_method :[]=, :set
+
+    # Removes header
+    #
+    # @return [void]
+    def delete(name)
+      name = canonicalize_header name.to_s
+      @pile.delete_if { |k, _| k == name }
+    end
+
+    # Append header
+    #
+    # @return [void]
+    def add(name, value)
+      name = canonicalize_header name.to_s
+      Array(value).each { |v| @pile << [name, v] }
+    end
+    alias_method :append, :add
+
+    # Return array of header values if any.
+    #
+    # @return [Array]
+    def get(name)
+      name = canonicalize_header name.to_s
+      @pile.select { |k, _| k == name }.map { |_, v| v }
+    end
+
+    # Smart version of {#get}
+    #
+    # @return [NilClass] if header was not set
+    # @return [Object] if header has exactly one value
+    # @return [Array<Object>] if header has more than one value
+    def [](name)
+      values = get(name)
+
+      case values.count
+      when 0 then nil
+      when 1 then values.first
+      else        values
+      end
+    end
+
+    # Converts headers into a Rack-compatible Hash
+    #
+    # @return [Hash]
+    def to_h
+      Hash[keys.map { |k| [k, self[k]] }]
+    end
+
+    # Array of key/value pairs
+    #
+    # @return [Array<[String, String]>]
+    def to_a
+      @pile.map { |pair| pair.map(&:dup) }
+    end
+
+    # :nodoc:
+    def inspect
+      "#<#{self.class} #{to_h.inspect}>"
+    end
+
+    # List of header names
+    #
+    # @return [Array<String>]
+    def keys
+      @pile.map { |k, _| k }.uniq
+    end
+
+    # Compares headers to another Headers or Array of key/value pairs
+    #
+    # @return [Boolean]
+    def ==(other)
+      return false unless other.respond_to? :to_a
+      @pile == other.to_a
+    end
+
+    def_delegators :@pile, :each, :empty?, :hash
+
+    # :nodoc:
+    def initialize_copy(orig)
+      super
+      @pile = to_a
+    end
+
+    # Merge in `other` headers
+    #
+    # @see #merge
+    # @return [void]
+    def merge!(other)
+      self.class.coerce(other).to_h.each { |name, values| set name, values }
+    end
+
+    # Returns new Headers instance with `other` headers merged in.
+    #
+    # @see #merge!
+    # @return [Headers]
+    def merge(other)
+      dup.tap { |dupped| dupped.merge! other }
+    end
+
+    # Initiates new Headers object from given object.
+    #
+    # @raise [Error] if given object can't be coerced
+    # @param [#to_hash, #to_h, #to_a] object
+    # @return [Headers]
+    def self.coerce(object)
+      unless object.is_a? self
+        object = case
+                when object.respond_to?(:to_hash) then object.to_hash
+                when object.respond_to?(:to_h)    then object.to_h
+                when object.respond_to?(:to_a)    then object.to_a
+                else fail Error, "Can't coerce #{object.inspect} to Headers"
+                end
+      end
+
+      headers = new
+      object.each { |k, v| headers.add k, v }
+      headers
+    end
+
+  private
+
+    # Transform to canonical HTTP header capitalization
+    # @param [String] name
+    # @return [String]
+    def canonicalize_header(name)
+      name[CANONICAL_HEADER] || name.split(/[\-_]/).map(&:capitalize).join('-')
+    end
+  end
+end

data/lib/http/headers/mixin.rb

@@ -0,0 +1,11 @@
+require 'forwardable'
+
+module HTTP
+  class Headers
+    module Mixin
+      extend Forwardable
+      attr_reader :headers
+      def_delegators :headers, :[], :[]=
+    end
+  end
+end

data/lib/http/mime_type.rb

@@ -1,51 +1,76 @@
 module HTTP
-  # Yes, HTTP bundles its own MIME type library. Maybe it should be spun off
-  # as a separate gem or something.
-  class MimeType
-    @mime_types, @shortcuts = {}, {}
-
+  # MIME type encode/decode adapters
+  module MimeType
     class << self
-      def register(obj)
-        @mime_types[obj.type] = obj
-        @shortcuts[obj.shortcut] = obj if obj.shortcut
+      # Associate MIME type with adapter
+      #
+      # @example
+      #
+      #   module JsonAdapter
+      #     class << self
+      #       def encode(obj)
+      #         # encode logic here
+      #       end
+      #
+      #       def decode(str)
+      #         # decode logic here
+      #       end
+      #     end
+      #   end
+      #
+      #   HTTP::MimeType.register_adapter 'application/json', MyJsonAdapter
+      #
+      # @param [#to_s] type
+      # @param [#encode, #decode] adapter
+      # @return [void]
+      def register_adapter(type, adapter)
+        adapters[type.to_s] = adapter
       end
 
+      # Returns adapter associated with MIME type
+      #
+      # @param [#to_s] type
+      # @raise [Error] if no adapter found
+      # @return [void]
       def [](type)
-        if type.is_a? Symbol
-          @shortcuts[type]
-        else
-          @mime_types[type]
-        end
+        adapters[normalize type] || fail(Error, "Unknown MIME type: #{type}")
       end
-    end
-
-    attr_reader :type, :shortcut
 
-    def initialize(type, shortcut = nil)
-      @type, @shortcut = type, shortcut
-      @parse_with = @emit_with = nil
-
-      self.class.register self
-    end
+      # Register a shortcut for MIME type
+      #
+      # @example
+      #
+      #   HTTP::MimeType.register_alias 'application/json', :json
+      #
+      # @param [#to_s] type
+      # @param [#to_sym] shortcut
+      # @return [void]
+      def register_alias(type, shortcut)
+        aliases[shortcut.to_sym] = type.to_s
+      end
 
-    # Define
-    def parse_with(&block)
-      @parse_with = block
-    end
+      # Resolves type by shortcut if possible
+      #
+      # @param [#to_s] type
+      # @return [String]
+      def normalize(type)
+        aliases.fetch type, type.to_s
+      end
 
-    def emit_with(&block)
-      @emit_with = block
-    end
+    private
 
-    def parse(obj)
-      @parse_with ? @parse_with[obj] : obj
-    end
+      # :nodoc:
+      def adapters
+        @adapters ||= {}
+      end
 
-    def emit(obj)
-      @emit_with  ? @emit_with[obj]  : obj
+      # :nodoc:
+      def aliases
+        @aliases ||= {}
+      end
     end
   end
 end
 
-# MIME type registry
-require 'http/mime_types/json'
+# built-in mime types
+require 'http/mime_type/json'

data/lib/http/mime_type/adapter.rb

@@ -0,0 +1,24 @@
+require 'forwardable'
+require 'singleton'
+
+module HTTP
+  module MimeType
+    # Base encode/decode MIME type adapter
+    class Adapter
+      include Singleton
+
+      class << self
+        extend Forwardable
+        def_delegators :instance, :encode, :decode
+      end
+
+      %w[encode decode].each do |operation|
+        class_eval <<-RUBY, __FILE__, __LINE__
+          def #{operation}(*)
+            fail Error, "\#{self.class} does not supports ##{operation}"
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/http/mime_type/json.rb

@@ -0,0 +1,23 @@
+require 'json'
+require 'http/mime_type/adapter'
+
+module HTTP
+  module MimeType
+    # JSON encode/decode MIME type adapter
+    class JSON < Adapter
+      # Encodes object to JSON
+      def encode(obj)
+        return obj.to_json if obj.respond_to?(:to_json)
+        ::JSON.dump obj
+      end
+
+      # Decodes JSON
+      def decode(str)
+        ::JSON.load str
+      end
+    end
+
+    register_adapter 'application/json', JSON
+    register_alias   'application/json', :json
+  end
+end

data/lib/http/options.rb

@@ -1,10 +1,9 @@
-require 'http/version'
+require 'http/headers'
 require 'openssl'
 require 'socket'
 
 module HTTP
   class Options
-
     # How to format the response [:object, :body, :parse_body]
     attr_accessor :response
 
@@ -17,15 +16,15 @@ module HTTP
     # Form data to embed in the request
     attr_accessor :form
 
+    # JSON data to embed in the request
+    attr_accessor :json
+
     # Explicit request body of the request
     attr_accessor :body
 
     # HTTP proxy to route request
     attr_accessor :proxy
 
-    # Before callbacks
-    attr_accessor :callbacks
-
     # Socket classes
     attr_accessor :socket_class, :ssl_socket_class
 
@@ -35,7 +34,7 @@ module HTTP
     # Follow redirects
     attr_accessor :follow
 
-    protected :response=, :headers=, :proxy=, :params=, :form=,  :callbacks=, :follow=
+    protected :response=, :headers=, :proxy=, :params=, :form=, :json=, :follow=
 
     @default_socket_class     = TCPSocket
     @default_ssl_socket_class = OpenSSL::SSL::SSLSocket
@@ -51,36 +50,23 @@ module HTTP
 
     def initialize(options = {})
       @response  = options[:response]  || :auto
-      @headers   = options[:headers]   || {}
       @proxy     = options[:proxy]     || {}
-      @callbacks = options[:callbacks] || {:request => [], :response => []}
       @body      = options[:body]
-      @params      = options[:params]
+      @params    = options[:params]
       @form      = options[:form]
+      @json      = options[:json]
       @follow    = options[:follow]
 
+      @headers   = HTTP::Headers.coerce(options[:headers] || {})
+
       @socket_class     = options[:socket_class]     || self.class.default_socket_class
       @ssl_socket_class = options[:ssl_socket_class] || self.class.default_ssl_socket_class
       @ssl_context      = options[:ssl_context]
-
-      @headers["User-Agent"] ||= "RubyHTTPGem/#{HTTP::VERSION}"
-    end
-
-    def with_response(response)
-      unless [:auto, :object, :body, :parsed_body].include?(response)
-        argument_error! "invalid response type: #{response}"
-      end
-      dup do |opts|
-        opts.response = response
-      end
     end
 
     def with_headers(headers)
-      unless headers.respond_to?(:to_hash)
-        argument_error! "invalid headers: #{headers}"
-      end
       dup do |opts|
-        opts.headers = self.headers.merge(headers.to_hash)
+        opts.headers = self.headers.merge(headers)
       end
     end
 
@@ -102,31 +88,21 @@ module HTTP
       end
     end
 
-    def with_body(body)
+    def with_json(data)
       dup do |opts|
-        opts.body = body
+        opts.json = data
       end
     end
 
-    def with_follow(follow)
+    def with_body(body)
       dup do |opts|
-        opts.follow = follow
+        opts.body = body
       end
     end
 
-    def with_callback(event, callback)
-      unless callback.respond_to?(:call)
-        argument_error! "invalid callback: #{callback}"
-      end
-      unless callback.respond_to?(:arity) and callback.arity == 1
-        argument_error! "callback must accept only one argument"
-      end
-      unless [:request, :response].include?(event)
-        argument_error! "invalid callback event: #{event}"
-      end
+    def with_follow(follow)
       dup do |opts|
-        opts.callbacks = callbacks.dup
-        opts.callbacks[event] = (callbacks[event].dup << callback)
+        opts.follow = follow
       end
     end
 
@@ -136,12 +112,10 @@ module HTTP
 
     def merge(other)
       h1, h2 = to_hash, other.to_hash
-      merged = h1.merge(h2) do |k,v1,v2|
+      merged = h1.merge(h2) do |k, v1, v2|
         case k
         when :headers
           v1.merge(v2)
-        when :callbacks
-          v1.merge(v2){|event,l,r| (l+r).uniq}
         else
           v2
         end
@@ -156,12 +130,12 @@ module HTTP
       # get serialized here, rather than manually having to add them each time
       {
         :response         => response,
-        :headers          => headers,
+        :headers          => headers.to_h,
         :proxy            => proxy,
         :params           => params,
         :form             => form,
+        :json             => json,
         :body             => body,
-        :callbacks        => callbacks,
         :follow           => follow,
         :socket_class     => socket_class,
         :ssl_socket_class => ssl_socket_class,
@@ -175,11 +149,10 @@ module HTTP
       dupped
     end
 
-    private
+  private
 
     def argument_error!(message)
-      raise ArgumentError, message, caller[1..-1]
+      fail(Error, message, caller[1..-1])
     end
-
   end
 end