commute 0.2.0.rc.2 → 0.3.0.pre

data/lib/commute/core/util/stream.rb

@@ -0,0 +1,141 @@
+require 'commute/core/util/event_emitter'
+
+module Commute
+
+  # Internal: A Simple Evented stream modelled after node.js' stream.
+  # More info: http://nodejs.org/api/stream.html.
+  #
+  # When you create a stream, you can write anything to it. For every
+  # write, an event 'data' is emitted to the listeners (evented reading).
+  #
+  # When a stream is ended, an 'end' event is emitted and the stream is
+  # not writeable anymore.
+  #
+  module Stream
+    include EventEmitter
+
+    class Simple
+      include Stream
+    end
+
+    # Internal: Opens a new writeable stream.
+    def initialize *args
+      super *args
+      @writeable = true
+    end
+
+    # Internal: Writes data to the stream.
+    # Note: Silenty does not write if the stream is not writeable (see #writable?).
+    #
+    # data - A chunk of data to write to the stream.
+    #
+    # Returns the written data (nil if no data was written).
+    def write data
+      if writeable?
+        emit :data, data
+        data
+      end
+    end
+
+    # Internal: Checks if the stream is writeable.
+    #
+    # Returns true if the stream is writeable.
+    def writeable?
+      @writeable
+    end
+
+    # Internal: Ends the stream.
+    # Note: After this, the stream is not writeable anymore.
+    #
+    # data - Last chunk of data to send.
+    #
+    # Returns Nothing
+    def end data = nil
+      emit :data, data if data
+      @writeable = false
+      emit :end
+      nil
+    end
+
+    # Internal: Pipes the stream to another stream.
+    #
+    # Whenever data is written to the source stream,
+    # it gets written to the destination stream.
+    # When the source stream end, the destinations stream
+    # is ended as well.
+    #
+    # destination - The stream to pipe to.
+    # options - For future use.
+    #
+    # Returns Nothing.
+    def pipe destination, options = {}
+      on(:data) { |chunk| destination.write chunk }
+      on(:end)  { destination.end }
+      nil
+    end
+
+    # Buffers data and emits the entire buffer.
+    # Calls << on the initial for every chunk in the stream.
+    #
+    # initial - The initial value of the buffer (default: []).
+    #
+    # Yields if done buffering.
+    # Returns a new buffered stream.
+    def buffer
+      inject [], &:<<
+    end
+
+    def >> sink
+      buffer.on(:data) { |buffer| sink.concat buffer }
+    end
+
+    def map &block
+      Simple.new.tap do |stream|
+        on(:data) { |chunk| stream.write block.call(chunk) }
+        on(:end) { stream.end }
+      end
+    end
+
+    def reject &block
+      Simple.new.tap do |stream|
+        on(:data) { |chunk| stream.write chunk unless block.call(chunk) }
+        on(:end) { stream.end }
+      end
+    end
+
+    def select &block
+      Simple.new.tap do |stream|
+        on(:data) { |chunk| stream.write chunk if block.call(chunk) }
+        on(:end) { stream.end }
+      end
+    end
+
+    def inject initial, &block
+      Simple.new.tap do |stream|
+        triggered = false
+        on(:data) do |chunk|
+          initial = block.call initial, chunk
+          triggered = true
+        end
+        on(:end) do
+          stream.write initial if triggered
+          stream.end
+        end
+      end
+    end
+
+    def take amount
+      Simple.new.tap do |stream|
+        count = 0
+        on(:data) do |chunk|
+          if count < amount
+            stream.write chunk
+            count += 1
+          else
+            stream.end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commute/extensions/crud.rb

