alice 0.1.0

data/lib/alice/builder.rb

@@ -0,0 +1,39 @@
+require 'rack/builder'
+
+module Alice
+  # Possibly going to extend this a bit.
+  #
+  # Alice::Connection.new(:url => 'http://sushi.com') do
+  #   request  :yajl     # Alice::Request::Yajl
+  #   adapter  :logger   # Alice::Adapter::Logger
+  #   response :yajl     # Alice::Response::Yajl
+  # end
+  class Builder < Rack::Builder
+    def self.create_with_inner_app(&block)
+      inner = lambda do |env| 
+        if !env[:parallel_manager]
+          env[:response].finish(env)
+        else
+          env[:response]
+        end
+      end
+      Builder.new(&block).tap { |builder| builder.run(inner) }
+    end
+
+    def request(key, *args, &block)
+      use_symbol Alice::Request, key, *args, &block
+    end
+
+    def response(key, *args, &block)
+      use_symbol Alice::Response, key, *args, &block
+    end
+
+    def adapter(key, *args, &block)
+      use_symbol Alice::Adapter, key, *args, &block
+    end
+
+    def use_symbol(mod, key, *args, &block)
+      use mod.lookup_module(key), *args, &block
+    end
+  end
+end

data/lib/alice/connection.rb

@@ -0,0 +1,183 @@
+require 'addressable/uri'
+require 'set'
+
+module Alice
+  class Connection
+    include Addressable, Rack::Utils
+
+    HEADERS = Hash.new { |h, k| k.respond_to?(:to_str) ? k : k.to_s.capitalize }.update \
+      :content_type    => "Content-Type",
+      :content_length  => "Content-Length",
+      :accept_charset  => "Accept-Charset",
+      :accept_encoding => "Accept-Encoding"
+    HEADERS.values.each { |v| v.freeze }
+
+    METHODS = Set.new [:get, :post, :put, :delete, :head]
+    METHODS_WITH_BODIES = Set.new [:post, :put]
+
+    attr_accessor :host, :port, :scheme, :params, :headers, :parallel_manager
+    attr_reader   :path_prefix, :builder
+
+    # :url
+    # :params
+    # :headers
+    def initialize(url = nil, options = {}, &block)
+      if url.is_a?(Hash)
+        options = url
+        url     = options[:url]
+      end
+      @headers          = HeaderHash.new
+      @params           = {}
+      @parallel_manager = options[:parallel]
+      self.url_prefix = url if url
+      merge_params  @params,  options[:params]  if options[:params]
+      merge_headers @headers, options[:headers] if options[:headers]
+      if block
+        @builder = Builder.create_with_inner_app(&block)
+      end
+    end
+
+    def get(url = nil, headers = nil, &block)
+      run_request :get, url, nil, headers, &block
+    end
+
+    def post(url = nil, body = nil, headers = nil, &block)
+      run_request :post, url, body, headers, &block
+    end
+
+    def put(url = nil, body = nil, headers = nil, &block)
+      run_request :put, url, body, headers, &block
+    end
+
+    def head(url = nil, headers = nil, &block)
+      run_request :head, url, nil, headers, &block
+    end
+
+    def delete(url = nil, headers = nil, &block)
+      run_request :delete, url, nil, headers, &block
+    end
+
+    def run_request(method, url, body, headers)
+      if !METHODS.include?(method)
+        raise ArgumentError, "unknown http method: #{method}"
+      end
+
+      Request.run(self, method) do |req|
+        req.url(url)                if url
+        req.headers.update(headers) if headers
+        req.body = body             if body
+        yield req if block_given?
+      end
+    end
+
+    def in_parallel?
+      !!@parallel_manager
+    end
+
+    def in_parallel(manager)
+      @parallel_manager = manager
+      yield
+      @parallel_manager && @parallel_manager.run
+    ensure
+      @parallel_manager = nil
+    end
+
+    # return the assembled Rack application for this instance.
+    def to_app
+      @builder.to_app
+    end
+
+    # Parses the giving url with Addressable::URI and stores the individual
+    # components in this connection.  These components serve as defaults for 
+    # requests made by this connection.
+    #
+    #   conn = Alice::Connection.new { ... }
+    #   conn.url_prefix = "https://sushi.com/api"
+    #   conn.scheme      # => https
+    #   conn.path_prefix # => "/api"
+    #
+    #   conn.get("nigiri?page=2") # accesses https://sushi.com/api/nigiri
+    #
+    def url_prefix=(url)
+      uri              = URI.parse(url)
+      self.scheme      = uri.scheme
+      self.host        = uri.host
+      self.port        = uri.port
+      self.path_prefix = uri.path
+      if uri.query && !uri.query.empty?
+        merge_params @params, parse_query(uri.query)
+      end
+    end
+
+    # Ensures that the path prefix always has a leading / and no trailing /
+    def path_prefix=(value)
+      if value
+        value.chomp!  "/"
+        value.replace "/#{value}" if value !~ /^\//
+      end
+      @path_prefix = value
+    end
+
+    # Takes a relative url for a request and combines it with the defaults 
+    # set on the connection instance.
+    #
+    #   conn = Alice::Connection.new { ... }
+    #   conn.url_prefix = "https://sushi.com/api?token=abc"
+    #   conn.scheme      # => https
+    #   conn.path_prefix # => "/api"
+    #
+    #   conn.build_url("nigiri?page=2")      # => https://sushi.com/api/nigiri?token=abc&page=2
+    #   conn.build_url("nigiri", :page => 2) # => https://sushi.com/api/nigiri?token=abc&page=2
+    #
+    def build_url(url, params = nil)
+      uri          = URI.parse(url.to_s)
+      uri.scheme ||= @scheme
+      uri.host   ||= @host
+      uri.port   ||= @port
+      if @path_prefix && uri.path !~ /^\//
+        uri.path = "#{@path_prefix.size > 1 ? @path_prefix : nil}/#{uri.path}"
+      end
+      replace_query(uri, params)
+      uri
+    end
+
+    def replace_query(uri, params)
+      url_params = @params.dup
+      if uri.query && !uri.query.empty?
+        merge_params url_params, parse_query(uri.query)
+      end
+      if params && !params.empty?
+        merge_params url_params, params
+      end
+      uri.query = url_params.empty? ? nil : build_query(url_params)
+      uri
+    end
+
+    # turns param keys into strings
+    def merge_params(existing_params, new_params)
+      new_params.each do |key, value|
+        existing_params[key.to_s] = value
+      end
+    end
+
+    # turns headers keys and values into strings.  Look up symbol keys in the 
+    # the HEADERS hash.  
+    #
+    #   h = merge_headers(HeaderHash.new, :content_type => 'text/plain')
+    #   h['Content-Type'] # = 'text/plain'
+    #
+    def merge_headers(existing_headers, new_headers)
+      new_headers.each do |key, value|
+        existing_headers[HEADERS[key]] = value.to_s
+      end
+    end
+
+    # Be sure to URI escape '+' symbols to %2B.  Otherwise, they get interpreted
+    # as spaces.
+    def escape(s)
+      s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/n) do
+        '%' << $1.unpack('H2'*bytesize($1)).join('%').tap { |c| c.upcase! }
+      end
+    end
+  end
+end

