commute 0.2.0.rc.2 → 0.3.0.pre

data/lib/commute/common/em-synchrony_adapter.rb

@@ -1,29 +0,0 @@
-require "em-synchrony"
-require "em-synchrony/em-http"
-
-require 'commute/common/em_http_request_adapter'
-
-module Commute
-  module Common
-
-    # Public: Adapter that uses em-synchrony (with em-http-request).
-    #
-    # Requires use of em-synchrony and thus Eventmachine.
-    #
-    class EmSynchronyAdapter < EmHttpRequestAdapter
-      @id = :adapter
-
-      # Internal: Make a request through em-synchrony.
-      def call commuter, options = {}
-        # Create a native em-http request.
-        em_request = to_request commuter.get
-
-        # Create a Commute response.
-        response = to_response em_request.response_header, em_request.response
-        response.request = commuter.get
-        # Set it on the commuter.
-        commuter.set response
-      end
-    end
-  end
-end

data/lib/commute/common/em_http_request_adapter.rb

@@ -1,57 +0,0 @@
-require 'em-http-request'
-
-require 'commute/core/response'
-
-module Commute
-  module Common
-
-    # Public: Adapter that uses em-http-request, an Eventmachine based
-    # HTTP client, as a underlaying commute engine.
-    #
-    # This requires all the commute requests to be made within the
-    # Eventmachine loop.
-    #
-    class EmHttpRequestAdapter
-      @id = :adapter
-
-      # Internal: Make a request through Eventmachine.
-      def call commuter, options = {}
-        # Commuter delay for async processing.
-        commuter.delay do |&done|
-          # Create a native em-http request.
-          em_request = to_request commuter.get
-
-          # Set the callback.
-          em_request.callback do
-            # Create a Commute response.
-            response = to_response em_request.response_header, em_request.response
-            response.request = request
-            # Set it on the commuter.
-            commuter.set response
-            # Async call finished.
-            done.call
-          end
-        end
-      end
-
-      protected
-
-      # Internal: Converts a Commute requests into an em-http request.
-      def to_request request
-        EventMachine::HttpRequest.new(request.url).send request.method, \
-          query: request.query,
-          head: request.headers,
-          body: request.body
-      end
-
-      # Internal: Converts an em-http response into a Commute response.
-      # Note: trims whitespace bodies.
-      def to_response em_response_header, em_response
-        Commute::Response.new.tap do |response|
-          response.code = em_response_header.status
-          response.body = em_response unless em_response.strip.empty?
-        end
-      end
-    end
-  end
-end

data/lib/commute/common/typhoeus_adapter.rb

@@ -1,40 +0,0 @@
-require 'typhoeus'
-
-require 'commute/core/response'
-
-module Commute
-  module Common
-
-    # Internal: Adapter that uses Typhoeus to make requests.
-    #
-    # Compatibility:
-    #
-    #   TODO
-    #
-    class TyphoeusAdapter
-      @id = :adapter
-
-      def call commuter, options = {}
-        commuter.change do |request|
-          # puts request.inspect
-          # Build a Typhoeus request from this request.
-          typhoeus_request = Typhoeus::Request.new request.url, \
-            method: request.method,
-            body: request.body.to_s,
-            params: request.query || {},
-            headers: request.headers
-          # Run the request.
-          hydra = Typhoeus::Hydra.new
-          hydra.queue typhoeus_request
-          hydra.run
-          typhoeus_response = typhoeus_request.response
-          # Build a Commute response.
-          Response.new(request).tap do |response|
-            response.code = typhoeus_response.code
-            response.body = typhoeus_response.body
-          end
-        end
-      end
-    end
-  end
-end

data/lib/commute/common/xml.rb

@@ -1,7 +0,0 @@
-module Commute
-  module Common
-
-    class Xml
-    end
-  end
-end

data/lib/commute/core/commuter.rb

