commute 0.1.2

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in commute.gemspec
+gemspec
+
+# Partially solves https://github.com/typhoeus/typhoeus/pull/171.
+gem 'typhoeus', :git => 'https://github.com/challengee/typhoeus.git'

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'minitest' do
+  watch(%r|^spec/(.*)_spec\.rb|)
+  watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r|^spec/spec_helper\.rb|)    { "spec" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Mattias Putman
+
+MIT License
+
+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.md

@@ -0,0 +1,262 @@
+# Commute 
+[![Build Status](https://secure.travis-ci.org/challengee/commute.png)](http://travis-ci.org/challengee/commute)
+[![Dependency Status](https://gemnasium.com/challengee/commute.png?travis)](https://gemnasium.com/challengee/commute)
+
+Commute helps you to:
+
+* Dynamically build HTTP requests for your favorite HTTP library (currently only Typhoeus).
+* Easily process request and response bodies.
+* Execute parallel HTTP requests.
+
+## Contexts and Api's
+
+Almost everything in Commute is a context. Contexts represent all the information that Commute needs to build, execute and process your requests. This includes:
+
+* **Request options**: url, body, url params, headers, ....
+* **Custom options**: custom named parameters that can be translated in request options.
+* **Stack options**: used to provide information on how request/response bodies are processed.
+* **A Stack**: A sequence of layers that a request/response body is pushed through to be processed (these layers user the stack options).
+* A reference to an **Api** that is responsible for executing the request.
+
+Api's are nothing more than a set of predefined, named contexts. If you think about it, options and stack layers needed for certain Api calls can be seen as an extension as a context. So these named contexts (aka Api calls) take a context and extend it with the needed information.
+
+## Stacks
+
+Stacks are responsible for processing request and response bodies. A stack consists of a request and response `sequence`. The response sequence is generally the inverse of the request sequence.
+
+A sequence consists of an ordered list of layers. Each layer provides some logic to transform a body according to some options. For example a chemicals layer could parse or render an xml document based on a given template. This would look like this:
+
+```ruby
+class Chemicals < Layer
+  def request body, template
+    template.render body
+  end
+
+  def response body, template
+    template.parse body
+  end
+end
+```
+
+When a context is built into a request. The body is ran through the request sequence. When the request is completed, the response body is ran through the response sequence.
+
+## Building Contexts
+
+### Extending Contexts 101
+
+Commute is all about building partial contexts and extending them until enough information is present to build a real HTTP request. Basically it works like this:
+
+```ruby
+# Assume there is an Api "GistApi".
+# This would create a context containing a custom option 'user'
+#   and then one with a context-type header.
+defunkt_api = GistApi.with(user: 'defunkt')
+defunkt_xml_api = defunkt_api.with(headers: {
+  'Content-Type' => 'application/xml'
+})
+```
+
+Any further context extensions or api calls on `defunkt_xml_api` would thus be in xml and for the user 'defunkt'.
+
+For example, you could take an vanilla api, extend it to a context that contains needed authentication parameters, and pass that context through your app acting as an api that does not need authentication. Here lies the power of commute: A context will act as an api with some predefined options and behavior.
+
+### Default and raw contexts
+
+Without you knowing, `GistApi.with` extended a special context of the `GistApi` called the `default` context. It contains options that every requests for this api will be needing. When you don't want this you can use the `raw` context.
+
+Example:
+
+```ruby
+class GistApi < Commute::Api
+  def default
+    # Extends the raw context with some options.
+    # Every request/response will be json.
+    raw.with headers: {
+      'Content-Type' => 'application/json',
+      'Accept' => 'application/json'
+    }
+  end
+end
+
+defunkt = GistApi.with(user: 'defunkt')
+defunkt.options.inspect
+# => { user: 'defunkt', headers: {
+  'Content-Type' => 'application/json',
+  'Accept' => 'application/json'
+}}
+```
+
+### Making basic Api calls
+
+Let's say we want to create an Api call that fetches all gists for a certain user. This call would extend the context by using the custom `:user` option and putting it in the url.
+
+```ruby
+class GistApi < Commute::Api
+  def default
+    # Extends the raw context with some options.
+    # Every request/response will be json.
+    raw.with headers: {
+      'Content-Type' => 'application/json',
+      'Accept' => 'application/json'
+    }
+  end
+
+  def for_user context
+    context.with url: "https://api.github.com/users/#{context[:user]}/gists"
+  end
+end
+
+# A context for getting all gists from defunkt.
+gists = GistApi.for_user user: 'defunkt'
+
+# or, you can play with it. See the potential?
+gists = GistApi.with(user: 'defunkt').for_user
+```
+
+Internally, those last two methods of creating the gists context are the same. When calling an api method from a context, passed arguments are used to create a context to be passed to the api call. That is why the argument of an api call is always `context`. The first method is only a convenient shortcut.
+
+### A basic stack
+
+If we would want to parse and encode json for every request and response we could create a layer like this:
+
+```ruby
+class Json < Commute::Layer
+  # Enode on request.
+  def request body, options
+    Yajl::Encoder.encode body, options
+  end
+
+  # Decode on response.
+  def response body, options
+    Yajl::Parser.parse body, options
+  end
+end
+```
+
+And use it in our default context:
+
+```ruby
+def default
+  # Extends the raw context with some options.
+  # Every request/response will be json.
+  raw.with headers: {
+    'Content-Type' => 'application/json',
+    'Accept' => 'application/json'
+  } do |stack|
+    stack << Json.new(:format)
+  end
+end
+```
+
+When adding a layer to a stack, you can give it a name. This can then later be used in stack altering or as a reference to pass options to the stack.
+
+### Extending Contexts 201
+
+We only showed simple context extending using some extra parameters. As said, contexts also define behavior (How does a request/response body have to be processed?) using stacks.
+
+On extending a context, the stack can be altered.
+
+Lat's say that in the basic stack, we want to send raw json, but we still want the stack to automatically parse json for the response. We could create a new context that does this:
+
+```ruby
+raw_requests = GistApi.with { |stack|
+  # Dump the format layer in the request sequence.
+  stack.request.without! :format
+}
+```
+
+Other stack altering methods are:
+
+* `before!`: inserts a layer before a certain named layer.
+* `after!`: inserts a layer after a certain named layer.
+
+### Passing options to the stack
+
+Naming layers has the advantage that they can be used to pass options to the layer. In the case of the `Json` layer, we could pass options to `yajl`:
+
+```ruby
+symbolized_api = GistApi.with(format: {
+  symbolize_keys: true
+})
+
+# Now all further extensions will return bodies with symbolized keys.
+```
+
+### Authorization
+
+A authorization mechanism can be implemented for an api by implementing the `authorize(context)` method. This does not follow the standard context system because Authorization headers can be time sensitive. The Authorization header is computed just before the requests is actually fired.
+
+### Hooks
+
+Commute provides a before (default) and after hook. They can be used to set up default context options/behavior or finishing up a context before it can be built.
+
+We already showed how to provide `default` contexts. The after hook can be provided by implementing `after(context)`.
+
+## Building requests and executing them.
+
+We now know how to build a context, it's time to turn those contexts into requests and firing them onto the internets.
+
+### Building requests.
+
+When you build a request from a context, you receive a pure `Typhoeus::Request`. You can do with it what you want, the context system just acts as a builder solution. You can pass a block to the build method that gets called when the request completes. This block gets called with:
+
+* The pure `Typhoeus::Response` as it was received from typhoeus.
+* A transformed response body (went through the stack).
+
+For example:
+
+```ruby
+request = GistApi.for_user(user: 'defunkt').build do |response, gists|
+  puts gists.count
+end
+```
+
+### Executing requests
+
+Executing requests is done through the `rush` method on a context. It executes the given request, runs the response through the stack and call the callback block.
+
+Building on the previous example that would go like this:
+
+```ruby
+GistApi.rush request
+# => 10
+```
+
+Remember that `GistApi.rush` calls the rush method on the `default` context. It would be the same as calling:
+
+```ruby
+GistApi.default.rush request
+```
+
+The `rush` method can be called on every context, it will be router to the underlaying Api.
+
+### Queueing requests for parallel execution
+
+Using the `commute` method you can queue requests for later execution. It simply works like this (Let's add some coolness for fun):
+
+```ruby
+# Define a callback.
+callback = Proc.new { |response, gists|
+  puts gists.count
+}
+# Build and queue some requests.
+['defunkt', 'challengee'].map { |user|
+  GistApi.commute GistApi.for_user(user: user).build
+}
+# Execute all requests in parallel
+GistApi.rush
+# => 10
+# => 0
+```
+
+### Error handling
+
+Commute does not provide any help with handling errors. This is done purely through the underlaying HTTP client that is used (here Typhoeus).
+
+In the callback one can for example check if the requests has timed out by issueing `response.timed_out?`.
+
+## What's next?
+
+* I would like an "adapter" system so that `Typhoeus` would just be an adapter.
+* Adding support for `em-http-request`.
+* Caching support (As a special adapter?).

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs = ['lib', 'spec']
+  t.test_files = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec

data/commute.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/commute/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.authors       = ["Mattias Putman"]
+  s.email         = ["mattias.putman@gmail.com"]
+  s.description   = %q{Handling the HTTP commute like a boss}
+  s.summary       = %q{Commute helps you to: 1) Dynamically build HTTP requests for your favorite HTTP library (currently only Typhoeus). 2) Easily process request and response bodies. 3) Execute parallel HTTP requests.}
+  s.homepage      = "http://challengee.github.com/commute/"
+
+  s.files         = `git ls-files`.split($\)
+  s.test_files    = s.files.grep(%r{^(spec)/})
+  s.name          = "commute"
+  s.require_paths = ["lib"]
+  s.version       = Commute::VERSION
+
+  s.add_dependency 'typhoeus'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'guard-minitest'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'webmock'
+
+  # For the examples.
+  s.add_development_dependency 'yajl-ruby'
+end

data/lib/commute/adapters/typhoeus.rb

@@ -0,0 +1,13 @@
+module Commute
+  module Typhoeus
+
+    class ContextualRequest < ::Typhoeus::Request
+      attr_reader :context
+
+      def initialize context, url, options = {}
+        @context = context
+        super(url, options)
+      end
+    end
+  end
+end

data/lib/commute/api.rb

@@ -0,0 +1,86 @@
+require 'singleton'
+require 'forwardable'
+
+require 'typhoeus'
+
+require 'commute/context'
+
+module Commute
+
+  # An Api holds:
+  #   * Contexts of defaults.
+  #   * Named contexts (= Api calls)
+  #
+  # Every Api is a singleton, it contains no state, only some name configurations (contexts).
+  class Api
+    include Singleton
+
+    # @!attribute queue
+    #   @return List of requests waiting for execution.
+    attr_reader :queue
+
+    class << self
+      extend Forwardable
+
+      def_delegators :instance, :default, :raw, :with
+
+      # Call missing methods on the default context.
+      def method_missing name, *args, &block
+        default.send name, *args, &block
+      end
+    end
+
+    # Initializes an Api with a parallel manager.
+    def initialize
+      @queue = []
+      @hydra = ::Typhoeus::Hydra.new
+    end
+
+    # A pretty standard starting point is the `default` context.
+    # An Api class can implement it to provide some default options and stack layers.
+    #
+    # @return [Context] A default context.
+    def default
+      @default ||= raw
+    end
+
+    # Get a raw context without any defaults.
+    #
+    # @return [Context] A raw context for this api.
+    def raw
+      @raw ||= Context.new self, {}, Stack.new
+    end
+
+    # Start scoping on this Api.
+    # Creates a context with provided options and stack.
+    #
+    # @return [Context] The created context.
+    def with options = {}, &stack_mod
+      default.with options, &stack_mod
+    end
+
+    # Queue a request for later parallel execution.
+    #
+    # @param request [Typhoeus::Request] The request to queue.
+    def commute request
+      @queue << request
+    end
+
+    # Executes all requests in the queue in parallel.
+    #
+    # @param request [Typhoeus::Request] Last request to add to the queue.
+    #   Shortcut to commute and rush one request in one line.
+    def rush request = nil
+      commute request if request
+      # Authorize each request right before executing
+      @queue.each do |request|
+        request.headers['Authorization'] = authorize(request.context) if respond_to? :authorize
+        @hydra.queue request
+      end
+      # Clear the queue.
+      @queue.clear
+      # Run all requests.
+      @hydra.run
+    end
+  end
+end

data/lib/commute/context.rb

@@ -0,0 +1,154 @@
+require 'forwardable'
+
+require 'commute/stack'
+require 'commute/adapters/typhoeus'
+
+module Commute
+
+  # A context represents all what can better define a HTTP request/response trip. This includes:
+  #   * An url.
+  #   * A partial request/response stack that defines request/response body transformations.
+  #   * Partial options for the request, the stack or behavior of certain {Api} calls.
+  #
+  # Contexts work incrementally to provide a full context (all required options and behaviour)
+  # for a HTTP request/response trip.
+  #
+  # Every Context has notion of an underlying api to easily make requests.
+  #
+  # Contexts can be extended through {#with}. This way you can add options/override options,
+  # alter the stack or specify an url.
+  #
+  class Context
+    extend Forwardable
+
+    # @!attribute options
+    #   @return The options of the context.
+    attr_accessor :options
+
+    # @!attribute stack
+    #   @return The stack of the context.
+    attr_accessor :stack
+
+    # Create a new Context.
+    #
+    # @param api [Api] The underlying api.
+    # @param options [Hash] all kinds of options (for the request, api call and stack layers).
+    # @param stack [Stack] The request/response stack.
+    def initialize api, options, stack
+      @api = api
+      @options = options
+      @stack = stack
+    end
+
+    # @!method [](key)
+    #   @param key [Symbol] The key to get from the options.
+    #   @return [Object] The value associated with that key.
+    def_delegator :@options, :[], :[]
+
+    # @!method commute(request)
+    #   Queues a request for later parallel execution.
+    #   @param request [Typhoeus::Request] The request to queue for later execution.
+    def_delegator :@api, :commute, :commute
+
+    # @!method rush
+    #   Executes all the requests in the queue of the api.
+    def_delegator :@api, :rush, :rush
+
+    # Create a new context from this context by providing new options and stack modifications.
+    #
+    # @param options [Hash] Options for the new {Context}.
+    #
+    # @yieldparam stack [Stack] The stack in this {Context}.
+    # @yieldreturn [Stack] The modified {Stack}.
+    def with options = {}
+      # Alter the stack if necessary
+      stack = @stack.clone
+      yield(stack) if block_given?
+      # Create a new context.
+      Context.new @api, mix(@options, options), stack
+    end
+
+    # Builds a Typhoeus::Request from the context.
+    #
+    # @todo This should work with some kind of Typhoeus adapter.
+    # @todo Actually the prepare method should only be called right before the request
+    #   is sent. We do not take queueing into account here. Timestamps for authorization could
+    #   expire. Can be solved by extending Typhoeus::Request with an UnpreparedRequest and
+    #   preparing it right before it is sent.
+    #
+    # @yieldparam response [Typhoeus::Response] The response object as we got it from Typhoeus.
+    # @yieldparam result [Object] The result of the body after going through the {Stack}.
+    #
+    # @return [Typhoeus::Request] The built Typhoeus Request.
+    def build &callback
+      # Call after hook if necessary.
+      context = if @api.respond_to? :after
+        @api.after self
+      else
+        self
+      end
+      # Build the real context (with or without after hook).
+      context.build_without_after &callback
+    end
+
+    # Builds the context without calling the after hook.
+    #
+    # @private
+    def build_without_after &callback
+      # Run the request body through the stack.
+      body = self[:body]
+      raw_body = if body && body != ''
+        @stack.run_request body, options
+      else
+        body
+      end
+      # Build the Typhoeus Request.
+      options[:body] = raw_body
+      request = Typhoeus::ContextualRequest.new self, self[:url], options
+      # Attach an on_complete handler that wraps the callback.
+      request.on_complete do |response|
+        # Run the response body through the stack.
+        body = response.body
+        result = if body && body != '' && response.success?
+          @stack.run_response response.body, options
+        else
+          body
+        end
+        # Call the real commute callback.
+        callback.call response, result if callback
+      end
+      # Return the request.
+      request
+    end
+
+    # Any method missing should be a shortcut to an api call with the current context.
+    # The options and the block that are passed are used to create a new context.
+    # This context is then passed to the API call to return another new context.
+    def method_missing name, *args, &block
+      # Extract the options from the method arguments.
+      options = args.first || {}
+      # Create the new context.
+      context = with options, &block
+      # Call the Api. This returns a new context.
+      @api.send name, context
+    end
+
+    private
+
+    # Merge a 2-level deep hash of options.
+    #
+    # @param options [Hash] The base options hash.
+    # @param override_options [Hash] The options hash considered as more important.
+    #
+    # @return [Hash] A mixed hash.
+    def mix options, override_options
+      options.merge(override_options) { |key, old_value, new_value|
+        if old_value.kind_of? Hash
+          old_value.merge new_value
+        else
+          new_value
+        end
+      }
+    end
+  end
+end

data/lib/commute/layer.rb

@@ -0,0 +1,16 @@
+module Commute
+
+  # @todo more docs and tests.
+  class Layer < Struct.new(:name)
+
+    # Default request forwards to the call method.
+    def request request, options
+      call request, options if respond_to? :call
+    end
+
+    # Default response forwards to the call method.
+    def response response, options
+      call response, options if respond_to? :call
+    end
+  end
+end

data/lib/commute/stack.rb

@@ -0,0 +1,104 @@
+require 'forwardable'
+require 'delegate'
+
+require 'commute/layer'
+
+module Commute
+
+  # A {Stack} is a sequence of layers that define a transfornation of a request/response body.
+  #
+  # Each {Layer} has a optional name. Options of the {Layer} can be passed in the
+  # {Context}'s options under the the equally named key.
+  #
+  # A Stack can both process a request and a response body (that can be either object,
+  # as long as it conforms with the first {Layer}).
+  class Stack
+    extend Forwardable
+
+    # Represents one way of the {Stack}
+    # Delegates methods to the underlying layer array.
+    class Sequence < SimpleDelegator
+
+      # Remove some layers from this sequence.
+      #
+      # @param names [<Symbol>] The names of the layers that must be removed.
+      def without! *names
+        reject! { |layer| names.include? layer.name }
+      end
+
+      # Insert a layer before another layer.
+      #
+      # @param reference [Symbol] The layer to insert before.
+      # @param insert [Layer] The layer to insert.
+      def before! reference, inserting
+        insert(index { |layer| layer.name == reference }, inserting)
+      end
+
+      # Insert a layer after another layer.
+      #
+      # @param reference [Symbol] The layer to insert after.
+      # @param insert [Layer] The layer to insert.
+      def after! reference, insert
+        insert((index { |layer| layer.name == reference }) + 1, insert)
+      end
+    end
+
+    # @!attribute request
+    #   The request {Sequence} of the stack.
+    attr_accessor :request
+
+    # @!attribute response
+    #   The response {Sequence} of the stack.
+    attr_accessor :response
+
+    # Create a new {Stack} with a few layers.
+    def initialize *layers
+      @request  = Sequence.new layers
+      @response = Sequence.new layers.reverse
+    end
+
+    # @param layer [Layer] The layer to be added to the stack.
+    def << layer
+      @request << layer
+      @response.insert 0, layer
+    end
+
+    # Run a request body through the stack.
+    #
+    # @param body [Object] The request body.
+    # @param options [Hash] Options for the layers.
+    #
+    # @return [Object] the transformed body.
+    def run_request body, options = {}
+      @request.inject(body) do |body, layer|
+        # Run through layer to modfiy the request
+        layer.request body, options[layer.name] || {}
+      end
+    end
+
+    # Run a response body through the stack.
+    # We want the response to have the inverse manipulations
+    #   so we invert the stack.
+    #
+    # @param body [Object] The request body.
+    # @param options [Hash] Options for the layers.
+    #
+    # @return [Object] the transformed body.
+    def run_response body, options = {}
+      @response.inject(body) do |body, layer|
+        # Run through layer to modfiy the request
+        layer.response body, options[layer.name] || {}
+      end
+    end
+
+    # Override the clone method to clone the layers.
+    #
+    # @return A duplicate of the stack.
+    def clone
+      stack = super
+      stack.request = stack.request.clone
+      stack.response = stack.response.clone
+      stack
+    end
+  end
+end

data/lib/commute/version.rb

@@ -0,0 +1,3 @@
+module Commute
+  VERSION = "0.1.2"
+end

data/lib/commute.rb

@@ -0,0 +1,7 @@
+require "commute/version"
+
+require 'commute/api'
+
+module Commute
+  # Your code goes here...
+end

data/spec/commute/api_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Commute::Api do
+
+  class TestApi < Commute::Api
+  end
+
+  let(:default) { TestApi.with(user: 'mattias') }
+
+  let(:request1) { default.with(url: 'http://www.example.com', method: :get).build }
+  let(:request2) { default.with(url: 'http://www.example.com', method: :post).build }
+  let(:request3) { default.with(url: 'http://www.example.com', method: :delete).build }
+
+  after do
+    TestApi.instance.queue.clear
+  end
+
+  describe '#method_missing' do
+    before do
+      TestApi.stubs(:default).returns(default)
+    end
+
+    it 'should forward calls to the singleton with the default context' do
+      TestApi.instance.expects(:get).with { |c|
+        c.options.must_equal user: 'mattias'
+      }
+      TestApi.get
+    end
+
+    it 'should take no default context if the raw context is used' do
+      TestApi.instance.expects(:get).with { |c|
+        c.options.must_equal id: 1
+      }
+      TestApi.raw.get id: 1
+    end
+
+    it 'should scope on the default context' do
+      TestApi.instance.expects(:get).with { |c|
+        c.options.must_equal user: 'mattias', id: 1
+      }
+      TestApi.get id: 1
+    end
+  end
+
+  describe '#commute' do
+    it 'should add requests to the queue' do
+      default.commute request1
+      default.commute request2
+      TestApi.instance.queue.size.must_equal 2
+    end
+  end
+
+  describe '#rush' do
+    describe 'no authorize' do
+      before do
+        @stub_get = stub_request(:get, "http://www.example.com")
+        @stub_post = stub_request(:post, "http://www.example.com")
+        @stub_delete = stub_request(:delete, "http://www.example.com")
+
+        default.commute request1
+        default.commute request2
+      end
+
+      it 'should clear the queue' do
+        default.rush
+        TestApi.instance.queue.size.must_equal 0
+      end
+
+      it 'should run all requests' do
+        default.rush
+        assert_requested(@stub_get)
+        assert_requested(@stub_post)
+      end
+
+      it 'should make the additional requests given to rush' do
+        default.rush request3
+        assert_requested(@stub_get)
+        assert_requested(@stub_post)
+        assert_requested(@stub_delete)
+      end
+    end
+
+    describe 'authorize method provided' do
+      it 'should authorize if a methode is provided' do
+        request = default.with(url: 'http://www.example.com', method: :get).build
+        TestApi.instance.stubs(:authorize).returns 'Authorized'
+        stub_request(:get, "http://www.example.com")
+        # Actually make the request
+        default.rush request
+        # TestApi.instance.stubs(:authorize).returns('Authorized')
+        assert_requested(:get, "http://www.example.com", :times => 1) { |request|
+          request.headers['Authorization'] = 'Authorized'
+        }
+      end
+    end
+  end
+end

data/spec/commute/context_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+require 'webmock/minitest'
+
+describe Commute::Context do
+
+  let(:context) {
+    Commute::Context.new api, options, stack
+  }
+
+  let(:stack) { Commute::Stack.new(stub, stub) }
+
+  let(:api) { stub }
+
+  let(:options) {
+    { body: 1, two: 2, params: { a: 'a' }}
+  }
+
+  describe '#with' do
+    it 'should keep its current options when the context is incremented' do
+      new_context = context.with body: 'one', params: { a: 'A', b: 'b' }
+      context.options.must_equal body: 1, two: 2, params: { a: 'a' }
+      new_context.options.must_equal body: 'one', two: 2, params: { a: 'A', b: 'b' }
+    end
+
+    it 'should not alter the current stack when the context is incremented' do
+      new_context = context.with do |stack|
+        stack << stub
+      end
+      context.stack.request.size.must_equal 2
+      new_context.stack.request.size.must_equal 3
+    end
+  end
+
+  describe '#[]' do
+    it 'should give the specified option' do
+      context[:body].must_equal 1
+    end
+  end
+
+  describe '#build' do
+    let(:stack) { stub_everything }
+
+    it 'should return a typhoeus request with the raw body' do
+      stack.expects(:run_request).with(1, options).returns 2
+      request = context.build
+      request.body.must_equal 2
+    end
+
+    describe 'when called with a callback' do
+      let(:options) {
+        {url: 'www.example.com', method: :get, body: 'sent'}
+      }
+
+      before do
+        # Stub the stack
+        stack.stubs(:run_request).with('sent', options).returns('sent transformed')
+        stack.stubs(:run_response).with('returned', options).returns('returned transformed')
+      end
+
+      describe 'when the requests succeeds with good status' do
+        it 'should call the callback with the original response and the transformed result' do
+          # Stub the http request.
+          stub_request(:get, 'www.example.com').with(body: 'sent transformed').to_return(body: 'returned')
+          # Build the request with a callback
+          callback = Proc.new {}
+          callback.expects(:call).with { |response, result|
+            response.body.must_equal 'returned'
+            result.must_equal 'returned transformed'
+          }
+          request = context.build &callback
+          # Run the request.
+          Typhoeus::Hydra.hydra.queue request
+          Typhoeus::Hydra.hydra.run
+        end
+      end
+
+      describe 'when the request succeeds with bad status' do
+        it 'should call the callback with the original response and no result' do
+          # Stub the http request.
+          stub_request(:get, 'www.example.com').with(body: 'sent transformed').to_return(\
+             status: [500, "Internal Server Error"])
+          # Response stack should never be triggered.
+          stack.expects(:run_response).never
+          # Build the request with a callback
+          callback = Proc.new {}
+          callback.expects(:call).with { |response, result|
+            response.code.must_equal 500
+            result.must_equal ''
+          }
+          request = context.build &callback
+          # Run the request.
+          Typhoeus::Hydra.hydra.queue request
+          Typhoeus::Hydra.hydra.run
+        end
+      end
+
+      describe 'when an after hook is configured' do
+        it 'should call it with the context' do
+          api.stubs(:after).with(context).returns(context.with(after: true))
+          request = context.build
+          request.context[:after].must_equal true
+        end
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    it 'should call the api with an incremented context when only given options' do
+      api.expects(:test_api_call).with { |context|
+        context[:enhanced].must_equal true
+      }
+      context.test_api_call enhanced: true
+    end
+
+    it 'should call the api with an incremented context when given no options' do
+      api.expects(:test_api_call).with { |incr_context|
+        context.options.must_equal context.options
+      }
+      context.test_api_call
+    end
+
+    it 'should call the api with an incremented context when given options and a block' do
+      api.expects(:test_api_call).with { |context|
+        context[:enhanced].must_equal true
+        context.stack.request.size.must_equal 3
+      }
+      context.test_api_call enhanced: true do |stack|
+        stack << stub
+      end
+    end
+  end
+
+  it 'should forward commute and rush to the api' do
+    request = stub
+    api.expects(:commute).with(request)
+    api.expects(:rush)
+    context.commute request
+    context.rush
+  end
+end

data/spec/commute/layer_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Commute::Layer do
+
+  let(:layer) { Commute::Layer.new }
+
+  describe 'when there is no call method' do
+    it 'should do nothing' do
+      layer.request nil, nil
+      layer.response nil, nil
+    end
+  end
+
+  describe 'when there is a call methode' do
+    it 'should call it' do
+      request = stub
+      options = { test: 1 }
+      layer.expects(:call).with(request, options)
+      layer.request request, options
+    end
+  end
+end

data/spec/commute/stack_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Commute::Stack do
+
+  let(:stack) { Commute::Stack.new }
+
+  let(:layer1) { stub.tap { |stub|
+    stub.stubs(:name).returns(:first)
+  }}
+
+  let(:layer2) { stub.tap { |stub|
+    stub.stubs(:name).returns(:second)
+  }}
+
+  let(:layer3) { stub.tap { |stub|
+    stub.stubs(:name).returns(:third)
+  }}
+
+  describe '#size' do
+    it 'should return the size of the stack' do
+      stack.request.size.must_equal 0
+      stack << stub
+      stack << stub
+      stack.request.size.must_equal 2
+    end
+  end
+
+  describe '#run_request' do
+    before do
+      stack << layer1
+      stack << layer2
+    end
+
+    it 'should run the body through all layers' do
+      layer1.expects(:request).with(1, {}).returns(2)
+      layer2.expects(:request).with(2, {}).returns(3)
+
+      stack.run_request(1).must_equal 3
+    end
+
+    it 'should route the options to the layers' do
+      layer1.expects(:request).with(1, 'options').returns(2)
+      layer2.expects(:request).with(2, user: 'defunkt')
+
+      stack.run_request 1, first: 'options', second: {
+        user: 'defunkt'
+      }
+    end
+  end
+
+  describe '#run_response' do
+    before do
+      stack << layer1
+      stack << layer2
+    end
+
+    it 'should run the body through all layers' do
+      layer2.expects(:response).with(1, {}).returns(2)
+      layer1.expects(:response).with(2, {}).returns(3)
+
+      stack.run_response(1).must_equal 3
+    end
+
+    it 'should route the options to the layers' do
+      layer2.expects(:response).with(1, user: 'defunkt').returns(2)
+      layer1.expects(:response).with(2, 'options')
+
+      stack.run_response 1, first: 'options', second: {
+        user: 'defunkt'
+      }
+    end
+  end
+
+  describe Commute::Stack::Sequence do
+
+    describe '#without!' do
+      before do
+        stack << layer1
+        stack << layer2
+        stack << layer3
+      end
+
+      it 'should remove the correct layers from the stack' do
+        stack.request.without! :second, :third
+        stack.request.size.must_equal 1
+        stack.response.size.must_equal 3
+      end
+    end
+
+    describe '#before!' do
+      before do
+        stack << layer1
+        stack << layer3
+      end
+
+      it 'should insert a layer before another one' do
+        stack.request.before! :third, layer2
+        stack.request[1].must_equal layer2
+        stack.request.size.must_equal 3
+        stack.response.size.must_equal 2
+      end
+    end
+
+    describe '#after!' do
+      before do
+        stack << layer1
+        stack << layer3
+      end
+
+      it 'should insert a layer after another one' do
+        stack.request.after! :first, layer2
+        stack.request[1].must_equal layer2
+        stack.request.size.must_equal 3
+        stack.response.size.must_equal 2
+      end
+
+      it 'should insert after the last one' do
+        stack.request.after! :third, layer2
+        stack.request.last.must_equal layer2
+        stack.request.size.must_equal 3
+        stack.response.size.must_equal 2
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'simplecov'
+
+SimpleCov.command_name 'minitest'
+SimpleCov.start
+
+require 'minitest/autorun'
+require 'minitest/spec'
+
+require 'mocha'
+
+require 'webmock'
+require 'webmock/minitest'
+
+require 'commute'

metadata

@@ -0,0 +1,217 @@
+--- !ruby/object:Gem::Specification
+name: commute
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+  prerelease: 
+platform: ruby
+authors:
+- Mattias Putman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Handling the HTTP commute like a boss
+email:
+- mattias.putman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- commute.gemspec
+- lib/commute.rb
+- lib/commute/adapters/typhoeus.rb
+- lib/commute/api.rb
+- lib/commute/context.rb
+- lib/commute/layer.rb
+- lib/commute/stack.rb
+- lib/commute/version.rb
+- spec/commute/api_spec.rb
+- spec/commute/context_spec.rb
+- spec/commute/layer_spec.rb
+- spec/commute/stack_spec.rb
+- spec/spec_helper.rb
+homepage: http://challengee.github.com/commute/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.19
+signing_key: 
+specification_version: 3
+summary: ! 'Commute helps you to: 1) Dynamically build HTTP requests for your favorite
+  HTTP library (currently only Typhoeus). 2) Easily process request and response bodies.
+  3) Execute parallel HTTP requests.'
+test_files:
+- spec/commute/api_spec.rb
+- spec/commute/context_spec.rb
+- spec/commute/layer_spec.rb
+- spec/commute/stack_spec.rb
+- spec/spec_helper.rb
+has_rdoc: