rack-client 0.1.1 → 0.3.0

data/lib/rack/client/handler/net_http.rb

@@ -0,0 +1,85 @@
+require 'net/http'
+require 'net/https'
+
+module Rack
+  module Client
+    module Handler
+      class NetHTTP
+        include Rack::Client::DualBand
+
+        class << self
+          extend Forwardable
+          def_delegator :new, :call
+        end
+
+        def sync_call(env)
+          request = Rack::Request.new(env)
+
+          connection_for(request).request(net_request_for(request), body_for(request)) do |net_response|
+            return parse(net_response).finish
+          end
+        end
+
+        def async_call(env)
+          request = Rack::Request.new(env)
+
+          connection_for(request).request(net_request_for(request), body_for(request)) do |net_response|
+            yield parse(net_response).finish
+          end
+        end
+
+        def connection_for(request)
+          connection = Net::HTTP.new(request.host, request.port)
+
+          if request.scheme == 'https'
+            connection.use_ssl = true
+            connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+
+          connection.start
+          connection
+        end
+
+        def net_request_for(request)
+          klass = case request.request_method
+                  when 'DELETE' then Net::HTTP::Delete
+                  when 'GET'    then Net::HTTP::Get
+                  when 'HEAD'   then Net::HTTP::Head
+                  when 'POST'   then Net::HTTP::Post
+                  when 'PUT'    then Net::HTTP::Put
+                  end
+
+          klass.new(request.path, Headers.from(request.env).to_http)
+        end
+
+        def body_for(request)
+          case request.body
+          when StringIO then request.body.string
+          when IO       then request.body.read
+          when Array    then request.body.to_s
+          when String   then request.body
+          end
+        end
+
+        def parse(net_response)
+          body = (net_response.body.nil? || net_response.body.empty?) ? [] : StringIO.new(net_response.body)
+          Response.new(net_response.code.to_i, parse_headers(net_response), body)
+        end
+
+        def parse_headers(net_response)
+          headers = Headers.new
+
+          net_response.each do |(k,v)|
+            headers.update(k => v)
+          end
+
+          headers.to_http
+        end
+
+        def connections
+          @connections ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/handler/typhoeus.rb

@@ -0,0 +1,62 @@
+require 'typhoeus'
+
+module Rack
+  module Client
+    module Handler
+      class Typhoeus
+        include Rack::Client::DualBand
+
+        def initialize(url, hydra = Typhoeus::Hydra.new)
+          @uri, @hydra = URI.parse(url), hydra
+        end
+
+        def async_call(env)
+          rack_request = Rack::Request.new(env)
+
+          typhoeus_request = request_for(rack_request)
+
+          typhoeus_request.on_complete do |response|
+            yield parse(response).finish
+          end
+
+          @hydra.queue typhoeus_request
+        end
+
+        def sync_call(env)
+          rack_request = Rack::Request.new(env)
+
+          parse(process(rack_request)).finish
+        end
+
+        def parse(typhoeus_response)
+          body = (typhoeus_response.body.nil? || typhoeus_response.body.empty?) ? [] : StringIO.new(typhoeus_response.body)
+          Response.new(typhoeus_response.code, Headers.new(typhoeus_response.headers_hash).to_http, body)
+        end
+
+        def request_for(rack_request)
+          ::Typhoeus::Request.new((@uri + rack_request.path).to_s, params_for(rack_request))
+        end
+
+        def process(rack_request)
+          ::Typhoeus::Request.run((@uri + rack_request.path).to_s, params_for(rack_request))
+        end
+
+        def params_for(rack_request)
+          {
+            :method => rack_request.request_method.downcase.to_sym,
+            :headers => Headers.from(rack_request.env).to_http,
+            :params => {}
+          }.merge(body_params_for(rack_request))
+        end
+
+        def body_params_for(rack_request)
+          unless %w[ HEAD GET ].include? rack_request.request_method
+            {:body => rack_request.body.string}
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/headers.rb

@@ -0,0 +1,49 @@
+module Rack
+  module Client
+    class Headers < Hash
+      def self.from(env)
+        new env.reject {|(header,_)| header !~ %r'^HTTP_' unless %w( CONTENT_TYPE CONTENT_LENGTH ).include?(header) }
+      end
+
+      def initialize(headers = {})
+        super
+        merge!(headers)
+      end
+
+      def clean(header)
+        header.gsub(/HTTP_/, '').gsub('_', '-').gsub(/(\w+)/) do |matches|
+          matches.downcase.sub(/^./) do |char|
+            char.upcase
+          end
+        end
+      end
+
+      def to_http
+        self.inject({}) {|h,(header,value)| h.update(clean(header) => value) }
+      end
+
+      def to_env
+        self.inject({}) {|h,(header,value)| h.update((rackish?(header) ? header : rackify(header)) => value) }
+      end
+
+      def rackish?(header)
+        case header
+        when 'CONTENT_TYPE', 'CONTENT_LENGTH' then true
+        when /^rack[-.]/                      then true
+        when /^HTTP_/                         then true
+        else false
+        end
+      end
+
+      def rackify(original)
+        header =  original.upcase.gsub('-', '_')
+
+        case header
+        when 'CONTENT_TYPE', 'CONTENT_LENGTH' then header
+        when /^HTTP_/                         then header
+        else "HTTP_#{header}"
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/parser.rb