@@ -1,116 +0,0 @@
-require 'commute/core/context'
-
-module Commute
-
-  # Public: A Commuter is a package that holds a value
-  # associated to a context.
-  #
-  # A commuter can be tagged to make conditional
-  # processing possible.
-  #
-  class Commuter
-    attr_reader :context
-
-    # Public: Creates a new commuter
-    def initialize context, value = nil
-      @context = context
-      @value = value
-      @tags = []
-    end
-
-    # Public: Returns the inner value of the commuter.
-    def get
-      @value
-    end
-
-    # Public: Sets the inner value of the commuter.
-    #
-    # value - The new value.
-    def set value
-      @value = value
-    end
-
-    # Public: Changes the value of a commuter using a block.
-    # ONLY calls the block if the commuter value is not nil.
-    #
-    # Yields the value of the commuter.
-    #
-    # Returns nothing
-    def change
-      @value = yield @value unless @value.nil?
-      return nil
-    end
-
-    # Public: Get some parameters on how the commuter
-    # should be processed within a certain processor.
-    #
-    # processor_id - The id of the processor
-    #
-    # Returns whatever set in the context for this processor.
-    def parameters processor_id
-      self.context[processor_id]
-    end
-
-    # TODO
-    def disabled? processor_id
-      false
-    end
-
-    # TODO
-    def enabled? processor_id
-      !disabled?(processor_id)
-    end
-
-    # Public: Tags the commuter.
-    #
-    # tag - The tag to tag with (can be any object).
-    #
-    # Returns nothing.
-    def tag tag
-      @tags << tag
-      return nil
-    end
-
-    # Public: Checks if a commuter has a certain tag.
-    #
-    # tag - The tag to check presence of (can be any object).
-    #
-    # Returns true if the commuter is tagged with the given tag.
-    def tagged? tag
-      @tags.include? tag
-    end
-
-    # Public: Delays a commuter by giving it a block that
-    # must definitely be executed before the commute can continue.
-    #
-    # delay - The delay that must be executed.
-    #
-    # Returns nothing.
-    def delay &delay
-      @delay = delay
-      nil
-    end
-
-    def return
-      delay {}
-    end
-
-    # Public: check if a commuter is delayed.
-    def delayed?
-      !!@delay
-    end
-
-    # Public: Wait for a delay to be executed.
-    # And the do something when done.
-    #
-    # Yields when the delay has been executed.
-    #
-    # Returns nothing.
-    def wait &done
-      delay = @delay
-      @delay = nil
-      delay.call &done
-      return nil
-    end
-  end
-end

data/lib/commute/core/processors/code_status_processor.rb

@@ -1,40 +0,0 @@
-require 'commute/core/commuter'
-
-module Commute
-
-  # Internal: Looks at a response and decides if it was
-  # successful or not. This is the most basic one of
-  # those checkers. It simply checks if the response
-  # code is a 2xx code, when it is, the request was
-  # a success.
-  #
-  # This processor replaces the commuter's Response
-  #
-  class CodeStatusProcessor
-
-    class CodeStatus
-      @id = :status
-
-      attr_reader :code
-
-      def initialize code
-        @code = code
-        @success = (200..299).include? code
-      end
-
-      def success?
-        @success
-      end
-
-      def fail?
-        !@success
-      end
-    end
-
-    def call commuter
-      commuter.change do |response|
-        [response.body, CodeStatus.new(response.code)]
-      end
-    end
-  end
-end

data/lib/commute/core/processors/hook.rb

@@ -1,14 +0,0 @@
-require 'commute/core/commuter'
-
-module Commute
-
-  # Public: A Hook is a processor that yields the commuter value to a handler.
-  # The handler is given via the options for the processor (via its name).
-  #
-  class Hook
-
-    def call commuter, handler = nil
-      handler.call *commuter.get if handler
-    end
-  end
-end

data/lib/commute/core/processors/request_builder.rb

@@ -1,26 +0,0 @@
-require 'commute/core/commuter'
-require 'commute/core/request'
-
-module Commute
-
-  # Internal: A RequestBuilder builds a request given a context.
-  #
-  # It basically call all transformations defined on the context,
-  # resulting in a request. The request is then passed as the new
-  # value of the commuter (still with a reference to the context).
-  #
-  class RequestBuilder
-    @id = :builder
-
-    def call commuter
-      # Create a new request.
-      request = Request.new
-      # Build the request using context transformations.
-      commuter.context.transformations.each do |t|
-        t.call request, commuter.context
-      end
-      # Set the request on the commuter.
-      commuter.set request
-    end
-  end
-end

data/lib/commute/core/processors/sequencer.rb

