alice 0.1.0

data/.document

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

data/.gitignore

@@ -0,0 +1,6 @@
+## 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,76 @@
+= alice
+
+Use a Rack app as an HTTP client library.  This is another exploration in the 
+same vein as Faraday: http://github.com/technoweenie/faraday
+
+Let me think: was I the same when I got up this morning? I almost think I can 
+remember feeling a little different. But if I'm not the same, the next 
+question is, Who in the world am I?
+
+== Usage
+
+  conn = Alice::Connection.new(:url => 'http://sushi.com') do
+    use Alice::Request::Yajl     # convert body to json with Yajl lib
+    use Alice::Adapter::Logger   # log the request somewhere?
+    use Alice::Adapter::Typhoeus # make http request with typhoeus
+    use Alice::Response::Yajl    # # parse body with yajl
+
+    # or use shortcuts
+    request  :yajl     # Alice::Request::Yajl
+    adapter  :logger   # Alice::Adapter::Logger
+    adapter  :typhoeus # Alice::Adapter::Typhoeus
+    response :yajl     # Alice::Response::Yajl
+  end
+
+  resp1 = conn.get '/nigiri/sake.json'
+  resp2 = conn.post do |req|
+    req.url  "/nigiri.json", :page => 2
+    req[:content_type] = 'application/json'
+    req.body = {:name => 'Unagi'}
+  end
+
+== Testing
+
+  test = Alice::Connection.new do
+    adapter :test do |stub|
+      stub.get '/nigiri/sake.json' do
+        [200, {}, 'hi world']
+      end
+    end
+  end
+
+  resp = test.get '/nigiri/sake.json'
+  resp.body # => 'hi world'
+
+== 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.
+
+== Running Tests
+
+* Yajl is needed for tests :(
+* Pass a LIVE env var to run it against a live server.
+
+  > ruby test/live_server.rb         # start the server
+  > rake                             # no live tests
+  > LIVE=1 rake                      # run with http://localhost:4567
+  > LIVE=http://foobar.dev:4567 rake # run with http://foobar.dev:4567
+
+== TODO
+
+* Add curb/em-http support
+* Add xml parsing
+* Support timeouts, proxy servers, ssl options
+* Add streaming requests and responses
+* Add default middleware load out for common cases
+* Add symbol => string index for mime types (:json => 'application/json')
+
+== Copyright
+
+Copyright (c) 2010 rick. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "alice"
+    gem.summary = %Q{HTTP/REST API client library using Rack-like middleware}
+    gem.description = %Q{HTTP/REST API client library using Rack-like middleware}
+    gem.email = "technoweenie@gmail.com"
+    gem.homepage = "http://github.com/technoweenie/alice"
+    gem.authors = ["rick"]
+    gem.add_dependency "rack"
+    gem.add_dependency "addressable"
+  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 = "alice #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/alice.rb

@@ -0,0 +1,76 @@
+require 'rack/utils'
+
+module Alice
+  module AutoloadHelper
+    def register_lookup_modules(mods)
+      (@lookup_module_index ||= {}).update(mods)
+    end
+
+    def lookup_module(key)
+      return if !@lookup_module_index
+      const_get @lookup_module_index[key] || key
+    end
+
+    def autoload_all(prefix, options)
+      options.each do |const_name, path|
+        autoload const_name, File.join(prefix, path)
+      end
+    end
+
+    # Loads each autoloaded constant.  If thread safety is a concern, wrap
+    # this in a Mutex.
+    def load_autoloaded_constants
+      constants.each do |const|
+        const_get(const) if autoload?(const)
+      end
+    end
+
+    def all_loaded_constants
+      constants.map { |c| const_get(c) }.select { |a| a.loaded? }
+    end
+  end
+
+  extend AutoloadHelper
+
+  autoload_all 'alice', 
+    :Connection => 'connection',
+    :Middleware => 'middleware',
+    :Builder    => 'builder',
+    :Request    => 'request',
+    :Response   => 'response',
+    :Error      => 'error'
+
+  module Adapter
+    extend AutoloadHelper
+    autoload_all 'alice/adapter',
+      :NetHttp  => 'net_http',
+      :Typhoeus => 'typhoeus',
+      :Patron   => 'patron',
+      :Test     => 'test'
+
+    register_lookup_modules \
+      :test     => :Test,
+      :net_http => :NetHttp,
+      :typhoeus => :Typhoeus,
+      :patron   => :patron,
+      :net_http => :NetHttp
+  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/alice/adapter/net_http.rb

@@ -0,0 +1,30 @@
+require 'net/http'
+module Alice
+  module Adapter
+    class NetHttp < Middleware
+      def call(env)
+        process_body_for_request(env)
+
+        http      = Net::HTTP.new(env[:url].host, env[:url].port)
+        full_path = full_path_for(env[:url].path, env[:url].query, env[:url].fragment)
+        http_resp = http.send_request(env[:method].to_s.upcase, full_path, env[:body], env[:request_headers])
+
+        raise Error::ResourceNotFound if http_resp.code == '404'
+
+        resp_headers = {}
+        http_resp.each_header do |key, value|
+          resp_headers[key] = value
+        end
+
+        env.update \
+          :status           => http_resp.code.to_i, 
+          :response_headers => resp_headers, 
+          :body             => http_resp.body
+
+        @app.call env
+      rescue Errno::ECONNREFUSED
+        raise Error::ConnectionFailed, "connection refused"
+      end
+    end
+  end
+end

data/lib/alice/adapter/patron.rb

@@ -0,0 +1,35 @@
+module Alice
+  module Adapter
+    class Patron < Middleware
+      begin
+        require 'patron'
+      rescue LoadError => e
+        self.load_error = e
+      end
+
+      def call(env)
+        process_body_for_request(env)
+
+        sess = ::Patron::Session.new
+        args = [env[:method], env[:url].to_s, env[:request_headers]]
+        if Alice::Connection::METHODS_WITH_BODIES.include?(env[:method])
+          args.insert(2, env[:body].to_s)
+        end
+        resp = sess.send *args
+
+        raise Alice::Error::ResourceNotFound if resp.status == 404
+
+        env.update \
+          :status           => resp.status,
+          :response_headers => resp.headers.
+            inject({}) { |memo, (k, v)| memo.update(k.downcase => v) },
+          :body             => resp.body
+        env[:response].finish(env)
+
+        @app.call env
+      rescue Errno::ECONNREFUSED
+        raise Error::ConnectionFailed, "connection refused"
+      end
+    end
+  end
+end

data/lib/alice/adapter/test.rb

@@ -0,0 +1,94 @@
+module Alice
+  module Adapter
+    # test = Alice::Connection.new do
+    #   use Alice::Adapter::Test do |stub|
+    #     stub.get '/nigiri/sake.json' do
+    #       [200, {}, 'hi world']
+    #     end
+    #   end
+    # end
+    # 
+    # resp = test.get '/nigiri/sake.json'
+    # resp.body # => 'hi world'
+    #
+    class Test < Middleware
+      def self.loaded?() false end
+
+      class Stubs
+        def initialize
+          # {:get => [Stub, Stub]}
+          @stack = {}
+          yield self if block_given?
+        end
+
+        def empty?
+          @stack.empty?
+        end
+
+        def match(request_method, path)
+          return false if !@stack.key?(request_method)
+          @stack[request_method].detect { |stub| stub.matches?(path) }
+        end
+
+        def get(path, &block)
+          new_stub(:get, path, block)
+        end
+
+        def head(path, &block)
+          new_stub(:head, path, block)
+        end
+
+        def post(path, &block)
+          new_stub(:post, path, block)
+        end
+
+        def put(path, &block)
+          new_stub(:put, path, block)
+        end
+
+        def delete(path, &block)
+          new_stub(:delete, path, block)
+        end
+
+        def new_stub(request_method, path, block)
+          (@stack[request_method] ||= []) << Stub.new(path, block)
+        end
+      end
+
+      class Stub < Struct.new(:path, :block)
+        def matches?(request_path)
+          request_path == path
+        end
+      end
+
+      def initialize app, &block
+        super(app)
+        configure(&block) if block
+      end
+
+      def configure
+        yield stubs
+      end
+
+      def stubs
+        @stubs ||= Stubs.new
+      end
+
+      def call(env)
+        if stub = stubs.match(env[:method], env[:url].path)
+          status, headers, body = stub.block.call(env)
+          env.update \
+            :status           => status,
+            :response_headers => headers,
+            :body             => body
+        else
+          env.update \
+            :status           => 404,
+            :response_headers => {},
+            :body             => 'no stubbed requests'
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/alice/adapter/typhoeus.rb

@@ -0,0 +1,61 @@
+module Alice
+  module Adapter
+    class Typhoeus < Middleware
+      self.supports_parallel_requests = true
+
+      def self.setup_parallel_manager(options = {})
+        options.empty? ? ::Typhoeus::Hydra.hydra : ::Typhoeus::Hydra.new(options)
+      end
+
+      begin
+        require 'typhoeus'
+      rescue LoadError => e
+        self.load_error = e
+      end
+
+      def call(env)
+        process_body_for_request(env)
+
+        hydra = env[:parallel_manager] || self.class.setup_parallel_manager
+        req   = ::Typhoeus::Request.new env[:url].to_s, 
+          :method  => env[:method],
+          :body    => env[:body],
+          :headers => env[:request_headers]
+
+        req.on_complete do |resp|
+          raise Alice::Error::ResourceNotFound if resp.code == 404
+          env.update \
+            :status           => resp.code,
+            :response_headers => parse_response_headers(resp.headers),
+            :body             => resp.body
+          env[:response].finish(env)
+        end
+
+        hydra.queue req
+
+        if !env[:parallel_manager]
+          hydra.run
+        end
+
+        @app.call env
+      rescue Errno::ECONNREFUSED
+        raise Error::ConnectionFailed, "connection refused"
+      end
+
+      def in_parallel(options = {})
+        @hydra = ::Typhoeus::Hydra.new(options)
+        yield
+        @hydra.run
+        @hydra = nil
+      end
+
+      def parse_response_headers(header_string)
+        return {} unless header_string && !header_string.empty?
+        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
+    end
+  end
+end