@@ -0,0 +1,88 @@
+module Commute
+  module Extension
+
+    # Public: Defines standard Restful CRUD actions.
+    #
+    # create  -> POST
+    # read    -> GET
+    # update  -> PUT
+    # destroy -> DELETE
+    #
+    # Note: Implement "one" and "list" methods to
+    # hook on different CRUD selectors.
+    #
+    # Examples:
+    #
+    #   gist = gists.find(1).run!
+    #   gist[:description] = "Testing CRUD"
+    #   gists.update(gist).where(id: 1).run
+    #   gists.destroy(1).run
+    #
+    #   # Making use of contexts.
+    #   handle = gists.where(id: 1)
+    #   gist = handle.find.run!
+    #   gist[:description] = "Testing CRUD"
+    #   handle.update(gist).run
+    #   handle.destroy
+    #
+    module Crud
+      METHODS = [:all, :find, :update, :create, :destroy].freeze
+
+      # Public: An Extended CRUD extension that uses PATCH for updates.
+      #
+      # create  -> POST
+      # read    -> GET
+      # update  -> PATCH
+      # replace -> PUT
+      # destroy -> DELETE
+      #
+      module Extended
+        include Crud
+        METHODS = [:all, :find, :update, :replace, :create, :destroy].freeze
+
+        # Public: Replaces a resource
+        def replace body = nil
+          put.body(body).try :one
+        end
+
+        # Public: Updates a resource.
+        def update body = nil
+          patch.body(body).try :one
+        end
+      end
+
+      # Public: Get all resources.
+      def all
+        get.try :list
+      end
+
+      # Public: Find a resource using an id.
+      #
+      # id - The id of the resource (optional).
+      #
+      def find id = nil
+        with id: id
+        get.try :one
+      end
+
+      # Public: Updates a resource.
+      def update body = nil
+        put.body(body).try :one
+      end
+
+      # Public: Creates a resource.
+      def create body = nil
+        post.body(body).try :one
+      end
+
+      # Public: Destroys a resource.
+      #
+      # id - The id of the resource to destroy (optional).
+      #
+      def destroy id = nil
+        with id: id
+        delete.try :one
+      end
+    end
+  end
+end

data/lib/commute/extensions/param.rb

@@ -0,0 +1,20 @@
+module Commute
+  module Extension
+
+    module Param
+      METHOD = [:param, :params]
+
+      def param name, param_name = name
+        transform name do |request, value|
+          request.query[param_name] = value
+        end
+      end
+
+      def params names
+        names.each do |name|
+          self.param name
+        end
+      end
+    end
+  end
+end

data/lib/commute/extensions/url.rb

@@ -0,0 +1,53 @@
+require 'uri'
+
+module Commute
+  module Extension
+
+    # The url extensions provides an `url` method that pushes
+    # a transformation on the context that renders the required url
+    # based on a pattern.
+    #
+    # The pattern uses the standard ruby format specification. When
+    # not all variables are present, the url in sanitized in a
+    # way that it is valid again.
+    #
+    # Examples:
+    #
+    #   class GistApi < Commute::Api
+    #     include Commute::Extension::Url
+    #
+    #     url 'https://api.github.com/gists/%{filter}'
+    #
+    #     def user user = nil
+    #       with(user: user)
+    #       url('https://api.github.com/user/%{user}/gists').all
+    #     end
+    #   end
+    #
+    module Url
+      METHODS = [:url].freeze
+
+      # Public: Define the url pattern to use.
+      #
+      # pattern - The patter with variables between %{}.
+      #
+      # Returns self.
+      def url pattern
+        # Transform the context, filling in the url.
+        transform do |request, context|
+          # First, render the url pattern.
+          rendered = pattern.gsub(/%{([^}]*)}/) { |m| context[$1.to_sym] }
+          # Parse the rendered url using uri.
+          uri = URI rendered
+          # Substitute multiple / by one /.
+          uri.path.gsub! /\/+/, '/'
+          # Substiture /.format by .format
+          uri.path.sub! /\/\.([^\/]+)$/, '.\1'
+
+          # Assign the uri to the request.
+          request.uri = uri
+        end
+      end
+    end
+  end
+end

data/lib/commute/version.rb

@@ -1,3 +1,3 @@
 module Commute
-  VERSION = "0.2.0.rc.2"
+  VERSION = "0.3.0.pre"
 end