@@ -1,46 +0,0 @@
-require 'commute/core/commuter'
-
-module Commute
-
-  # Public: A sequencer is a processor that lazily fetches a sequence
-  # from the stack and executes it with the given commuter.
-  #
-  # This has the advantage that an either not ye existent sequence or
-  # a sequence that could be modified later, can be referenced from
-  # another sequence.
-  #
-  # Examples:
-  #
-  #   Stack.new do |stack, main|
-  #     # Defining a new sequence.
-  #     response = stack.sequence(:response) do
-  #       ...
-  #     end
-  #
-  #     # This would work but if we alter the response
-  #     # sequence later on, it would still use this one.
-  #     main.append response
-  #
-  #     # Instead we do
-  #     main.append Sequencer.new(:response)
-  #   end
-  #
-  class Sequencer
-
-    # Public: Creates a new sequencer.
-    #
-    # name - The name of the sequence that needs to be called (lazily).
-    def initialize name
-      @name = name
-    end
-
-    def call commuter
-      # Get the stack from the processing context.
-      stack = commuter.context.stack
-      # Get the sequence we need to call.
-      sequence =  stack.get(@name)
-      # Call the sequence if one was found.
-      sequence.call commuter if sequence
-    end
-  end
-end

data/lib/commute/core/request.rb

@@ -1,58 +0,0 @@
-require 'uri'
-
-module Commute
-
-  class Request
-
-    # Scheme (http(s))
-    attr_accessor :scheme
-
-    # Host to connect to (String).
-    attr_accessor :host
-
-    # Port to connect to (Integer).
-    attr_accessor :port
-
-    # Path to request (String).
-    attr_accessor :path
-
-    # Url parameters (Hash).
-    attr_accessor :query
-    alias :params :query
-    alias :params= :query=
-
-    # The HTTP Method of the request (Symbol).
-    # Mostly :get, :post, :put, :patch, :delete
-    attr_accessor :method
-
-    # Request headers.
-    attr_accessor :headers
-
-    # The headers (Hash).
-
-    # The Body.
-    attr_accessor :body
-
-    def initialize
-      @headers = {}
-      @query = {}
-    end
-
-    def url= url
-      uri = URI url
-      @scheme = uri.scheme
-      @host = uri.host
-      @port = uri.port
-      @path = uri.path
-      @query = Hash[uri.query.split('&').map { |p| p.split('=') }] if uri.query
-    end
-
-    # SCHEME! TODO
-    def url
-      query = @query.map { |k,v| "#{k}=#{v}" }.join '&'
-      url = "#{@scheme}://#{@host}:#{@port}#{@path}"
-      url << "?#{query}" unless query.nil? || query.empty?
-      url
-    end
-  end
-end

data/lib/commute/core/response.rb

@@ -1,18 +0,0 @@
-module Commute
-
-  class Response
-
-    # The request responsible for this response.
-    attr_accessor :request
-
-    # Response code.
-    attr_accessor :code
-
-    # The Body.
-    attr_accessor :body
-
-    def initialize request = nil
-      @request = request
-    end
-  end
-end

data/spec/commute/aspects/caching_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require 'commute/aspects/caching'
-
-describe Commute::Aspect::Caching do
-
-  class TestApi < Commute::Api
-    include Commute::Aspect::Caching
-  end
-
-  it '' do
-  end
-end

data/spec/commute/aspects/url_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-require 'commute/core/context'
-require 'commute/core/request'
-require 'commute/aspects/url'
-
-describe Commute::Aspect::Url do
-
-  Klass = Class.new(Commute::Builder) do |klass|
-    include Commute::Aspect::Url::ClassMethods
-  end
-
-  let(:request) { Commute::Request.new }
-
-  it 'should create an url transformation without parameters' do
-    transformation = example('http://api.example.com')
-    # Hash that acts as a context.
-    context = {}
-    transformation.call(request, context)
-    # Checks.
-    request.scheme.must_equal 'http'
-    request.host.must_equal 'api.example.com'
-    request.path.must_be_empty
-  end
-
-  it 'should create an url transformation with parameters in the host and path' do
-    transformation = example('https://api.$root.com:3000/1/$scope/$id.xml')
-    # Hash that acts as a context.
-    context = {
-      root: 'example',
-      scope: 'people',
-      id: '3'
-    }
-    transformation.call(request, context)
-    # Checks.
-    request.scheme.must_equal 'https'
-    request.host.must_equal 'api.example.com'
-    request.path.must_equal '/1/people/3.xml'
-    request.port.must_equal '3000'
-  end
-
-  it 'should create an url transformation with parameters in the host and path when only some of the values are present' do
-    transformation = example('https://api.$root.com:3000/1/$scope/$id.xml')
-    # Hash that acts as a context.
-    context = {
-      root: 'example',
-      scope: 'people'
-    }
-    transformation.call(request, context)
-    # Checks.
-    request.scheme.must_equal 'https'
-    request.host.must_equal 'api.example.com'
-    request.path.must_equal '/1/people.xml'
-    request.port.must_equal '3000'
-  end
-
-  private
-
-  def example pattern
-    Klass.new(Commute::Context.new).url(pattern).transformations.first
-  end
-end