data/lib/alice/error.rb

@@ -0,0 +1,6 @@
+module Alice
+  module Error
+    class ConnectionFailed < StandardError; end
+    class ResourceNotFound < StandardError; end
+  end
+end

data/lib/alice/middleware.rb

@@ -0,0 +1,54 @@
+module Alice
+  class Middleware
+    include Rack::Utils
+
+    class << self
+      attr_accessor :load_error, :supports_parallel_requests
+      alias supports_parallel_requests? supports_parallel_requests
+
+      # valid parallel managers should respond to #run with no parameters.
+      # otherwise, return a short wrapper around it.
+      def setup_parallel_manager(options = {})
+        nil
+      end
+    end
+
+    def self.loaded?
+      @load_error.nil?
+    end
+
+    def initialize(app = nil)
+      @app = app
+    end
+
+    # assume that query and fragment are already encoded properly
+    def full_path_for(path, query = nil, fragment = nil)
+      full_path = path.dup
+      if query && !query.empty?
+        full_path << "?#{query}"
+      end
+      if fragment && !fragment.empty?
+        full_path << "##{fragment}"
+      end
+      full_path
+    end
+
+    def process_body_for_request(env)
+      # if it's a string, pass it through
+      return if env[:body].nil? || env[:body].empty? || !env[:body].respond_to?(:each_key)
+      env[:request_headers]['Content-Type'] ||= 'application/x-www-form-urlencoded'
+      env[:body] = create_form_params(env[:body])
+    end
+
+    def create_form_params(params, base = nil)
+      [].tap do |result|
+        params.each_key do |key|
+          key_str = base ? "#{base}[#{key}]" : key
+          value   = params[key]
+          wee = (value.kind_of?(Hash) ? create_form_params(value, key_str) : "#{key_str}=#{escape(value.to_s)}")
+          result << wee
+        end
+      end.join("&")
+    end
+  end
+end

data/lib/alice/request.rb

