faraday 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 rick
+
+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/README.rdoc

@@ -0,0 +1,88 @@
+= faraday
+
+Experiments in a REST API lib
+
+Super alpha!  Don't use it if you mind throwing away all the code when I change
+the API on a whim.
+
+This mess is gonna get raw, like sushi. So, haters to the left.
+
+== Usage
+
+    # uses Net/HTTP, no response parsing
+    conn = Faraday::Connection.new("http://sushi.com")
+    conn.extend Faraday::Adapter::NetHttp
+    resp = conn.get("/sake.json")
+    resp.body # => %({"name":"Sake"})
+
+    # uses Net/HTTP, Yajl parsing
+    conn = Faraday::Connection.new("http://sushi.com")
+    conn.extend Faraday::Adapter::NetHttp
+    conn.response_class = Faraday::Response::YajlResponse
+    resp = conn.get("/sake.json")
+    resp.body # => {"name": "Sake"}
+
+    # uses Typhoeus, no response parsing
+    conn = Faraday::Connection.new("http://sushi.com")
+    conn.extend Faraday::Adapter::Typhoeus
+    resp = conn.get("/sake.json")
+    resp.body # => %({"name":"Sake"})
+
+    # uses Typhoeus, Yajl parsing, performs requests in parallel
+    conn = Faraday::Connection.new("http://sushi.com")
+    conn.extend Faraday::Adapter::Typhoeus
+    conn.response_class = Faraday::Response::YajlResponse
+    resp1, resp2 = nil, nil
+    conn.in_parallel do
+      resp1 = conn.get("/sake.json")
+      resp2 = conn.get("/unagi.json")
+
+      # requests have not been made yet
+      resp1.body # => nil
+      resp2.body # => nil
+    end
+    resp1.body # => {"name": "Sake"}
+    resp2.body # => {"name": "Unagi"}
+
+== Testing
+
+* Yajl is needed for tests :(
+* Live Sinatra server is required for tests: `ruby test/live_server.rb` to start it.
+
+=== Writing tests based on faraday
+
+Using the MockRequest connection adapter you can implement your own test
+connection class:
+
+    class TestConnection < Faraday::Connection
+      extend Faraday::Adapter::MockRequest
+    end
+
+    conn = TestConnection.new do |stub|
+      stub.get('/hello.json', { 'hi world' }
+    end
+    resp = conn.get '/hello.json'
+    resp.body                     # => 'hi world'
+    resp = conn.get '/whatever'   # => <not stubbed, raises connection error>
+
+== TODO
+
+* other HTTP methods besides just GET
+* gracefully skip tests for Yajl and other optional libraries if they don't exist.
+* gracefully skip live http server tests if the sinatra server is not running.
+* use Typhoeus' request mocking facilities in the Typhoeus adapter test
+* lots of other crap
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 rick. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "faraday"
+    gem.summary = "HTTP/REST API client library"
+    gem.description = "HTTP/REST API client library with pluggable components"
+    gem.email = "technoweenie@gmail.com"
+    gem.homepage = "http://github.com/technoweenie/faraday"
+    gem.authors = ["rick"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "faraday #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/faraday.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{faraday}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["rick"]
+  s.date = %q{2009-12-19}
+  s.description = %q{HTTP/REST API client library with pluggable components}
+  s.email = %q{technoweenie@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "faraday.gemspec",
+     "lib/faraday.rb",
+     "lib/faraday/adapter/mock_request.rb",
+     "lib/faraday/adapter/net_http.rb",
+     "lib/faraday/adapter/typhoeus.rb",
+     "lib/faraday/connection.rb",
+     "lib/faraday/error.rb",
+     "lib/faraday/response.rb",
+     "lib/faraday/response/yajl_response.rb",
+     "test/adapter/typhoeus_test.rb",
+     "test/adapter_test.rb",
+     "test/connection_test.rb",
+     "test/helper.rb",
+     "test/live_server.rb",
+     "test/response_test.rb"
+  ]
+  s.homepage = %q{http://github.com/technoweenie/faraday}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{HTTP/REST API client library}
+  s.test_files = [
+    "test/adapter/typhoeus_test.rb",
+     "test/adapter_test.rb",
+     "test/connection_test.rb",
+     "test/helper.rb",
+     "test/live_server.rb",
+     "test/response_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/faraday.rb

@@ -0,0 +1,47 @@
+module Faraday
+  # Loads each autoloaded constant.  If thread safety is a concern, wrap
+  # this in a Mutex.
+  def self.load
+    constants.each do |const|
+      const_get(const) if autoload?(const)
+    end
+  end
+
+  autoload :Connection, 'faraday/connection'
+  autoload :Response,   'faraday/response'
+  autoload :Error,      'faraday/error'
+
+  module Adapter
+    autoload :NetHttp,     'faraday/adapter/net_http'
+    autoload :Typhoeus,    'faraday/adapter/typhoeus'
+    autoload :MockRequest, 'faraday/adapter/mock_request'
+
+    # Names of available adapters.  Should not actually load them.
+    def self.adapters
+      constants
+    end
+
+    # Array of Adapters.  These have been loaded and confirmed to work (right gems, etc).
+    def self.loaded_adapters
+      adapters.map { |c| const_get(c) }.select { |a| a.loaded? }
+    end
+  end
+end
+
+# not pulling in active-support JUST for this method.
+class Object
+  # Yields <code>x</code> to the block, and then returns <code>x</code>.
+  # The primary purpose of this method is to "tap into" a method chain,
+  # in order to perform operations on intermediate results within the chain.
+  #
+  #   (1..10).tap { |x| puts "original: #{x.inspect}" }.to_a.
+  #     tap    { |x| puts "array: #{x.inspect}" }.
+  #     select { |x| x%2 == 0 }.
+  #     tap    { |x| puts "evens: #{x.inspect}" }.
+  #     map    { |x| x*x }.
+  #     tap    { |x| puts "squares: #{x.inspect}" }
+  def tap
+    yield self
+    self
+  end unless Object.respond_to?(:tap)
+end

data/lib/faraday/adapter/mock_request.rb

@@ -0,0 +1,68 @@
+module Faraday
+  module Adapter
+    module MockRequest
+      extend Faraday::Connection::Options
+      def self.loaded?() false end
+
+      include Faraday::Error # ConnectionFailed
+
+      class Stubs
+        def initialize
+          # {:get => [Stub, Stub]}
+          @stack = {}
+          yield self if block_given?
+        end
+
+        def empty?
+          @stack.empty?
+        end
+
+        def match(request_method, path, request_headers)
+          return false if !@stack.key?(request_method)
+          @stack[request_method].detect { |stub| stub.matches?(path, request_headers) }
+        end
+
+        def get(path, request_headers = {}, &block)
+          (@stack[:get] ||= []) << new_stub(path, request_headers, block)
+        end
+
+        def new_stub(path, request_headers, block)
+          status, response_headers, body = block.call
+          Stub.new(path, request_headers, status, response_headers, body)
+        end
+      end
+
+      class Stub < Struct.new(:path, :request_headers, :status, :response_headers, :body)
+        def matches?(request_path, headers)
+          return false if request_path != path
+          return true  if request_headers.empty?
+          request_headers.each do |key, value|
+            return true if headers[key] == value
+          end 
+          false
+        end
+      end
+
+      def initialize &block
+        super nil
+        yield stubs
+      end
+
+      def stubs
+        @stubs ||= Stubs.new
+      end
+
+      def _get(uri, headers)
+        raise ConnectionFailed, "no stubbed requests" if stubs.empty?
+        if stub = @stubs.match(:get, uri.path, headers)
+          response_class.new do |resp|
+            resp.headers = stub.response_headers
+            resp.process stub.body
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/faraday/adapter/net_http.rb

@@ -0,0 +1,22 @@
+require 'net/http'
+module Faraday
+  module Adapter
+    module NetHttp
+      extend Faraday::Connection::Options
+
+      def _get(uri, request_headers)
+        http      = Net::HTTP.new(uri.host, uri.port)
+        response_class.new do |resp|
+          http_resp = http.get(uri.path, request_headers) do |chunk|
+            resp.process(chunk)
+          end
+          http_resp.each_header do |key, value|
+            resp.headers[key] = value
+          end
+        end
+      rescue Errno::ECONNREFUSED
+        raise Faraday::Error::ConnectionFailed, "connection refused"
+      end
+    end
+  end
+end

data/lib/faraday/adapter/typhoeus.rb

@@ -0,0 +1,55 @@
+module Faraday
+  module Adapter
+    module Typhoeus
+      extend Faraday::Connection::Options
+
+      begin
+        require 'typhoeus'
+
+        def in_parallel?
+          !!@parallel_manager
+        end
+        
+        def in_parallel(options = {})
+          setup_parallel_manager(options)
+          yield
+          run_parallel_requests
+        end
+        
+        def setup_parallel_manager(options = {})
+          @parallel_manager ||= ::Typhoeus::Hydra.new(options)
+        end
+        
+        def run_parallel_requests
+          @parallel_manager.run
+          @parallel_manager = nil
+        end
+        
+        def _get(uri, request_headers)
+          response_class.new do |resp|
+            is_async = in_parallel?
+            setup_parallel_manager
+            req      = ::Typhoeus::Request.new(uri.to_s, :headers => request_headers, :method => :get)
+            req.on_complete do |response|
+              resp.process!(response.body)
+              resp.headers = parse_response_headers(response.headers)
+            end
+            @parallel_manager.queue(req)
+            if !is_async then run_parallel_requests end
+          end
+        rescue Errno::ECONNREFUSED
+          raise Faraday::Error::ConnectionFailed, "connection refused"
+        end
+
+        def parse_response_headers(header_string)
+          Hash[*header_string.split(/\r\n/).
+            tap  { |a|      a.shift           }. # drop the HTTP status line
+            map! { |h|      h.split(/:\s+/,2) }. # split key and value
+            map! { |(k, v)| [k.downcase, v]   }.flatten!]
+        end
+      rescue LoadError => e
+        self.load_error = e
+      end
+    end
+  end
+end

data/lib/faraday/connection.rb

@@ -0,0 +1,100 @@
+require 'addressable/uri'
+module Faraday
+  class Connection
+    module Options
+      def load_error()       @load_error         end
+      def load_error=(v)     @load_error = v     end
+      def supports_async()   @supports_async     end
+      def supports_async=(v) @supports_async = v end
+      def loaded?()         !@load_error         end
+      alias supports_async? supports_async
+    end
+
+    include Addressable
+
+    attr_accessor :host, :port, :scheme
+    attr_reader   :path_prefix
+
+    def initialize(url = nil)
+      @response_class = nil
+      if url
+        uri              = URI.parse(url)
+        self.scheme      = uri.scheme
+        self.host        = uri.host
+        self.port        = uri.port
+        self.path_prefix = uri.path
+      end
+    end
+
+    # Override in a subclass, or include an adapter
+    #
+    #   def _get(uri, headers)
+    #   end
+    #
+    def get(url, params = {}, headers = {})
+      _get(build_uri(url, params), headers)
+    end
+
+    def response_class
+      @response_class || Response
+    end
+
+    def response_class=(v)
+      if v.respond_to?(:loaded?) && !v.loaded?
+        raise ArgumentError, "The response class: #{v.inspect} does not appear to be loaded."
+      end
+      @response_class = v
+    end
+
+    def in_parallel?
+      !!@parallel_manager
+    end
+    
+    def in_parallel(options = {})
+      @parallel_manager = true
+      yield
+      @parallel_manager = false
+    end
+    
+    def setup_parallel_manager(options = {})
+    end
+    
+    def run_parallel_requests
+    end
+
+    def path_prefix=(value)
+      if value
+        value.chomp!  "/"
+        value.replace "/#{value}" if value !~ /^\//
+      end
+      @path_prefix = value
+    end
+
+    def build_uri(url, params = {})
+      uri          = URI.parse(url)
+      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
+      query = params_to_query(params)
+      if !query.empty? then uri.query = query end
+      uri
+    end
+
+    def params_to_query(params)
+      params.inject([]) do |memo, (key, val)|
+        memo << "#{escape_for_querystring(key)}=#{escape_for_querystring(val)}"
+      end.join("&")
+    end
+
+    # Some servers convert +'s in URL query params to spaces.
+    # Go ahead and encode it.
+    def escape_for_querystring(s)
+      URI.encode_component(s, Addressable::URI::CharacterClasses::QUERY).tap do |escaped|
+        escaped.gsub! /\+/, "%2B"
+      end
+    end
+  end
+end

data/lib/faraday/error.rb

@@ -0,0 +1,5 @@
+module Faraday
+  module Error
+    class ConnectionFailed < StandardError; end
+  end
+end

data/lib/faraday/response.rb

@@ -0,0 +1,41 @@
+module Faraday
+  class Response < Struct.new(:headers, :body)
+    class << self
+      attr_accessor :load_error
+      def loaded?
+        !load_error
+      end
+    end
+
+    autoload :YajlResponse, 'faraday/response/yajl_response'
+
+    def initialize(headers = nil, body = nil)
+      super(headers || {}, body)
+      if block_given?
+        yield self
+        processed!
+      end
+    end
+
+    # TODO: process is a funky name.  change it
+    # processes a chunk of the streamed body.
+    def process(chunk)
+      if !body
+        self.body = []
+      end
+      body << chunk
+    end
+
+    # Assume the given content is the full body, and not streamed.  
+    def process!(full_body)
+      process(full_body)
+      processed!
+    end
+
+    # Signals the end of streamed content.  Do whatever you need to clean up
+    # the streamed body.
+    def processed!
+      self.body = body.join if body.respond_to?(:join)
+    end
+  end
+end

data/lib/faraday/response/yajl_response.rb

@@ -0,0 +1,35 @@
+module Faraday
+  class Response
+    class YajlResponse < Response
+      attr_reader :body
+
+      begin
+        require 'yajl'
+
+        def initialize(headers = nil, body = nil)
+          super
+          @parser = nil
+        end
+
+        def process(chunk)
+          if !@parser
+            @parser = Yajl::Parser.new
+            @parser.on_parse_complete = method(:object_parsed)
+          end
+          @parser << chunk
+        end
+
+        def processed!
+          @parser = nil
+        end
+
+        def object_parsed(obj)
+          @body = obj
+        end
+
+      rescue LoadError => e
+        self.load_error = e
+      end
+    end
+  end
+end

data/test/adapter/typhoeus_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'helper'))
+
+if Faraday::Adapter::Typhoeus.loaded?
+  class TyphoeusTest < Faraday::TestCase
+    describe "#parse_response_headers" do
+      before do
+        @conn = Object.new.extend(Faraday::Adapter::Typhoeus)
+      end
+
+      it "leaves http status line out" do
+        headers = @conn.parse_response_headers("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n")
+        assert_equal %w(content-type), headers.keys
+      end
+
+      it "parses lower-cased header name and value" do
+        headers = @conn.parse_response_headers("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n")
+        assert_equal 'text/html', headers['content-type']
+      end
+
+      it "parses lower-cased header name and value with colon" do
+        headers = @conn.parse_response_headers("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nLocation: http://sushi.com/\r\n\r\n")
+        assert_equal 'http://sushi.com/', headers['location']
+      end
+    end
+  end
+end

data/test/adapter_test.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class AdapterTest < Faraday::TestCase
+  before do
+    @connection = Faraday::Connection.new(LIVE_SERVER)
+  end
+
+  Faraday::Adapter.loaded_adapters.each do |adapter|
+    describe "#get with #{adapter} adapter" do
+      before do
+        @connection.extend adapter
+      end
+
+      it "retrieves the response body" do
+        assert_equal 'hello world', @connection.get('hello_world').body
+      end
+
+      it "retrieves the response body with YajlResponse" do
+        @connection.response_class = Faraday::Response::YajlResponse
+        assert_equal [1,2,3], @connection.get('json').body
+      end
+
+      it "retrieves the response headers" do
+        assert_equal 'text/html', @connection.get('hello_world').headers['content-type']
+      end
+    end
+
+    describe "async requests" do
+      before do
+        @connection.extend adapter
+      end
+
+      it "clears parallel manager after running a single request" do
+        assert !@connection.in_parallel?
+        resp = @connection.get('hello_world')
+        assert !@connection.in_parallel?
+        assert_equal 'hello world', @connection.get('hello_world').body
+      end
+
+      it "uses parallel manager to run multiple json requests" do
+        resp1, resp2 = nil, nil
+
+        @connection.response_class = Faraday::Response::YajlResponse
+        @connection.in_parallel do
+          resp1 = @connection.get('json')
+          resp2 = @connection.get('json')
+          assert @connection.in_parallel?
+          if adapter.supports_async?
+            assert_nil resp1.body
+            assert_nil resp2.body
+          end
+        end
+        assert !@connection.in_parallel?
+        assert_equal [1,2,3], resp1.body
+        assert_equal [1,2,3], resp2.body
+      end
+    end
+  end
+end

data/test/connection_test.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class ConnectionTest < Faraday::TestCase
+  describe "#initialize" do
+    it "parses @host out of given url" do
+      conn = Faraday::Connection.new "http://sushi.com"
+      assert_equal 'sushi.com', conn.host
+    end
+
+    it "parses nil @port out of given url" do
+      conn = Faraday::Connection.new "http://sushi.com"
+      assert_nil conn.port
+    end
+
+    it "parses @scheme out of given url" do
+      conn = Faraday::Connection.new "http://sushi.com"
+      assert_equal 'http', conn.scheme
+    end
+
+    it "parses @port out of given url" do
+      conn = Faraday::Connection.new "http://sushi.com:815"
+      assert_equal 815, conn.port
+    end
+
+    it "parses nil @path_prefix out of given url" do
+      conn = Faraday::Connection.new "http://sushi.com"
+      assert_equal '/', conn.path_prefix
+    end
+
+    it "parses @path_prefix out of given url" do
+      conn = Faraday::Connection.new "http://sushi.com/fish"
+      assert_equal '/fish', conn.path_prefix
+    end
+  end
+
+  describe "#build_uri" do
+    it "uses Connection#host as default URI host" do
+      conn = Faraday::Connection.new
+      conn.host = 'sushi.com'
+      uri = conn.build_uri("/sake.html")
+      assert_equal 'sushi.com', uri.host
+    end
+
+    it "uses Connection#port as default URI port" do
+      conn = Faraday::Connection.new
+      conn.port = 23
+      uri = conn.build_uri("http://sushi.com")
+      assert_equal 23, uri.port
+    end
+
+    it "uses Connection#scheme as default URI scheme" do
+      conn = Faraday::Connection.new 'http://sushi.com'
+      uri = conn.build_uri("/sake.html")
+      assert_equal 'http', uri.scheme
+    end
+
+    it "uses Connection#path_prefix to customize the path" do
+      conn = Faraday::Connection.new
+      conn.path_prefix = '/fish'
+      uri = conn.build_uri("sake.html")
+      assert_equal '/fish/sake.html', uri.path
+    end
+
+    it "uses '/' Connection#path_prefix to customize the path" do
+      conn = Faraday::Connection.new
+      conn.path_prefix = '/'
+      uri = conn.build_uri("sake.html")
+      assert_equal '/sake.html', uri.path
+    end
+
+    it "forces Connection#path_prefix to be absolute" do
+      conn = Faraday::Connection.new
+      conn.path_prefix = 'fish'
+      uri = conn.build_uri("sake.html")
+      assert_equal '/fish/sake.html', uri.path
+    end
+
+    it "ignores Connection#path_prefix trailing slash" do
+      conn = Faraday::Connection.new
+      conn.path_prefix = '/fish/'
+      uri = conn.build_uri("sake.html")
+      assert_equal '/fish/sake.html', uri.path
+    end
+
+    it "allows absolute URI to ignore Connection#path_prefix" do
+      conn = Faraday::Connection.new
+      conn.path_prefix = '/fish'
+      uri = conn.build_uri("/sake.html")
+      assert_equal '/sake.html', uri.path
+    end
+
+    it "parses url/params into #path" do
+      conn = Faraday::Connection.new
+      uri = conn.build_uri("http://sushi.com/sake.html")
+      assert_equal '/sake.html', uri.path
+    end
+
+    it "parses url/params into #query" do
+      conn = Faraday::Connection.new
+      uri = conn.build_uri("http://sushi.com/sake.html", 'a[b]' => '1 + 2')
+      assert_equal "a%5Bb%5D=1%20%2B%202", uri.query
+    end
+
+    it "parses url into #host" do
+      conn = Faraday::Connection.new
+      uri = conn.build_uri("http://sushi.com/sake.html")
+      assert_equal "sushi.com", uri.host
+    end
+
+    it "parses url into #port" do
+      conn = Faraday::Connection.new
+      uri = conn.build_uri("http://sushi.com/sake.html")
+      assert_nil uri.port
+    end
+  end
+
+  describe "#params_to_query" do
+    it "converts hash of params to URI-escaped query string" do
+      conn = Faraday::Connection.new
+      assert_equal "a%5Bb%5D=1%20%2B%202", conn.params_to_query('a[b]' => '1 + 2')
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'context'
+if ENV['LEFTRIGHT']
+  require 'leftright'
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'faraday'
+
+module Faraday
+  class TestCase < Test::Unit::TestCase
+    LIVE_SERVER = 'http://localhost:4567'
+
+    class TestConnection < Faraday::Connection
+      include Faraday::Adapter::MockRequest
+    end
+  end
+end

data/test/live_server.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'sinatra'
+
+get '/hello_world' do
+  'hello world'
+end
+
+get '/json' do
+  "[1,2,3]"
+end

data/test/response_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class ResponseTest < Faraday::TestCase
+  describe "unloaded response class" do
+    it "is not allowed to be set" do
+      resp_class = Object.new
+      def resp_class.loaded?() false end
+      conn = Faraday::Connection.new
+      assert_raises ArgumentError do
+        conn.response_class = resp_class
+      end
+    end
+  end
+
+  describe "TestConnection#get with default Faraday::Response class" do
+    it "returns Faraday::Response" do
+      conn = TestConnection.new do |stub|
+        stub.get('/hello') { [200, {}, 'hello world']}
+      end
+      resp = conn.get('/hello')
+      assert_equal 'hello world', resp.body
+    end
+  end
+
+  describe "TestConnection#get with Faraday::YajlResponse class" do
+    it "returns string body" do
+      conn = TestConnection.new do |stub|
+        stub.get('/hello') { [200, {}, '[1,2,3]']}
+      end
+      conn.response_class = Faraday::Response::YajlResponse
+      assert_equal [1,2,3], conn.get('/hello').body
+    end
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: faraday
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- rick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-19 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: HTTP/REST API client library with pluggable components
+email: technoweenie@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- faraday.gemspec
+- lib/faraday.rb
+- lib/faraday/adapter/mock_request.rb
+- lib/faraday/adapter/net_http.rb
+- lib/faraday/adapter/typhoeus.rb
+- lib/faraday/connection.rb
+- lib/faraday/error.rb
+- lib/faraday/response.rb
+- lib/faraday/response/yajl_response.rb
+- test/adapter/typhoeus_test.rb
+- test/adapter_test.rb
+- test/connection_test.rb
+- test/helper.rb
+- test/live_server.rb
+- test/response_test.rb
+has_rdoc: true
+homepage: http://github.com/technoweenie/faraday
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: HTTP/REST API client library
+test_files: 
+- test/adapter/typhoeus_test.rb
+- test/adapter_test.rb
+- test/connection_test.rb
+- test/helper.rb
+- test/live_server.rb
+- test/response_test.rb