data/spec/commute/common/caching_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+require 'commute/common/caching'
+
+describe Commute::Common::Caching do
+
+  let(:cache) { stub }
+
+  let(:response) {
+    Commute::Http::Response.new(nil).tap { |response|
+      response.headers['ETag'] = 'A'
+    }
+  }
+
+  let(:body) {
+    { some: ['complex', 'structure'] }
+  }
+
+  let(:responder) {
+    proc { |router, request|
+      request.respond(response, status).tap { |response|
+        response.write body
+        response.end
+      }
+    }
+  }
+
+  let(:stack) {
+    Commute::Stack.new do |stack|
+      stack.sequence do |s|
+        s.append Commute::Common::Caching.new
+        s.append responder
+      end
+    end
+  }
+
+  let(:base) {
+    Commute::Context.new(stack).with(caching: {
+      cache: cache
+    }).context
+  }
+
+  describe 'a get request' do
+    let(:api) do
+      base.transform do |request|
+        request.method = :get
+        request.uri = URI('http://www.example.com')
+      end
+    end
+
+    describe 'nothing in the cache' do
+      before do
+        cache.stubs(:get).returns nil
+      end
+
+      it 'should fire the request' do
+        responder.expects(:call).once.with do |router, request|
+          request.http.method.must_equal :get
+        end
+        call
+      end
+
+      describe 'the response was succesful' do
+        let(:status) { Commute::Http::Status.new(200) }
+
+        it 'should store the response in the cache and return the response' do
+          cache.expects(:set).with('http://www.example.com', {
+            data: body,
+            etag: 'A'
+          })
+          call
+          @body.must_equal body
+          @status.success?.must_equal true
+          @status.cached.must_equal false
+          @status.http.wont_be_nil
+        end
+      end
+
+      describe 'the response was not successful' do
+      end
+    end
+
+    describe 'something in the cache' do
+      before do
+        cache.stubs(:get).with('http://www.example.com').returns \
+          data: body,
+          etag: 'A'
+      end
+
+      describe 'without validation' do
+        it 'should return a response with the cached data' do
+          responder.expects(:call).never
+          call
+          @body.must_equal body
+          @status.success?.must_equal true
+          @status.cached.must_equal true
+          @status.updated.must_equal false
+          @status.http.must_be_nil
+        end
+      end
+
+      describe 'with validation' do
+        let(:base) {
+          Commute::Context.new(stack).with(caching: {
+            cache: cache,
+            validate: true
+          }).context
+        }
+
+        it 'should verify the etag of the resource' do
+          responder.expects(:call).once.with do |router, request|
+            request.http.headers['If-None-Match'].must_equal 'A'
+          end
+          call
+        end
+
+        describe 'the resource was not modified' do
+          let(:status) { Commute::Http::Status.new(304) }
+
+          it 'it should respond without updating the cache' do
+            cache.expects(:set).never
+            call
+            @body.must_equal body
+            @status.success?.must_equal true
+            @status.cached.must_equal true
+            @status.updated.must_equal false
+            @status.http.wont_be_nil
+          end
+        end
+
+        describe 'the resource was modified' do
+          let(:status) { Commute::Http::Status.new(200) }
+
+          it 'it should respond and update the cache' do
+            cache.expects(:set).with('http://www.example.com', {
+              data: body,
+              etag: 'A'
+            })
+            call
+            @body.must_equal body
+            @status.success?.must_equal true
+            @status.cached.must_equal true
+            @status.updated.must_equal true
+            @status.http.wont_be_nil
+          end
+        end
+
+        describe 'the response was not succesful' do
+        end
+      end
+    end
+  end
+
+  private
+
+  def call
+    @body, @status = api.run
+  end
+end

data/spec/commute/common/eventmachine_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'commute/common/eventmachine'
+
+describe Commute::Common::Eventmachine do
+
+  let(:adapter) { Commute::Common::Eventmachine.new }
+
+  let(:router) { Commute::Stack::Router.new [adapter].each }
+
+  before do
+    @stub = stub_request(:post, "http://www.example.com/").with \
+      headers: {
+        'Accept-Encoding' => 'gzip, deflate'
+      },
+      body: 'Hello World!'
+
+    @done = proc {}
+  end
+
+  it 'should be able to make a successful request' do
+    @done.expects(:call).twice
+    EM.run do
+      # Stub the request.
+      @stub.to_return(status: 200, body: 'Hello!', headers: {})
+
+      # Create a Http Request.
+      http_request = Commute::Http::Request.new(nil).tap do |r|
+        r.uri = URI('http://www.example.com')
+        r.method = :post
+      end
+
+      # Execute the request.
+      request = router.call http_request do |response, status|
+        @done.call
+        status.success?.must_equal true
+        response.buffer.on(:data) do |body|
+          @done.call
+          body.join.must_equal 'Hello!'
+        end
+
+        EM.stop
+      end
+      request.write 'Hello'
+      request.write ' World!'
+      request.end
+    end
+  end
+
+it 'should be able to handle a bad response' do
+  @done.expects(:call).once
+    EM.run do
+      # Stub the request.
+      @stub.to_return(status: 500, headers: {})
+
+      # Create a Http Request.
+      http_request = Commute::Http::Request.new(nil).tap do |r|
+        r.uri = URI('http://www.example.com')
+        r.method = :post
+      end
+
+      # Execute the request.
+      request = router.call http_request do |response, status|
+        @done.call
+        status.fail?.must_equal true
+        response.on(:data) { @done.call }
+
+        EM.stop
+      end
+      request.write 'Hello'
+      request.write ' World!'
+      request.end
+    end
+  end
+end

