commute 0.1.2 → 0.2.0.rc.1

data/spec/commute/core/commuter_spec.rb

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

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

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

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

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

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

data/spec/commute/core/sequence_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+require 'commute/core/sequence'
+
+describe Commute::Sequence do
+
+  let(:sequence) { Commute::Sequence.new }
+
+  let(:processor1) {
+    lambda { |result, subject, options = {}| result + 1 }
+  }
+
+  let(:processor2) {
+    lambda { |result, subject, options = {}| result * 2 }
+  }
+
+  let(:processor3) {
+    Class.new {
+      @id = :test
+
+      def call result, subject, options = {}
+        result ** options[:power]
+      end
+    }.new
+  }
+
+  describe '#new' do
+    it 'should alter the sequence when a block is provided' do
+      sequence = Commute::Sequence.new do |s|
+        s.append processor1
+      end
+      sequence.processors.size.must_equal 1
+    end
+  end
+
+  describe '#alter' do
+    it 'should alter the sequence in a block when the arity is 1' do
+      sequence.alter do |s|
+        s.append processor1
+      end
+      sequence.processors.size.must_equal 1
+    end
+
+    it 'should evaluate the block when the arity is 0' do
+      sequence.alter do
+        append Proc.new { |n| n.data += 1 }
+      end
+      sequence.processors.size.must_equal 1
+    end
+  end
+
+  describe '#processors' do
+    it 'should return an empty array when there are no processors' do
+      sequence.processors.must_equal []
+    end
+
+    it 'should not return a modifiable array' do
+      sequence.processors << 'test'
+      sequence.processors.must_be_empty
+    end
+  end
+
+  describe '#processors=' do
+
+    it 'should not exist' do
+      Proc.new { sequence.processors = nil }.must_raise NoMethodError
+    end
+  end
+
+  describe '#call' do
+    let(:processor1) do
+      Proc.new do |commuter|
+        commuter.change { |n| n+1 }
+      end
+    end
+
+    let(:processor2) do
+      Proc.new do |commuter, operation|
+        commuter.change { |n| n.send operation, n }
+      end
+    end
+
+    let(:commuter) { Commute::Commuter.new mock, 1 }
+
+    it 'should call all processors' do
+      commuter.expects(:parameters).with(nil).never
+      commuter.expects(:parameters).with(:operator).returns(:**)
+      sequence.append(processor1)
+      sequence.append(processor2, as: :operator)
+      sequence.call commuter
+      commuter.get.must_equal 4
+    end
+
+    # This is not tested implicitely due to the Proc usage.
+    it 'should call processors with the correct number of arguments' do
+      commuter.expects(:parameters).with(:operator).returns(:+)
+      processor1 = mock
+      processor1.expects(:call).with(commuter)
+      processor2 = mock
+      processor2.expects(:call).with(commuter, :+)
+      sequence.append processor1
+      sequence.append processor2, as: :operator
+      sequence.call commuter
+    end
+
+    it 'should be a processor itself' do
+      commuter.expects(:parameters).with(:operator).returns(:**)
+
+      subsequence = Commute::Sequence.new do |s|
+        s.append processor1
+      end
+
+      sequence = Commute::Sequence.new do |s|
+        s.append subsequence
+        s.append processor2, as: :operator
+      end
+
+      sequence.call commuter
+      commuter.get.must_equal 4
+    end
+
+    it 'should return nothing' do
+      Commute::Sequence.new { |s|
+        s.append processor1
+      }.call(commuter).must_equal nil
+    end
+  end
+
+  describe '#append' do
+    it 'should append the processor to the tail' do
+      sequence.append processor1
+      sequence.processors.must_equal [processor1]
+      assert_equal sequence.append(processor2),  processor2
+      sequence.processors.must_equal [processor1, processor2]
+    end
+
+    it 'should be able to override the default processor id' do
+      sequence.append processor1, as: :increment
+      sequence.at(:increment).call(1, nil).must_equal 2
+
+      sequence.append processor3, as: :power
+      sequence.at(:power).must_equal processor3
+    end
+
+    it 'should be able to append after a specified processor' do
+      sequence.append processor1, as: :increment
+      sequence.append processor2
+
+      sequence.append processor3, as: :power, after: :increment
+      sequence.processors.must_equal [processor1, processor3, processor2]
+    end
+  end
+
+  describe '#remove' do
+    before do
+      sequence.append processor1
+      sequence.append processor2, as: :multiplier
+    end
+
+    it 'should remove the processor if the processor itself is given' do
+      processor = sequence.remove processor1
+      (processor == processor1).must_equal true
+      sequence.processors.must_equal [processor2]
+      assert_equal sequence.at(:multiplier), processor2
+    end
+
+    it 'should remove the processor if its id is given' do
+      processor = sequence.remove :multiplier
+      (processor == processor2).must_equal true
+      sequence.processors.must_equal [processor1]
+      sequence.at(:multiplier).must_be_nil
+    end
+  end
+
+  describe '#at' do
+    it 'should index processors with a default id' do
+      sequence.append processor3
+      sequence.at(:test).must_equal processor3
+    end
+  end
+
+  describe '#dup' do
+    it 'should duplicate the sequence' do
+      sequence.append processor1
+      cloned = sequence.dup
+      cloned.append processor2
+      sequence.processors.size.must_equal 1
+      cloned.processors.size.must_equal 2
+    end
+  end
+end

