commute 0.1.2 → 0.2.0.rc.1

data/lib/commute/context.rb

@@ -1,154 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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/spec/commute/api_spec.rb

@@ -1,97 +0,0 @@
-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

@@ -1,140 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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