data/spec/commute/common/typhoeus_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'commute/common/typhoeus'
+
+describe Commute::Common::Typhoeus do
+
+  let(:adapter) { Commute::Common::Typhoeus.new }
+
+  let(:router) { Commute::Stack::Router.new [adapter].each }
+
+  before do
+    @stub = stub_request(:post, "http://www.example.com/").with \
+      headers: {
+        'User-Agent' => 'Typhoeus - https://github.com/typhoeus/typhoeus'
+      },
+      body: 'Hello World!'
+  end
+
+  it 'should be able to make a successful request' do
+    # Stub the request.
+    @stub.to_return(status: 200, body: 'Hello!', headers: {})
+
+    # Create a Http Request.
+    http_request = Commute::Http::Request.new(nil).tap do |r|
+      r.uri = URI('http://www.example.com')
+      r.method = :post
+    end
+
+    # Execute the request.
+    response, body, status = nil, [], nil
+    request = router.call http_request do |_response, _status|
+      _response >> body
+      response, status = _response, _status
+    end
+    request.write 'Hello'
+    request.write ' World!'
+    request.end
+
+    # Do some checks.
+    status.success?.must_equal true
+    body.join.must_equal 'Hello!'
+  end
+
+  it 'should be able to handle a bad response' do
+    # Stub the request.
+    @stub.to_return(status: 500, headers: {})
+
+    # Create a Http Request.
+    http_request = Commute::Http::Request.new(nil).tap do |r|
+      r.uri = URI('http://www.example.com')
+      r.method = :post
+    end
+
+    # Execute the request.
+    response, body, status = nil, [], nil
+    request = router.call http_request do |_response, _status|
+      _response >> body
+      response, status = _response, _status
+    end
+    request.write 'Hello'
+    request.write ' World!'
+    request.end
+
+    # Do some checks.
+    status.fail?.must_equal true
+    body.must_be_empty
+  end
+end

data/spec/commute/core/api_spec.rb

@@ -48,14 +48,16 @@ describe Commute::Api do
   end
 
   it 'should create a new Api instance when a method is called on the class' do
+    api_klass.builder[:id].must_equal 1
     context = api_klass.with(id: 2).all.context
     context.parameters.must_equal id: 2, text: 'go', help: true
+    api_klass.builder[:id].must_equal 1
   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
+    context.stack.sequence.size.must_be :>=, 2
   end
 
   describe '#new' do

data/spec/commute/core/builder_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 require 'commute/core/context'
-require 'commute/core/request'
+require 'commute/core/http'
 
 describe Commute::Builder do
 
   let(:parameters) {{}}
-  let(:stack) { Commute::Stack.new { |stack, main|
-    main.append Proc.new {}
+  let(:stack) { Commute::Stack.new {
+    sequence.append Proc.new {}
   }}
   let(:transformations) {[]}
   let(:disables) {[]}
@@ -15,7 +15,7 @@ describe Commute::Builder do
 
   let(:builder) { Commute::Builder.new context }
 
-  let(:request) { Commute::Request.new }
+  let(:request) { Commute::Http::Request.new context }
 
   describe '#with' do
     it 'should add parameters to the context' do
@@ -82,18 +82,18 @@ describe Commute::Builder do
 
     it 'should be able to add a dynamic transform without dependencies' do
       context = builder.with(id: 1).transform { |request, context|
-        request.path = "/#{context[:id]}"
+        request.uri.path = "/#{context[:id]}"
       }.context
       context.transformations.first.call(request, context)
-      request.path.must_equal '/1'
+      request.uri.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}"
+        request.uri.path = "/#{id}"
       }.context
       context.transformations.first.call(request, context)
-      request.path.must_equal '/1'
+      request.uri.path.must_equal '/1'
     end
 
     it 'should never call the transformation when its dependencies are all nil' do