data/spec/commute/core/commuter_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'commute/core/commuter'
-
-describe Commute::Commuter do
-
-  let(:context) { mock }
-
-  let(:commuter) { Commute::Commuter.new(context, 1) }
-
-  describe '#change' do
-    it 'should take a block that processes the value' do
-      commuter.change { |number| number + 1 }
-      commuter.get.must_equal 2
-    end
-
-    describe 'when there is no value' do
-      let(:commuter) { Commute::Commuter.new(context, nil) }
-
-      it 'should not call the block' do
-        block = Proc.new { |n| n+1 }
-        block.expects(:call).never
-        commuter.change &block
-      end
-    end
-  end
-
-  describe '#tag' do
-    it 'should tag the commuter' do
-      commuter.tag :cool
-      commuter.tagged?(:cool).must_equal true
-    end
-  end
-
-  describe '#context' do
-    it 'should return the associated context' do
-      commuter.context.must_equal context
-    end
-  end
-
-  describe '#parameters' do
-    it 'should return parameters needed for a processor to process the commuter' do
-      context.expects(:[]).with(:processor).returns operation: :multiply
-      commuter.parameters(:processor).must_equal operation: :multiply
-    end
-  end
-
-  describe '#wait' do
-    it 'waits for a delay and does something when done waiting' do
-      done = lambda { @done = true }
-      delay = Proc.new { |&done| done.call }
-      commuter.delay &delay
-      commuter.delayed?.must_equal true
-      commuter.wait &done
-      @done.must_equal true
-
-      done = lambda { @done = false }
-      delay = Proc.new { }
-      commuter.delay &delay
-      done.expects(:call).never
-      commuter.wait &done
-      @done.must_equal true
-    end
-  end
-end

data/spec/commute/core/processors/code_status_processor_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-require 'commute/core/processors/code_status_processor'
-
-describe Commute::CodeStatusProcessor do
-end

data/spec/commute/core/processors/hook_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-require 'commute/core/processors/hook'
-
-describe Commute::Hook do
-
-  let(:hook) { Commute::Hook.new }
-
-  let(:value) { mock }
-
-  let(:commuter) { Commute::Commuter.new mock, value }
-
-  describe 'when no handler is specified' do
-    it 'should do nothing' do
-      hook.call commuter
-    end
-  end
-
-  describe 'when a handler is specified' do
-    it 'should call the handler with the commuter value' do
-      handler = mock
-      handler.expects(:call).with(value)
-      hook.call commuter, handler
-    end
-  end
-end

data/spec/commute/core/processors/request_builder_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-require 'commute/core/processors/request_builder'
-
-describe Commute::RequestBuilder do
-
-  let(:context) { Commute::Context.new }
-
-  let(:builder) { Commute::RequestBuilder.new }
-
-  it 'should transform the context' do
-    c = context.get.
-      transform(:id) { |request, id| request.url =  "http://pastie.org/pastes/#{id}/text" }.
-      with(id: 1)
-
-    commuter = Commute::Commuter.new(c, nil)
-
-    builder.call commuter
-
-    commuter.get.tap { |request|
-      request.host.must_equal 'pastie.org'
-      request.path.must_equal '/pastes/1/text'
-      request.method.must_equal :get
-    }
-  end
-end

data/spec/commute/core/processors/sequencer_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-require 'commute/core/processors/sequencer'
-
-describe Commute::Sequencer do
-
-  let(:stack) { Commute::Stack.new {} }
-
-  let(:context) { Commute::Context.new stack }
-
-  let(:commuter) { Commute::Commuter.new context, mock }
-
-  let(:sequencer) { Commute::Sequencer.new(:response) }
-
-  describe 'The sequence is not defined in the stack' do
-    it 'should do nothing' do
-      sequencer.call commuter
-    end
-  end
-
-  describe 'The sequence is defined in the stack' do
-    let(:sequence) { mock }
-    let(:commuter) do
-      Commute::Commuter.new context.using { |stack, main|
-        stack.add sequence, :response
-      }.context, mock
-    end
-
-    it 'should call the sequence' do
-      sequence.expects(:call).once
-      sequencer.call commuter
-    end
-  end
-end