commute 0.1.2 → 0.2.0.rc.1

data/lib/commute/core/request.rb

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

@@ -0,0 +1,18 @@
+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/lib/commute/core/sequence.rb

@@ -0,0 +1,180 @@
+require 'commute/core/commuter'
+
+module Commute
+
+  # Internal: A Sequence is an ordered list of processors, that all
+  # work together to incrementally process a Commuter.
+  #
+  class Sequence
+
+    # Public: Initializes a sequence without processors.
+    def initialize &alter
+      @processors = []
+      @index = {}
+      self.alter &alter if block_given?
+    end
+
+    # Public: Alters the sequence.
+    #
+    # Yields the sequence itself if the arity of the block is 1.
+    # Evaluates the block if the arity is 0.
+    #
+    # Returns the sequence itself.
+    def alter &alter
+      if alter.arity == 0
+        instance_eval &alter
+      else
+        yield self
+      end
+      # Return the Sequence.
+      return self
+    end
+
+    # Returns an duplicate collection of processors.
+    def processors
+      @processors.clone
+    end
+
+    # Internal: Processes a commuter with al processors in the sequence.
+    #
+    # When a commuter provides parameters for a processor through the
+    # parameters method, given the processor id. Then those parameters
+    # are passed as an argument to the call method of the processor (if applicable).
+    #
+    # Returns Nothing.
+    def call commuter, options = {}
+      call_one 0, commuter
+    end
+
+    def call_one index, commuter
+      # Get the processor using the index.
+      processor = @processors[index]
+      # Immediately return if no processor is found.
+      return nil unless processor
+      # Identify the processor.
+      # TODO: not very performant
+      processor_id = @index.key processor
+      # Immediately jumpt to the next processor if this one is disabled.
+      if commuter.enabled? processor_id
+        # Get the parameters.
+        parameters = commuter.parameters(processor_id) if processor_id
+        # Calling the processor.
+        if parameters
+          processor.call commuter, parameters
+        else
+          processor.call commuter
+        end
+      end
+      # Call self for the next processor.
+      call_next = Proc.new { call_one index + 1, commuter }
+      if commuter.delayed?
+        commuter.wait &call_next
+      else
+        call_next.call
+      end
+    end
+
+    # Public: Appends a processor to a the list of processors.
+    #
+    # options - Optional parameters for processor naming and placement (default: {}):
+    #           :as    - The name of the processor in the sequence (optional).
+    #           :after - A reference processor id after which the processor needs to be appended.
+    #
+    # Returns the appended processor.
+    def append processor, options = {}
+      # When a reference is given, append after it.
+      if options[:after]
+        @processors.insert id_index(options[:after]) + 1, processor
+      else
+        @processors << processor
+      end
+      # Identify the processor using different methods.
+      id = identify processor, options[:as]
+      # Add the processor to the index for direct access purposes.
+      @index[id] = processor if id
+      # Return the appended processor.
+      processor
+    end
+
+    # TODO
+    def insert processor, options = {}
+      # When a reference is given, insert before it.
+      if options[:before]
+        @processors.insert id_index(options[:before]) - 1, processor
+      else
+        @processors.unshift processor
+      end
+      # Identify the processor using different methods.
+      id = identify processor, options[:as]
+      # Add the processor to the index for direct access purposes.
+      @index[id] = processor if id
+      # Return the appended processor.
+      processor
+    end
+
+    # TODO TEST
+    def replace processor_id
+      processor = at processor_id
+      raise "processor does not exist #{processor_id}" unless processor
+      replacement = yield processor
+      @processors[@processors.index processor] = replacement
+      @index[processor_id] = replacement
+    end
+
+    # Public: Removes a processor from the sequence.
+    #
+    # When a processor object is given, the processor is removed. When its
+    # Symbol identifier is given, the associated processor is removed.
+    #
+    # Returns the removed processor.
+    def remove processor
+      if processor.is_a?(Symbol)
+        processor_id = processor
+        processor = at(processor)
+        @processors.delete processor
+        @index.delete processor_id
+      else
+        # Remove from list of processors.
+        @processors.delete processor
+        # Remove from index (if necessary).
+        @index.delete_if { |id, pr| pr == processor}
+      end
+      # Return the deleted processor.
+      processor
+    end
+
+    # Public
+    # Returns the processor with the given id.
+    #
+    # id - The Symbol identifier of a processor.
+    def at id
+      @index[id]
+    end
+
+    # Internal: Clones the sequence.
+    def dup
+      Sequence.new.tap do |sequence|
+        sequence.processors = @processors.clone
+        sequence.index = @index.clone
+      end
+    end
+
+    private
+
+    def identify processor, override = nil
+      if override
+        override
+      else
+        processor.class.instance_variable_get :@id
+      end
+    end
+
+    def id_index id
+      @processors.index at(id)
+    end
+
+    protected
+
+    attr_writer :processors, :index
+  end
+end

