http_monkey 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+tags

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.8.7

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in http_monkey.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Roger Leite http://1up4dev.org
+
+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/Rakefile

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+ENV["RUBYOPT"] = "rubygems" if ENV["RUBYOPT"].nil?
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/http_monkey/*_test.rb']
+end
+
+Rake::TestTask.new("test:integration") do |t|
+  t.libs << "test"
+  t.pattern = "test/integration/*_test.rb"
+end
+
+desc "For Travis CI with love"
+task :ci => [:test, :"test:integration"]
+
+task :default => :ci

data/Readme.md

@@ -0,0 +1,173 @@
+# HTTP Monkey [![Build Status](https://secure.travis-ci.org/rogerleite/http_monkey.png?branch=master)](https://travis-ci.org/rogerleite/http_monkey)
+
+A fluent interface to do HTTP calls, free of fat dependencies and at same time, powered by middlewares rack.
+
+It's an awesome client with an awful name.
+
+## Light and powerful
+
+``` ruby
+    # Works with Entry Point concept
+    response = HttpMonkey.at("http://google.com").get
+    response = HttpMonkey.at("http://google.com").post(:q => "Http Monkey!")
+    puts response.body  # More info about response at http://httpirb.com/#responses
+
+    ## Headers
+    HttpMonket.at("http://google.com").
+      with_header("Content-Type" => "text/html").
+      with_header("X-Custom" => "sample").
+      get
+
+    ## Cookies
+    HttpMonkey.at("http://google.com").set_cookie("blah").get
+
+    ## Basic Authentication
+    HttpMonkey.at("http://user:pass@google.com").get
+    HttpMonkey.at("http://google.com").
+      basic_auth("user", "pass").
+      get
+
+    ## Request Internals (yields HTTPI::Request, to set your obscure desires)
+    HttpMonkey.at("http://google.com").yield_request do |req|
+      req.proxy = "http://proxy.com"
+      req.open_timeout = 30
+      req.read_timeout = 15
+    end.get
+
+    # SSL
+    HttpMonkey.at("http://google.com").yield_request do |req|
+      req.auth.ssl.cert_key_file     = "client_key.pem"   # the private key file to use
+      req.auth.ssl.cert_key_password = "C3rtP@ssw0rd"     # the key file's password
+      req.auth.ssl.cert_file         = "client_cert.pem"  # the certificate file to use
+      req.auth.ssl.ca_cert_file      = "ca_cert.pem"      # the ca certificate file to use
+      req.auth.ssl.verify_mode       = :none              # or one of [:peer, :fail_if_no_peer_cert, :client_once]
+      req.auth.ssl.ssl_version       = :TLSv1             # or one of [:SSLv2, :SSLv3]
+    end.get
+
+    # Default HTTP Headers (to all requests)
+    HttpMonkey.configure do
+      middlewares.use HttpMonkey::Middlewares::DefaultHeaders, {"Content-Type" => "application/json"}
+    end
+```
+
+## Flexibility
+
+You can configure the default or build your own client and define how it should behave.
+
+You can also define net adapter, behaviours and middlewares by request.
+
+``` ruby
+    # Changing default client
+    HttpMonkey.configure do
+      net_adapter :curb
+      behaviours.on(500) do |client, request, response|
+        raise "Server side error :X"
+      end
+    end
+
+    # Works with status code callbacks (here known as behaviours)
+    chimp = HttpMonkey.build do
+      behaviours do
+        # 2xx range
+        on(200..299) do |client, request, response|
+          response
+        end
+        # Redirects
+        on([301, 302]) do |client, request, response|
+          raise "Redirect error"
+        end
+      end
+    end
+
+    chimp.at("http://google.com").get  # raises Redirect error
+
+    # by request
+    chimp.at("http://google.com").get do
+      behaviours.on(200) do |client, request, response|
+        raise "ok" # only for this request
+      end
+    end
+```
+
+## Choose your HTTP client
+
+Thanks to [HTTPI](http://httpirb.com/), you can choose different HTTP clients:
+
+* [HTTPClient](http://rubygems.org/gems/httpclient)
+* [Curb](http://rubygems.org/gems/curb)
+* [Net::HTTP](http://ruby-doc.org/stdlib/libdoc/net/http/rdoc)
+
+*Important*: If you want to use anything other than Net::HTTP, you need to manually require the library or make sure it’s available in your load path.
+
+``` ruby
+    # When you build your own client, you can define which Http client to use.
+    chimp = HttpMonkey.build do
+      # HTTP clients available [:httpclient, :curb, :net_http]
+      net_adapter :curb  # default :net_http
+      # [...]
+    end
+
+    # You can also change you net_adapter by request
+    chimp.at("http://google.com").get do
+      # only on this request, use :httpclient
+      net_adapter :httpclient
+      # [...]
+    end
+```
+
+## More power to the people (for God sake!)
+
+Easy to extend, using the power of Rack middleware interface.
+
+``` ruby
+
+    class Logger
+      def initialize(app)
+        @app = app
+      end
+      def call(env)
+        puts "-> before #{env.inspect} #{Time.now.inspect}"
+        result = @app.call(env)
+        puts "-> after #{env.inspect} #{Time.now.inspect}"
+        result
+      end
+    end
+
+    # Add custom middlewares to default stack
+    HttpMonkey.configure do
+      middlewares do
+        use Logger
+      end
+    end
+    # Now all requests uses Logger
+    response = HttpMonkey.at("http://google.com").get
+
+    # or when you build your own client
+    chimp = HttpMonkey.build do
+      middlewares do
+        use Logger
+      end
+    end
+
+    # or by request
+    chimp.at("http://google.com").get do
+      middlewares.use Logger
+      # [...]
+    end
+```
+
+Some ideas:
+
+* Cache? [rack-cache](https://github.com/rtomayko/rack-cache)
+* Logger? [http://rack.rubyforge.org/doc/Rack/Logger.html]
+* Profile?
+* Support to specific Media Type?
+
+## Easy to contribute
+
+Suggestions, bugs and pull requests, here at [github.com/rogerleite/http_monkey](http://github.com/rogerleite/http_monkey).
+`bundle install`, `rake test` and be happy!
+
+## License
+
+HTTP Monkey is copyright 2012 Roger Leite and contributors. It is licensed under the MIT license. See the include LICENSE file for details.

data/http_monkey.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'http_monkey/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "http_monkey"
+  gem.version       = HttpMonkey::VERSION
+  gem.authors       = ["Roger Leite"]
+  gem.email         = ["roger.barreto@gmail.com"]
+  gem.description   = %q{A fluent interface to do HTTP calls, free of fat dependencies and at same time, powered by middlewares rack.}
+  gem.summary       = %q{A fluent interface to do HTTP calls, free of fat dependencies and at same time, powered by middlewares rack.}
+  gem.homepage      = "https://github.com/rogerleite/http_monkey"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency "rack"
+  gem.add_runtime_dependency "httpi", "~> 1.1"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "minitest", "~> 3"
+  gem.add_development_dependency "minitest-reporters", "~> 0.7.0"
+  gem.add_development_dependency "mocha"
+end

data/lib/http_monkey/client/environment.rb

@@ -0,0 +1,30 @@
+module HttpMonkey
+
+  # Rack environment with helpers.
+  class Client::Environment
+
+    def initialize(env)
+      @env = env
+    end
+
+    def [](key)
+      @env[key]
+    end
+
+    def []=(key, value)
+      @env[key] = value
+    end
+
+    # From {"HTTP_CONTENT_TYPE" => "text/html"} to {"Content-Type" => "text/html"}
+    def http_headers
+      req_headers = @env.reject {|k,v| !k.start_with? "HTTP_" }
+      normalized = req_headers.map do |key, value|
+        new_key = key.sub("HTTP_",'').split('_').map(&:capitalize).join('-')
+        [new_key, value]
+      end
+      Hash[normalized]
+    end
+
+  end
+
+end

data/lib/http_monkey/client/environment_builder.rb

@@ -0,0 +1,70 @@
+module HttpMonkey
+
+  # Great inspiration from https://github.com/rack/rack/blob/master/lib/rack/mock.rb,
+  # specially from Rack::MockRequest
+  class Client::EnvironmentBuilder
+
+    DEFAULT_ENV = {
+      "rack.version" => Rack::VERSION,
+      "rack.input" => nil,
+      "rack.errors" => STDERR,
+      "rack.multithread" => true,
+      "rack.multiprocess" => false,
+      "rack.run_once" => false,
+    }
+
+    def initialize(client, method, request)
+      @client = client
+      @method = method
+      @request = request
+    end
+
+    def to_env
+      uri = @request.url
+      rack_input = normalize_body(@request.body)
+
+      env = DEFAULT_ENV.dup
+      env = env.merge({
+        # request info
+        'REQUEST_METHOD'  => @method.to_s.upcase,
+        'SERVER_NAME'     => uri.host,
+        'SERVER_PORT'     => (uri.port || uri.inferred_port).to_s,
+        'QUERY_STRING'    => uri.query || "",
+        'PATH_INFO'       => (!uri.path || uri.path.empty?) ? "/" : uri.path,
+        'rack.url_scheme' => uri.scheme,
+        'HTTPS'           => (uri.scheme == "https" ? "on" : "off"),
+        'SCRIPT_NAME'     => "", # call me Suzy
+
+        'REQUEST_URI'     => uri.request_uri,
+        'HTTP_HOST'       => uri.host,
+        'rack.input'      => rack_input,
+        'CONTENT_LENGTH'  => rack_input.length.to_s,
+
+        # custom info
+        'http_monkey.request' => [@method, @request, @client.net_adapter]
+      }).update(http_headers)
+      env
+    end
+
+    # From {"Content-Type" => "text/html"} to {"HTTP_CONTENT_TYPE" => "text/html"}
+    def http_headers
+      env_headers = @request.headers.map do |key, value|
+        ["HTTP_#{key.to_s.upcase.gsub("-", "_")}", value]
+      end
+      Hash[env_headers]
+    end
+
+    def normalize_body(body)
+      return "" if body.nil?
+      input = body.dup
+      input.force_encoding("ASCII-8BIT") if input.respond_to?(:force_encoding)
+      # TODO: search about setting encoding binary
+      #input = StringIO.new(input) if input.is_a?(String)
+      #input.set_encoding(Encoding::BINARY) if input.respond_to?(:set_encoding)
+      #input = input.string if input.respond_to?(:string)
+      input
+    end
+
+  end
+
+end

data/lib/http_monkey/client/http_request.rb

@@ -0,0 +1,20 @@
+module HttpMonkey
+
+  # Main App middleware
+  # Responsible to make HTTP request
+  class Client::HttpRequest
+
+    def self.call(env)
+      env = Client::Environment.new(env)
+      method, request, net_adapter = env['http_monkey.request']
+
+      request.headers = env.http_headers
+      request.body = env['rack.input']
+
+      response = HTTPI.request(method, request, net_adapter)
+      [response.code, response.headers, response.body]
+    end
+
+  end
+
+end

data/lib/http_monkey/client.rb

@@ -0,0 +1,43 @@
+module HttpMonkey
+
+  class Client
+
+    def initialize
+      @conf = Configuration.new
+    end
+
+    def initialize_copy(source)
+      super
+      @conf = @conf.clone
+    end
+
+    def at(url)
+      HttpMonkey::EntryPoint.new(self, url)
+    end
+
+    def net_adapter
+      @conf.net_adapter
+    end
+
+    def configure(&block)
+      @conf.instance_eval(&block) if block_given?
+      self
+    end
+
+    def http_request(method, request)
+      env = Client::EnvironmentBuilder.new(self, method, request).to_env
+      code, headers, body = @conf.middlewares.execute(Client::HttpRequest, env)
+      body.close if body.respond_to?(:close)  # close when is a Rack::BodyProxy
+      response = HTTPI::Response.new(code, headers, body)
+
+      if (behaviour = @conf.behaviours.find(response.code))
+        behaviour.call(self, request, response)
+      else
+        unknown_behaviour = @conf.behaviours.unknown_behaviour
+        unknown_behaviour.call(self, request, response) if unknown_behaviour.respond_to?(:call)
+      end
+    end
+
+  end
+
+end

data/lib/http_monkey/configuration/behaviours.rb

@@ -0,0 +1,49 @@
+module HttpMonkey
+
+  class Configuration::Behaviours
+
+    attr_reader :unknown_behaviour
+
+    def initialize
+      self.clear!
+    end
+
+    def initialize_copy(source)
+      super
+      @behaviours = @behaviours.clone
+      @behaviours_range = @behaviours_range.clone
+    end
+
+    def clear!
+      @behaviours = {}
+      @behaviours_range = {}
+      @unknown_behaviour = nil
+      nil
+    end
+
+    def on(code, &block)
+      if code.is_a?(Integer)
+        @behaviours[code] = block
+      elsif code.respond_to?(:include?)
+        @behaviours_range[code] = block
+      end
+      nil
+    end
+
+    def on_unknown(&block)
+      @unknown_behaviour = block
+    end
+
+    def find(code)
+      behaviour = @behaviours[code]
+      if behaviour.nil?
+        _, behaviour = @behaviours_range.detect do |range, proc|
+          range.include?(code)
+        end
+      end
+      behaviour
+    end
+
+  end
+
+end

data/lib/http_monkey/configuration/middlewares.rb

@@ -0,0 +1,29 @@
+module HttpMonkey
+
+  # Heavily inspired on Rack::Builder (http://rack.rubyforge.org/doc/Rack/Builder.html)
+  class Configuration::Middlewares
+
+    def initialize
+      @chain = []
+    end
+
+    def initialize_copy(source)
+      super
+      @chain = @chain.clone
+    end
+
+    def use(middleware, *args, &block)
+      @chain << lambda { |app| middleware.new(app, *args, &block) }
+      self
+    end
+
+    def execute(app, env)
+      stacked_middleware = @chain.reverse.inject(app) do |app, middle|
+        middle.call(app)
+      end
+      stacked_middleware.call(env)
+    end
+
+  end
+
+end

data/lib/http_monkey/configuration.rb

@@ -0,0 +1,36 @@
+module HttpMonkey
+
+  class Configuration
+
+    def initialize
+      net_adapter(:net_http)  #default adapter
+      @behaviours = HttpMonkey::Configuration::Behaviours.new
+      # behaviour default always return response
+      @behaviours.on_unknown { |client, req, response| response }
+      @middlewares = HttpMonkey::Configuration::Middlewares.new
+    end
+
+    def initialize_copy(source)
+      super
+      @behaviours = @behaviours.clone
+      @middlewares = @middlewares.clone
+    end
+
+    def net_adapter(adapter = nil)
+      @net_adapter = adapter unless adapter.nil?
+      @net_adapter
+    end
+
+    def behaviours(&block)
+      @behaviours.instance_eval(&block) if block_given?
+      @behaviours
+    end
+
+    def middlewares(&block)
+      @middlewares.instance_eval(&block) if block_given?
+      @middlewares
+    end
+
+  end
+
+end

data/lib/http_monkey/entry_point.rb

@@ -0,0 +1,88 @@
+require "forwardable"
+
+module HttpMonkey
+
+  module EntryPointFluentInterface
+
+    def with_header(header)
+      @request.headers.update(header)
+      self
+    end
+    alias :with_headers :with_header
+
+    def set_cookie(cookie)
+      @request.headers["Cookie"] = cookie if cookie
+      self
+    end
+    alias :set_cookies :set_cookie
+
+    def basic_auth(user, pass)
+      @request.auth.basic(user, pass)
+      self
+    end
+
+    def digest_auth(user, pass)
+      @request.auth.digest(user, pass)
+      self
+    end
+
+    # Yields internal HTTPI::Request
+    def yield_request
+      yield(@request) if block_given?
+      self
+    end
+
+  end
+
+  class EntryPoint
+
+    def initialize(client, url)
+      @client = client
+      @request = HTTPI::Request.new(url)
+    end
+
+    def _request
+      @request
+    end
+
+    include EntryPointFluentInterface
+
+    def get(query_param = nil, &block)
+      # pending pull request to httpi support @request.query=
+      if query_param.kind_of?(Hash)
+        query_param = Rack::Utils.build_query(query_param)
+      end
+      query_param = query_param.to_s unless query_param.is_a?(String)
+      @request.url.query = query_param unless query_param.empty?
+
+      capture_client(&block).http_request(:get, @request)
+    end
+
+    def post(body_param, &block)
+      @request.body = body_param
+      capture_client(&block).http_request(:post, @request)
+    end
+
+    def put(body_param, &block)
+      @request.body = body_param
+      capture_client(&block).http_request(:put, @request)
+    end
+
+    def delete(&block)
+      capture_client(&block).http_request(:delete, @request)
+    end
+
+    protected
+
+    # If block given, clones actual client and uses
+    # the block as configuration
+    def capture_client(&block)
+      if block_given?
+        @client.clone.configure(&block)
+      else
+        @client
+      end
+    end
+  end
+
+end

data/lib/http_monkey/middlewares/default_headers.rb

@@ -0,0 +1,26 @@
+module HttpMonkey::Middlewares
+
+  # Allow to set default HTTP headers to all requests
+  #
+  # Examples
+  #
+  #   use HttpMonkey::Middlewares::DefaultHeaders, {"Content-Type" => "text/html",
+  #                                                 "X-Custom" => "custom"}
+  class DefaultHeaders
+
+    def initialize(app, headers = {})
+      @app = app
+      @headers = headers
+    end
+
+    def call(env)
+      @headers.each do |header, value|
+        http_header = "HTTP_#{header.to_s.upcase.gsub("-", "_")}"
+        env[http_header] = value unless env.key?(http_header)
+      end
+      @app.call(env)
+    end
+
+  end
+
+end

data/lib/http_monkey/middlewares.rb

@@ -0,0 +1,5 @@
+module HttpMonkey
+  module Middlewares
+    autoload :DefaultHeaders, "http_monkey/middlewares/default_headers"
+  end
+end

data/lib/http_monkey/version.rb

@@ -0,0 +1,3 @@
+module HttpMonkey
+  VERSION = "0.0.1"
+end