data/spec/commute/core/stack_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'commute/core/context'
+require 'commute/core/stack'
+
+describe Commute::Stack do
+
+  let(:sequence) do
+    Commute::Sequence.new do
+      append Proc.new { |n| n.data += 1 }
+    end
+  end
+
+  let(:stack) do
+    Commute::Stack.new do |stack, main|
+    end
+  end
+
+  describe '#initialize' do
+    describe 'when no sequence is given' do
+      it 'should yield the main sequence for the stack when the arity is 1' do
+        stack = Commute::Stack.new do |sequence|
+          sequence.append Proc.new {}
+        end
+        stack.sequence.processors.size.must_equal 1
+      end
+
+      it 'should yield the stack and the main sequence when the arity is 2' do
+        stack = Commute::Stack.new do |stack, sequence|
+          sequence.append Proc.new {}
+        end
+        stack.sequence.processors.size.must_equal 1
+      end
+    end
+
+    describe 'when a sequence is given' do
+      it 'should use that sequence' do
+        sequence = Commute::Sequence.new do
+          append Proc.new {}
+        end
+        stack = Commute::Stack.new sequence
+        stack.sequence.processors.size.must_equal 1
+      end
+    end
+  end
+
+  describe '#add' do
+    it 'should add a sequence to the stack by name' do
+      stack.add sequence, :calculation
+      stack.sequence(:calculation).must_equal sequence
+    end
+  end
+
+  describe '#sequence' do
+    it 'should add the sequence when it was not found' do
+      stack.sequence(:calculation) do
+        append Proc.new { |c| c.set(c.get + 1) }
+      end
+
+      stack.sequence(:calculation).processors.size.must_equal 1
+    end
+  end
+
+  describe '#sequencer' do
+    it 'should allow us to embed a sequence in a sequence' do
+      stack = Commute::Stack.new do |stack, sequence|
+        sequence.append Commute::Sequencer.new(:calculation)
+        sequence.append Proc.new { |c|
+          c.change { |n| "The result is #{n}" }
+        }
+
+        stack.sequence(:calculation) do
+          append Proc.new { |c| c.set(c.get + 1) }
+          append Proc.new { |c| c.set(c.get + 2) }
+        end
+      end
+      commuter = Commute::Commuter.new(Commute::Context.new(stack), 1)
+      stack.call(commuter)
+      commuter.get.must_equal 'The result is 4'
+    end
+  end
+
+  describe '#dup' do
+    it 'should duplicate the stack and all its sequences' do
+      stack.add sequence, :calculation
+      cloned = stack.dup.alter do
+        sequence.append Proc.new {}
+
+        sequence(:calculation).append Proc.new {}
+      end
+      stack.sequence.processors.size.must_equal 0
+      stack.sequence(:calculation).processors.size.must_equal 1
+      cloned.sequence.processors.size.must_equal 1
+      cloned.sequence(:calculation).processors.size.must_equal 2
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -6,9 +6,8 @@ SimpleCov.start
 require 'minitest/autorun'
 require 'minitest/spec'
 