data/lib/commute/core/stack.rb

@@ -0,0 +1,145 @@
+require 'commute/core/sequence'
+
+module Commute
+
+  # Internal: A stack is a collection of sequences with
+  # A main sequence uses as a starting point for processing.
+  #
+  # When the stack is called with a processable, it gets
+  # processed by the main sequence. That main sequence
+  # can easily "embed" other sequences by adding them as
+  # a processer (a sequence is also a processor).
+  #
+  # Example:
+  #
+  #   stack = Stack.new do |stack, sequence|
+  #     stack.sequence(:calculation) do
+  #       append Proc.new { |n| n.data += 1 }
+  #       append Proc.new { |n| n.data *= 2 }
+  #     end
+  #
+  #     sequence.append stack.sequencer(:calculation)
+  #     sequence.append Proc.new { |p| p.process { |n| "The result is #{n}" }}
+  #  end
+  #
+  #  stack.call Processable.new(context, 1)
+  #  # => "The result is 4"
+  #
+  class Stack
+
+    # Public: Constructs a stack with a main sequence.
+    #
+    # sequence - Sequence used as main sequence.
+    #
+    # Yields
+    #   1. The Stack itself. (If the arity of the block is 2)
+    #   2. a new sequence to use a main sequence when no
+    #      sequence is explicitely given.
+    #
+    # Raises an error if neither is given.
+    #
+    # Returns a Stack with a main sequence.
+    def initialize sequence = nil, &main
+      @sequences = {}
+      @main = if sequence
+        sequence
+      else
+        if main.arity == 1
+          Sequence.new &main
+        else
+          sequence = Sequence.new
+          yield self, sequence
+          sequence
+        end
+      end
+    end
+
+    # Public: Adds a sequence to the stack.
+    #
+    # sequence - The Sequence to be added.
+    # name     - The name of the sequence.
+    #
+    # Returns the Sequence that was added.
+    def add sequence, name
+      @sequences[name] = sequence
+    end
+
+    # Public: Get a sequence from the stack.
+    #
+    # name - The name of the wanted Sequence.
+    #
+    # Returns the asked sequence.
+    def get name
+      @sequences[name]
+    end
+
+    # Public: Manipulate an either existing or new sequence.
+    #
+    # name - The name of the sequence to alter or create.
+    #
+    # Yields
+    #   1. The Stack itself. (If the arity of the block is 2)
+    #   2. The existing sequence with given name or
+    #      adds a new yielded sequence with the name to the stack.
+    #
+    # Returns the Sequence.
+    def sequence name = nil, &alter
+      if name
+        @sequences[name] || add(Sequence.new(&alter), name)
+      else
+        @main
+      end
+    end
+
+    # Public: Creates a processor that lazily fetches a named sequence
+    # on a call.
+    #
+    # name - The name of the sequence this sequencer stands in for.
+    #
+    # Returns a Sequencer
+    def sequencer name = nil
+      if name
+        Sequencer.new.here(name)
+      else
+        Sequencer.new
+      end
+    end
+
+    # Internal: Calls the stack aka call the main sequence.
+    #
+    # processable - The thing to process.
+    #
+    # Returns the processable
+    def call processable
+      @main.call processable
+    end
+
+    # Public: Alters the stack.
+    #
+    # Yields the stack itself if the arity of the block is 1.
+    # Evaluates the block if the arity is 0.
+    #
+    # Returns the stack itself.
+    def alter &alter
+      if alter.arity == 0
+        instance_eval &alter
+      else
+        yield self, @main
+      end
+      # Return the Stack.
+      return self
+    end
+
+    # Internal: Clones the sequence.
+    def dup
+      Stack.new(@main.dup).tap do |stack|
+        stack.sequences = Hash[@sequences.map { |k,v| [k, v.dup] }]
+      end
+    end
+
+    protected
+
+    attr_writer :sequences
+  end
+end
+

data/lib/commute/version.rb

@@ -1,3 +1,3 @@
 module Commute
-  VERSION = "0.1.2"
+  VERSION = "0.2.0.rc.1"
 end

data/lib/commute.rb

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