@@ -0,0 +1,18 @@
+module Rack
+  module Client
+    module Parser
+      autoload :JSON, 'rack/client/parser/json'
+      autoload :YAML, 'rack/client/parser/yaml'
+
+      def self.new(app, &b)
+        Context.new(app, &b)
+      end
+    end
+  end
+end
+
+require 'rack/client/parser/base'
+require 'rack/client/parser/body_collection'
+require 'rack/client/parser/context'
+require 'rack/client/parser/request'
+require 'rack/client/parser/response'

data/lib/rack/client/parser/base.rb

@@ -0,0 +1,25 @@
+module Rack
+  module Client
+    module Parser
+      class Base
+        CONTENT_TYPE = %r'^([^/]+)/([^;]+)\s?(?:;\s?(.*))?$'
+
+        @@type_table ||= Hash.new {|h,k| h[k] = Hash.new {|hh,kk| hh[kk] = {} } }
+
+        def self.content_type(type, subtype, *parameters)
+          type_table[type][subtype][parameters] = self
+        end
+
+        def self.type_table
+          @@type_table
+        end
+
+        def self.lookup(content_type)
+          type, subtype, *parameters = content_type.scan(CONTENT_TYPE).first
+
+          type_table[type][subtype][parameters.compact]
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/parser/body_collection.rb

@@ -0,0 +1,50 @@
+module Rack
+  module Client
+    class BodyCollection
+      instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+
+      def initialize(&load_with_proc)
+        raise ArgumentException, 'BodyCollection must be initialized with a block' unless block_given?
+
+        @loaded         = false
+        @finished       = false
+        @load_with_proc = load_with_proc
+        @callbacks      = []
+        @array          = []
+      end
+
+      def each(&block)
+        @callbacks << block
+        @array.each {|a| yield(*a) }
+
+        lazy_load unless finished?
+      ensure
+        @callbacks.delete(block)
+      end
+
+      def lazy_load
+        until finished?
+          @load_with_proc[self]
+        end
+      end
+
+      def <<(value)
+        @array << value
+        @callbacks.each {|cb| cb[value] }
+      end
+
+      def finished?
+        @finished
+      end
+
+      def finish
+        @finished = true
+      end
+
+      def method_missing(sym, *a, &b)
+        lazy_load
+        @array.send(sym, *a, &b)
+      end
+    end
+  end
+end

data/lib/rack/client/parser/context.rb

@@ -0,0 +1,15 @@
+module Rack
+  module Client
+    module Parser
+      class Context
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          Response.new(*@app.call(Request.new(env).env)).finish
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/parser/json.rb

@@ -0,0 +1,54 @@
+require 'json'
+
+module Rack
+  module Client
+    module Parser
+      class JSON < Parser::Base
+
+        content_type 'application', 'json'
+
+        def encode(input)
+          output = StringIO.new
+
+          input.each do |object|
+            ::JSON.dump(object, output)
+          end
+
+          output
+        end
+
+        def decode(body)
+          BodyCollection.new do |collection|
+            begin
+              data = if body.respond_to? :read
+                       body.read
+                     elsif body.respond_to? :to_path
+                       File.read(body.to_path)
+                     else
+                       io = StringIO.new
+
+                       body.each do |part|
+                         io << part
+                       end
+
+                       io.rewind
+                       io.read
+                     end
+
+              case result = ::JSON.parse(data)
+              when Array then result.each {|object| collection << object }
+              else collection << result
+              end
+
+              collection.finish
+            ensure
+              body.close if body.respond_to? :close
+            end
+          end
+        end
+      end
+
+      Yaml = YAML
+    end
+  end
+end

data/lib/rack/client/parser/middleware.rb

@@ -0,0 +1,8 @@
+module Rack
+  module Client
+    module Parser
+      class Middleware
+      end
+    end
+  end
+end

data/lib/rack/client/parser/request.rb

@@ -0,0 +1,21 @@
+module Rack
+  module Client
+    module Parser
+      class Request < Rack::Request
+        def initialize(*)
+          super
+
+          if @env['rack-client.body_collection'] && content_type
+            parse_input(@env['rack-client.body_collection'])
+          end
+        end
+
+        def parse_input(collection)
+          if parser = Base.lookup(content_type)
+            @env['rack.input'] = parser.new.encode(collection)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/parser/response.rb

@@ -0,0 +1,19 @@
+module Rack
+  module Client
+    module Parser
+      class Response < Rack::Client::Response
+        def finish(*)
+          super
+        ensure
+          parse_body_as(headers['Content-Type']) if headers['Content-Type']
+        end
+
+        def parse_body_as(content_type)
+          if parser = Base.lookup(content_type)
+            headers['rack-client.body_collection'] = parser.new.decode(body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/client/parser/yaml.rb

@@ -0,0 +1,52 @@
+require 'yaml'
+
+module Rack
+  module Client
+    module Parser
+      class YAML < Parser::Base
+
+        content_type 'application', 'x-yaml'
+
+        def encode(input)
+          output = StringIO.new
+
+          input.each do |object|
+            ::YAML.dump(object, output)
+          end
+
+          output
+        end
+
+        def decode(body)
+          BodyCollection.new do |collection|
+            begin
+              io = if body.respond_to? :to_path
+                     File.open(body.to_path, 'r')
+                   else
+                     io = StringIO.new
+
+                     body.each do |part|
+                       io << part
+                     end
+
+                     io.rewind
+                     io
+                   end
+
+              ::YAML.load_documents(io) do |object|
+                collection << object
+              end
+
+              collection.finish
+            ensure
+              io.close if io.respond_to? :close
+              body.close if body.respond_to? :close
+            end
+          end
+        end
+      end
+
+      Yaml = YAML
+    end
+  end
+end