-require 'mocha'
+require 'dominance/minitest'
 
-require 'webmock'
-require 'webmock/minitest'
+require 'mocha'
 
 require 'commute'

metadata

@@ -1,18 +1,34 @@
 --- !ruby/object:Gem::Specification
 name: commute
 version: !ruby/object:Gem::Version
-  version: 0.1.2
-  prerelease: 
+  version: 0.2.0.rc.1
+  prerelease: 6
 platform: ruby
 authors:
 - Mattias Putman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-18 00:00:00.000000000 Z
+date: 2012-11-22 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.5.0.rc
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.0.rc
+- !ruby/object:Gem::Dependency
+  name: em-http-request
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -163,6 +179,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .todo
 - .travis.yml
 - Gemfile
 - Guardfile
@@ -170,17 +187,48 @@ files:
 - README.md
 - Rakefile
 - commute.gemspec
+- examples/gist_api.rb
+- examples/highrise_task_api.rb
+- examples/pastie_api.rb
 - 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/aspects/caching.rb
+- lib/commute/aspects/crud.rb
+- lib/commute/aspects/pagination.rb
+- lib/commute/aspects/url.rb
+- lib/commute/common/basic_auth.rb
+- lib/commute/common/cache.rb
+- lib/commute/common/chemicals.rb
+- lib/commute/common/conditional.rb
+- lib/commute/common/em-synchrony_adapter.rb
+- lib/commute/common/em_http_request_adapter.rb
+- lib/commute/common/json.rb
+- lib/commute/common/typhoeus_adapter.rb
+- lib/commute/common/xml.rb
+- lib/commute/configuration.rb
+- lib/commute/core/api.rb
+- lib/commute/core/builder.rb
+- lib/commute/core/commuter.rb
+- lib/commute/core/context.rb
+- lib/commute/core/processors/code_status_processor.rb
+- lib/commute/core/processors/hook.rb
+- lib/commute/core/processors/request_builder.rb
+- lib/commute/core/processors/sequencer.rb
+- lib/commute/core/request.rb
+- lib/commute/core/response.rb
+- lib/commute/core/sequence.rb
+- lib/commute/core/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/commute/aspects/caching_spec.rb
+- spec/commute/aspects/url_spec.rb
+- spec/commute/core/api_spec.rb
+- spec/commute/core/builder_spec.rb
+- spec/commute/core/commuter_spec.rb
+- spec/commute/core/processors/code_status_processor_spec.rb
+- spec/commute/core/processors/hook_spec.rb
+- spec/commute/core/processors/request_builder_spec.rb
+- spec/commute/core/processors/sequencer_spec.rb
+- spec/commute/core/sequence_spec.rb
+- spec/commute/core/stack_spec.rb
 - spec/spec_helper.rb
 homepage: http://challengee.github.com/commute/
 licenses: []
@@ -197,9 +245,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.19
@@ -209,9 +257,16 @@ summary: ! 'Commute helps you to: 1) Dynamically build HTTP requests for your fa
   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/commute/aspects/caching_spec.rb
+- spec/commute/aspects/url_spec.rb
+- spec/commute/core/api_spec.rb
+- spec/commute/core/builder_spec.rb
+- spec/commute/core/commuter_spec.rb
+- spec/commute/core/processors/code_status_processor_spec.rb
+- spec/commute/core/processors/hook_spec.rb
+- spec/commute/core/processors/request_builder_spec.rb
+- spec/commute/core/processors/sequencer_spec.rb
+- spec/commute/core/sequence_spec.rb
+- spec/commute/core/stack_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/lib/commute/adapters/typhoeus.rb

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

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