data/spec/commute/aspects/caching_spec.rb

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

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

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'commute/core/api'
+
+describe Commute::Api do
+
+  class TestApi < Commute::Api
+    with(text: 'hello world')
+
+    with(id: 1)
+
+    using do
+      sequence.append Proc.new {}
+    end
+
+    def all
+      with(text: 'go', help: true).get
+    end
+  end
+
+  class TestInheritance < TestApi
+    with(id: 2)
+
+    using do
+      sequence.append Proc.new {}
+    end
+  end
+
+  let(:api_klass) { TestApi }
+
+  let(:api_klass2) do
+    Class.new(Commute::Api) do
+      with text: 'goodbye world'
+    end
+  end
+
+  it 'should allow us to define a base context' do
+    api_klass.context.parameters.must_equal id: 1, text: 'hello world'
+  end
+
+  it 'should isolate base contexts for each api' do
+    api_klass2.context.parameters.must_equal text: 'goodbye world'
+  end
+
+  it 'should allow us to modify the base context externally' do
+    build = api_klass.builder.with id: 2
+    api_klass.context.parameters[:id].must_equal 2
+    api_klass.builder.with id: 1
+  end
+
+  it 'should create a new Api instance when a method is called on the class' do
+    context = api_klass.with(id: 2).all.context
+    context.parameters.must_equal id: 2, text: 'go', help: true
+  end
+
+  it 'should deal with inheritance' do
+    context = TestInheritance.new.context
+    context.parameters[:id].must_equal 2
+    context.stack.sequence.processors.size.must_be :>=, 2
+  end
+
+  describe '#new' do
+    it 'should build on the base context without modifying it' do
+      api = api_klass.new.context
+      api.with(id: 2).parameters[:id].must_equal 2
+      context = api.with(text: 'hi!').all.context
+      context.parameters[:id].must_equal 1
+      context.with(id: 2).parameters.must_equal text: 'go', help: true, id: 2
+    end
+  end
+end

data/spec/commute/core/builder_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'commute/core/context'
+require 'commute/core/request'
+
+describe Commute::Builder do
+
+  let(:parameters) {{}}
+  let(:stack) { Commute::Stack.new { |stack, main|
+    main.append Proc.new {}
+  }}
+  let(:transformations) {[]}
+  let(:disables) {[]}
+
+  let(:context) { Commute::Context.new stack, parameters, transformations, disables }
+
+  let(:builder) { Commute::Builder.new context }
+
+  let(:request) { Commute::Request.new }
+
+  describe '#with' do
+    it 'should add parameters to the context' do
+      builder.with(id: 1, text: 'hello').parameters.must_equal \
+        id: 1, text: 'hello'
+    end
+
+    it 'should merge collisions by merging hashes and adding arrays' do
+      builder.
+        with(ids: [1,2], options: { limit: 1 }).
+        with(ids: [3,4], options: { index: 2 }).
+        parameters.must_equal \
+          ids: [1,2,3,4], options: { limit: 1, index: 2 }
+    end
+
+    describe 'with initial parameters' do
+      let(:parameters) {
+        { text: 'hello', limit: 10 }
+      }
+
+      it 'should add parameters to the context' do
+        builder.with(id: 1, text: 'world').parameters.must_equal \
+          id: 1, text: 'world', limit: 10
+      end
+    end
+
+    it 'should not include parameters with nil value' do
+      builder.with(id: nil).parameters.must_equal({})
+    end
+  end
+
+  describe '#without' do
+
+    it 'should remove parameters' do
+      builder.with(id: 1, text: 'hello').without(:id).parameters.must_equal text: 'hello'
+    end
+
+    it 'should work over contexts' do
+      context = builder.with(id: 1, text: 'hello').context
+      context2 = context.without(:id).context
+      context2.parameters.wont_include :id
+      context.parameters.must_include :id
+    end
+  end
+
+  describe '#enable' do
+    it 'should enable a processor' do
+      skip 'TODO'
+    end
+  end
+
+  describe '#disable' do
+    it 'should disable a processor' do
+      skip 'TODO'
+    end
+  end
+
+  describe '#transform' do
+    it 'should be able to add a static transform without dependencies' do
+      context = builder.transform { |request| request.method = :get }.context
+      context.transformations.first.call(request, context)
+      request.method.must_equal :get
+    end
+
+    it 'should be able to add a dynamic transform without dependencies' do
+      context = builder.with(id: 1).transform { |request, context|
+        request.path = "/#{context[:id]}"
+      }.context
+      context.transformations.first.call(request, context)
+      request.path.must_equal '/1'
+    end
+
+    it 'should be able to add a dynamic transform with dependencies' do
+      context = builder.with(id: 1).transform(:id) { |request, id|
+        request.path = "/#{id}"
+      }.context
+      context.transformations.first.call(request, context)
+      request.path.must_equal '/1'
+    end
+
+    it 'should never call the transformation when its dependencies are all nil' do
+      proc = Proc.new {}
+      proc.expects(:call).never
+      context = builder.transform(:id, &proc)
+      context.transformations.first.call(request, context)
+    end
+  end
+
+  describe '#using' do
+    it 'should work without a block' do
+      skip 'TODO'
+    end
+  end
+
+  describe '#context' do
+    it 'should be a snapshot of the builder' do
+      builder.with id: 1
+      context = builder.context
+      context.parameters.must_equal id: 1
+      builder = context.with text: 'hello world'
+      context.parameters.must_equal id: 1
+      builder.context.parameters.must_equal id: 1, text: 'hello world'
+    end
+  end
+end