@@ -0,0 +1,77 @@
+module Alice
+  # Used to setup urls, params, headers, and the request body in a sane manner.
+  #
+  #   @connection.post do |req|
+  #     req.url 'http://localhost', 'a' => '1' # 'http://localhost?a=1'
+  #     req.headers['b'] = '2' # header
+  #     req['b']         = '2' # header
+  #     req.body = 'abc'
+  #   end
+  #
+  class Request < Struct.new(:path, :params, :headers, :body)
+    extend AutoloadHelper
+    autoload_all 'alice/request',
+      :Yajl              => 'yajl',
+      :ActiveSupportJson => 'active_support_json'
+
+    register_lookup_modules \
+      :yajl                => :Yajl,
+      :activesupport_json  => :ActiveSupportJson,
+      :rails_json          => :ActiveSupportJson,
+      :active_support_json => :ActiveSupportJson
+
+    def self.run(connection, request_method)
+      req = create
+      yield req if block_given?
+      req.run(connection, request_method)
+    end
+
+    def self.create
+      req = new(nil, {}, {}, nil)
+      yield req if block_given?
+      req
+    end
+
+    def url(path, params = {})
+      self.path   = path
+      self.params = params
+    end
+
+    def [](key)
+      headers[key]
+    end
+
+    def []=(key, value)
+      headers[key] = value
+    end
+
+    # ENV Keys
+    # :method - a symbolized request method (:get, :post)
+    # :body   - the request body that will eventually be converted to a string.
+    # :url    - Addressable::URI instance of the URI for the current request.
+    # :status           - HTTP response status code
+    # :request_headers  - hash of HTTP Headers to be sent to the server
+    # :response_headers - Hash of HTTP headers from the server
+    # :parallel_manager - sent if the connection is in parallel mode
+    # :response         - the actual response object that stores the rack response
+    def to_env_hash(connection, request_method)
+      env_headers = connection.headers.dup
+      env_params  = connection.params.dup
+      connection.merge_headers env_headers, headers
+      connection.merge_params  env_params,  params
+
+      { :method           => request_method, 
+        :body             => body, 
+        :url              => connection.build_url(path, env_params),
+        :request_headers  => env_headers,
+        :parallel_manager => connection.parallel_manager,
+        :response         => Response.new}
+    end
+
+    def run(connection, request_method)
+      app = connection.to_app
+      env = to_env_hash(connection, request_method)
+      app.call(env)
+    end
+  end
+end

data/lib/alice/request/active_support_json.rb

@@ -0,0 +1,20 @@
+module Alice
+  class Request::ActiveSupportJson < Alice::Middleware
+    begin
+      if !defined?(ActiveSupport::JSON)
+        require 'active_support'
+      end
+
+    rescue LoadError => e
+      self.load_error = e
+    end
+
+    def call(env)
+      env[:request_headers]['Content-Type'] = 'application/json'
+      if env[:body] && !env[:body].respond_to?(:to_str)
+        env[:body] = ActiveSupport::JSON.encode env[:body]
+      end
+      @app.call env
+    end
+  end
+end

data/lib/alice/request/yajl.rb

@@ -0,0 +1,18 @@
+module Alice
+  class Request::Yajl < Alice::Middleware
+    begin
+      require 'yajl'
+
+    rescue LoadError => e
+      self.load_error = e
+    end
+
+    def call(env)
+      env[:request_headers]['Content-Type'] = 'application/json'
+      if env[:body] && !env[:body].respond_to?(:to_str)
+        env[:body] = Yajl::Encoder.encode env[:body]
+      end
+      @app.call env
+    end
+  end
+end

data/lib/alice/response.rb

@@ -0,0 +1,48 @@
+module Alice
+  class Response
+    class Middleware < Alice::Middleware
+      self.load_error = :abstract
+
+      # Use a response callback in case the request is parallelized.
+      #
+      #   env[:response].on_complete do |finished_env|
+      #     finished_env[:body] = do_stuff_to(finished_env[:body])
+      #   end
+      #
+      def self.register_on_complete(env)
+      end
+
+      def call(env)
+        self.class.register_on_complete(env)
+        @app.call env
+      end
+    end
+
+    extend AutoloadHelper
+    autoload_all 'alice/response',
+      :Yajl              => 'yajl',
+      :ActiveSupportJson => 'active_support_json'
+
+    register_lookup_modules \
+      :yajl                => :Yajl,
+      :activesupport_json  => :ActiveSupportJson,
+      :rails_json          => :ActiveSupportJson,
+      :active_support_json => :ActiveSupportJson
+    attr_accessor :status, :headers, :body
+
+    def initialize
+      @status, @headers, @body = nil, nil, nil
+      @on_complete_callbacks = []
+    end
+
+    def on_complete(&block)
+      @on_complete_callbacks << block
+    end
+
+    def finish(env)
+      @on_complete_callbacks.each { |c| c.call(env) }
+      @status, @headers, @body = env[:status], env[:response_headers], env[:body]
+      self
+    end
+  end
+end