chickadee 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5bcb4cef05aca78538224ff2212092ab72bea7ca
-  data.tar.gz: e93f3c823ccf6911931b6ccf3dcf314a584bcd34
+  metadata.gz: 2c94ac31b90bdc338d7fde56dcc3197cd5cc3dda
+  data.tar.gz: 0114a62df6b8770ed3e43422ad77aef00f48ba64
 SHA512:
-  metadata.gz: b73a763034b866983accad6d7b8b4873bf75a4d623f75d024289afc81d6fc8f39f134a2fa8e26d4df18c0333f0ba3c23de67ce7ddd6070a8ae3aa2422a04f17a
-  data.tar.gz: 5c305b328b9855a187ddaa68927630775e900fe131dcfcad1bf27e929474a1d1e7dd2d93451255999e31864febe58e49c5b502b7ee531f34b98c3ba88d94e2a2
+  metadata.gz: ad5ee648a68d9274a1dbab7ca17208c266787f2e3eef24fba786ab3837ad7670555deabd2d4cfd39e05ff6a452fb47769e613d9f98f8deeb5e05604a489aa814
+  data.tar.gz: 2d3b5eaa405012bc49a44f2ac29a309cbecbf8ed7c52318dd7e3c22b50a0c94b5504893a8150c15b4a8e72bf08cbf22cad56e1159b558470169be58dd6391340

data/chickadee.gemspec

@@ -18,9 +18,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "ioc", "~> 0.5.0"
+  spec.add_dependency "ioc", "~> 2.1.0"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "mocha", "~> 0.14.0"
-end
+end

data/lib/chickadee/dispatcher.rb

@@ -0,0 +1,32 @@
+module Chickadee
+  class Dispatcher
+    def self.install(*installers)
+      [*installers].inject(new) do |d, installer|
+        installer.install(d)
+        d
+      end
+    end
+
+    def initialize
+      @container = Container.new
+      @dispatcher_manager = DispatcherManager.new(
+        CommandDispatcher.new(@container),
+        QueryDispatcher.new(@container),
+        EventDispatcher.new(@container),
+      )
+      @container.register(:event_dispatcher, @dispatcher_manager.event_dispatcher, :as => :instance)
+    end
+
+    def register(*args)
+      @container.register(*args)
+    end
+
+    def map(*args)
+      @dispatcher_manager.map(*args)
+    end
+
+    def dispatch(*args)
+      @dispatcher_manager.dispatch(*args)
+    end
+  end
+end

data/lib/chickadee/dispatchers/command_dispatcher.rb

@@ -0,0 +1,19 @@
+module Chickadee
+  class CommandDispatcher < RequestDispatcher
+    def map(request_key, *handlers)
+      raise(DispatcherError, "Command already mapped: #{request_key}") if bus.topic_exists?(request_key)
+      bus.subscribe(request_key) {|req| resolve_handler_chain(*handlers).handle(req)}
+    end
+
+    def dispatch(request)
+      bus.publish(request.class, request)
+      nil
+    end
+
+    private
+
+    def bus
+      @bus ||= MessageBus.new
+    end
+  end
+end

data/lib/chickadee/dispatchers/dispatcher_manager.rb

@@ -0,0 +1,47 @@
+module Chickadee
+  class DispatcherManager
+
+    attr_reader :command_dispatcher, :query_dispatcher, :event_dispatcher
+    
+    def initialize(container, command_dispatcher, query_dispatcher, event_dispatcher)
+      @container = container
+      @command_dispatcher = command_dispatcher
+      @event_dispatcher = event_dispatcher
+      @query_dispatcher = query_dispatcher
+    end
+
+    def map(request_key, *handlers)
+      send("map_#{request_key.type}", request_key, *handlers)
+    end
+
+    def dispatch(request)
+      send("dispatch_#{request.class.type}", request)
+    end
+
+    private
+
+    def map_command(*args)
+      @command_dispatcher.map(*args)
+    end
+
+    def map_query(*args)
+      @query_dispatcher.map(*args)
+    end
+
+    def map_event(*args)
+      @event_dispatcher.map(*args)
+    end
+
+    def dispatch_command(*args)
+      @command_dispatcher.dispatch(*args)
+    end
+
+    def dispatch_query(*args)
+      @query_dispatcher.dispatch(*args)
+    end
+
+    def dispatch_event(*args)
+      @event_dispatcher.dispatch(*args)
+    end
+  end
+end

data/lib/chickadee/dispatchers/event_dispatcher.rb

@@ -0,0 +1,22 @@
+module Chickadee
+  class EventDispatcher < RequestDispatcher
+    def map(request_key, *handlers)
+      bus.subscribe(request_key) {|req| resolve_handler_chain(*handlers).handle(req)}
+    end
+
+    def dispatch(request)
+      bus.publish(request.class, request)
+      nil
+    end
+
+    def raise(*args)
+      dispatch(*args)
+    end
+
+    private
+
+    def bus
+      @bus ||= MessageBus.new
+    end
+  end
+end

data/lib/chickadee/dispatchers/handler_chain_struct.rb

@@ -0,0 +1,17 @@
+module Chickadee
+  class HandlerChainStruct
+    def self.new(*parameter_names, &block)
+      klass = Class.new(&block)
+      klass.class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def initialize(#{parameter_names.map(&:to_s).join(", ")})     # def initialize(user_repo, session_repo)
+          @handlers = [#{parameter_names.map(&:to_s).join(", ")}]     #   @handlers = [user_repo, session_repo]
+        end                                                           # end
+
+        def handle(request)
+          @handlers.map {|h| h.handle(request)}.last
+        end
+      EOT
+      klass
+    end
+  end
+end

data/lib/chickadee/dispatchers/message_bus.rb

@@ -0,0 +1,65 @@
+module Chickadee
+  class MessageBus
+    class Topic
+      attr_reader :subscribers
+
+      def initialize
+        @subscribers = []
+      end
+
+      def subscribe(obj)
+        @subscribers << obj
+      end
+
+      def unsubscribe(subscriber_id)
+        @subscribers.delete_if{|subscriber| subscriber.id == subscriber_id}
+      end
+    end
+
+    class Subscriber
+      attr_reader :id
+
+      def initialize(id, &block)
+        @id = id
+        @block = block
+      end
+
+      def call(*args)
+        @block.call(*args)
+      end
+    end
+
+    def initialize
+      @topics = {}
+      @subscriber_id = -1
+    end
+
+    def subscribe(topic_key, &block)
+      subscriber = Subscriber.new(next_subscriber_id, &block)
+      get_topic(topic_key).subscribe(subscriber)
+      subscriber.id
+    end
+
+    def unsubscribe(subscriber_id)
+      @topics.each {|topic_key, topic| topic.unsubscribe(subscriber_id)}
+    end
+
+    def publish(topic_key, *args)
+      get_topic(topic_key).subscribers.each {|s| s.call(*args)}
+    end
+
+    def topic_exists?(key)
+      @topics.keys.include?(key)
+    end
+
+    private
+
+    def get_topic(topic_key)
+      @topics[topic_key] ||= Topic.new
+    end
+
+    def next_subscriber_id
+      @subscriber_id = @subscriber_id + 1
+    end
+  end
+end

data/lib/chickadee/dispatchers/query_dispatcher.rb

@@ -0,0 +1,18 @@
+module Chickadee
+  class QueryDispatcher < RequestDispatcher
+    def map(request_key, *handlers)
+      raise(DispatcherError, "Query already mapped: #{request_key}") if cache.key?(request_key)
+      cache[request_key] = Proc.new{|req| resolve_handler_chain(*handlers).handle(req)}
+    end
+
+    def dispatch(request)
+      cache[request.class].call(request)
+    end
+
+    private
+
+    def cache
+      @cache ||= {}
+    end
+  end
+end

data/lib/chickadee/dispatchers/request_dispatcher.rb

@@ -0,0 +1,21 @@
+module Chickadee
+  class RequestDispatcher
+    def initialize(container)
+      @container = container
+    end
+
+    def map(request_key, *handlers)
+      raise(NotImplementedError)
+    end
+
+    def dispatch(request)
+      raise(NotImplementedError)
+    end
+
+    private
+
+    def resolve_handler_chain(*handlers)
+      @container.resolve_anonymous(HandlerChainStruct.new(*handlers))
+    end
+  end
+end

data/lib/chickadee/exceptions.rb

@@ -1,4 +1,5 @@
 module Chickadee
   class ChickadeeError < StandardError; end
-  class RoutingError < ChickadeeError; end
+  class DispatcherError < ChickadeeError; end
+  class HandlerNotFound < ChickadeeError; end
 end

data/lib/chickadee/requests/command.rb

@@ -0,0 +1,4 @@
+module Chickadee
+  class Command < Request
+  end
+end

data/lib/chickadee/requests/event.rb

@@ -0,0 +1,4 @@
+module Chickadee
+  class Event < Request
+  end
+end

data/lib/chickadee/requests/query.rb

@@ -0,0 +1,4 @@
+module Chickadee
+  class Query < Request
+  end
+end

data/lib/chickadee/{request.rb → requests/request.rb}

@@ -8,10 +8,14 @@ module Chickadee
       request_type == :query
     end
 
+    def event?
+      request_type == :event
+    end
+
     private
 
     def request_type
-      raise(NotImplementedError)
+      self.class.name.split('::').last.downcase.to_sym
     end
   end
 end

data/lib/chickadee/version.rb

@@ -1,3 +1,3 @@
 module Chickadee
-  VERSION = "0.0.1"
+  VERSION = "1.0.0"
 end

data/lib/chickadee.rb

@@ -2,13 +2,18 @@ require 'ioc'
 require 'chickadee/version'
 require 'chickadee/exceptions'
 require 'chickadee/container'
-require 'chickadee/router'
-require 'chickadee/request'
-require 'chickadee/query'
-require 'chickadee/command'
-require 'chickadee/handler'
-require 'chickadee/registry'
-require 'chickadee/application'
+require 'chickadee/requests/request'
+require 'chickadee/requests/command'
+require 'chickadee/requests/query'
+require 'chickadee/requests/event'
+require 'chickadee/dispatchers/handler_chain_struct'
+require 'chickadee/dispatchers/message_bus'
+require 'chickadee/dispatchers/request_dispatcher'
+require 'chickadee/dispatchers/event_dispatcher'
+require 'chickadee/dispatchers/command_dispatcher'
+require 'chickadee/dispatchers/query_dispatcher'
+require 'chickadee/dispatchers/dispatcher_manager'
+require 'chickadee/dispatcher'
 
 module Chickadee
 end

data/spec/dispatchers/command_dispatcher_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'chickadee'
+
+describe Chickadee::CommandDispatcher do
+  it 'can map handler chain to request' do
+    container = define_container
+    dispatcher = define_dispatcher(container)
+    command = Chickadee::Command.new
+    handler1 = stub(:handle => 'handler1_response')
+    handler2 = stub(:handle => 'handler2_response')
+
+    container.register(:myhandler1, handler1, :as => :instance)
+    container.register(:myhandler2, handler2, :as => :instance)
+
+    dispatcher.map(Chickadee::Command, :myhandler1, :myhandler2)
+
+    handler1.expects(:handle).once
+    handler2.expects(:handle).once
+    dispatcher.dispatch(command)
+  end
+
+  it 'complains if same command mapped twice' do
+    container = define_container
+    dispatcher = define_dispatcher(container)
+    command = Chickadee::Command.new
+
+    dispatcher.map(Chickadee::Command, stub)
+    proc{ dispatcher.map(Chickadee::Command, stub) }.must_raise(Chickadee::DispatcherError)
+  end
+
+  it 'returns nothing' do
+    container = define_container
+    dispatcher = define_dispatcher(container)
+    command = Chickadee::Command.new
+    handler1 = stub(:handle => 'handler1_response')
+
+    container.register(:myhandler1, handler1, :as => :instance)
+
+    dispatcher.map(Chickadee::Command, :myhandler1)
+    dispatcher.dispatch(command).must_be_nil
+  end
+
+
+  def define_container
+    Chickadee::Container.new
+  end
+
+  def define_dispatcher(*args)
+    Chickadee::CommandDispatcher.new(*args)
+  end
+
+  def define_command
+    Chickadee::Command.new
+  end
+end

data/spec/dispatchers/event_dispatcher_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'chickadee'
+
+describe Chickadee::EventDispatcher do
+  it 'can map handler chain to request' do
+    container = define_container
+    dispatcher = define_dispatcher(container)
+    event = Chickadee::Event.new
+    handler1 = stub(:handle => 'handler1_response')
+    handler2 = stub(:handle => 'handler2_response')
+
+    container.register(:myhandler1, handler1, :as => :instance)
+    container.register(:myhandler2, handler2, :as => :instance)
+
+    dispatcher.map(Chickadee::Event, :myhandler1, :myhandler2)
+
+    handler1.expects(:handle).once
+    handler2.expects(:handle).once
+    dispatcher.dispatch(event)
+  end
+
+  it 'can map multiple handler chains to request' do
+    container = define_container
+    dispatcher = define_dispatcher(container)
+    event = Chickadee::Event.new
+    handler1 = stub(:handle => 'handler1_response')
+    handler2 = stub(:handle => 'handler2_response')
+    handler3 = stub(:handle => 'handler3_response')
+    handler4 = stub(:handle => 'handler4_response')
+
+    container.register(:myhandler1, handler1, :as => :instance)
+    container.register(:myhandler2, handler2, :as => :instance)
+    container.register(:myhandler3, handler3, :as => :instance)
+    container.register(:myhandler4, handler4, :as => :instance)
+
+    dispatcher.map(Chickadee::Event, :myhandler1, :myhandler2)
+    dispatcher.map(Chickadee::Event, :myhandler3, :myhandler4)
+
+    handler1.expects(:handle).once
+    handler2.expects(:handle).once
+    handler3.expects(:handle).once
+    handler4.expects(:handle).once
+    dispatcher.dispatch(event)
+  end
+
+  it 'returns nothing' do
+    container = define_container
+    dispatcher = define_dispatcher(container)
+    event = Chickadee::Event.new
+    handler1 = stub(:handle => 'handler1_response')
+
+    container.register(:myhandler1, handler1, :as => :instance)
+
+    dispatcher.map(Chickadee::Event, :myhandler1)
+    dispatcher.dispatch(event).must_be_nil
+  end
+
+
+  def define_container
+    Chickadee::Container.new
+  end
+
+  def define_dispatcher(*args)
+    Chickadee::EventDispatcher.new(*args)
+  end
+
+  def define_event
+    Chickadee::Event.new
+  end
+end

data/spec/dispatchers/handler_chain_struct_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'chickadee'
+
+describe Chickadee::HandlerChainStruct do
+  it 'generates handler class' do
+    person_class1 = struct_class.new(:first_name, :last_name)
+    person_class2 = struct_class.new(:first_name, :last_name)
+    person_class1.wont_equal(person_class2)
+  end
+
+  describe 'instance' do
+    describe '#handle' do
+      it 'delegates handle method to handlers in chain' do
+        request = stub
+        handler1 = stub
+        handler2 = stub
+        handler_chain_class = struct_class.new(:handler1, :handler2)
+        handler_chain = handler_chain_class.new(handler1, handler2)
+        
+        handler1.expects(:handle).with(request)
+        handler2.expects(:handle).with(request)
+        handler_chain.handle(request)
+      end 
+    end
+  end
+
+  def struct_class
+    Chickadee::HandlerChainStruct
+  end
+end

data/spec/dispatchers/message_bus_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'chickadee'
+
+describe Chickadee::MessageBus do
+  it 'can register block with bus topic' do
+    bus = new_bus
+
+    output = nil
+    
+    bus.subscribe("topic") do |msg|
+      output = msg
+    end
+
+    output.must_be_nil
+    bus.publish("topic", 'the proc was called')
+    output.must_equal('the proc was called')
+  end
+
+  it 'can pubish a message for a given topic' do
+    bus = new_bus
+
+    output1 = nil
+    output2 = nil
+
+    bus.subscribe("topic1") { |msg| output1 = msg }
+    bus.subscribe("topic2") { |msg| output2 = msg }
+
+    bus.publish("topic1", 'message for topic1')
+    bus.publish("topic2", 'message for topic2')
+
+    output1.must_equal('message for topic1')
+    output2.must_equal('message for topic2')
+  end
+
+  it 'can unsubscribe a listener' do
+    bus = new_bus
+
+    output = nil
+    subscriber_id = bus.subscribe("topic") { |msg| output = msg }
+    
+    bus.publish("topic", 'i received the message')
+    output.must_equal('i received the message')
+
+    bus.publish("topic", 'i received the message a second time')
+    output.must_equal('i received the message a second time')
+
+    bus.unsubscribe(subscriber_id)
+
+    bus.publish("topic", 'i received the message a third time')
+    output.must_equal('i received the message a second time')
+  end
+
+  it 'can publish any number of arguments' do
+    bus = new_bus
+
+    output1 = nil
+    output2 = nil
+    
+    bus.subscribe("topic") do |arg1, arg2|
+      output1 = arg1
+      output2 = arg2
+    end
+
+    bus.publish("topic", 'myarg1', 'myarg2')
+
+    output1.must_equal('myarg1')
+    output2.must_equal('myarg2')
+  end
+  
+  def new_bus
+    Chickadee::MessageBus.new
+  end
+end

data/spec/dispatchers/query_dispatcher_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'chickadee'
+
+describe Chickadee::QueryDispatcher do
+  it 'can map handler chain to request' do
+    container = define_container
+    dispatcher = define_dispatcher(container)
+    query = Chickadee::Query.new
+    handler1 = stub(:handle => 'handler1_response')
+    handler2 = stub(:handle => 'handler2_response')
+
+    container.register(:myhandler1, handler1, :as => :instance)
+    container.register(:myhandler2, handler2, :as => :instance)
+
+    dispatcher.map(Chickadee::Query, :myhandler1, :myhandler2)
+
+    handler1.expects(:handle).once
+    handler2.expects(:handle).once
+    dispatcher.dispatch(query)
+  end
+
+  it 'complains if same query mapped twice' do
+    container = define_container
+    dispatcher = define_dispatcher(container)
+    query = Chickadee::Query.new
+
+    dispatcher.map(Chickadee::Query, stub)
+    proc{ dispatcher.map(Chickadee::Query, stub) }.must_raise(Chickadee::DispatcherError)
+  end
+
+  it 'returns output from last handler in chain' do
+    container = define_container
+    dispatcher = define_dispatcher(container)
+    query = Chickadee::Query.new
+    handler1 = stub(:handle => 'handler1_response')
+    handler2 = stub(:handle => 'handler2_response')
+
+    container.register(:myhandler1, handler1, :as => :instance)
+    container.register(:myhandler2, handler2, :as => :instance)
+
+    dispatcher.map(Chickadee::Query, :myhandler1, :myhandler2)
+    dispatcher.dispatch(query).must_equal('handler2_response')
+  end
+
+
+  def define_container
+    Chickadee::Container.new
+  end
+
+  def define_dispatcher(*args)
+    Chickadee::QueryDispatcher.new(*args)
+  end
+
+  def define_query
+    Chickadee::Query.new
+  end
+end

data/spec/{command_spec.rb → requests/command_spec.rb}

@@ -4,6 +4,7 @@ require 'chickadee'
 describe Chickadee::Command do
   it { new_query.query?.must_equal(false) }
   it { new_query.command?.must_equal(true) }
+  it { new_query.event?.must_equal(false) }
 
   def new_query
     Chickadee::Command.new

data/spec/requests/event_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'chickadee'
+
+describe Chickadee::Event do
+  it { new_query.query?.must_equal(false) }
+  it { new_query.command?.must_equal(false) }
+  it { new_query.event?.must_equal(true) }
+
+  def new_query
+    Chickadee::Event.new
+  end
+end

data/spec/{query_spec.rb → requests/query_spec.rb}

@@ -4,6 +4,7 @@ require 'chickadee'
 describe Chickadee::Query do
   it { new_query.query?.must_equal(true) }
   it { new_query.command?.must_equal(false) }
+  it { new_query.event?.must_equal(false) }
 
   def new_query
     Chickadee::Query.new

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chickadee
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Erik Lott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-08 00:00:00.000000000 Z
+date: 2014-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ioc
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -81,21 +81,29 @@ files:
 - Rakefile
 - chickadee.gemspec
 - lib/chickadee.rb
-- lib/chickadee/application.rb
-- lib/chickadee/command.rb
 - lib/chickadee/container.rb
+- lib/chickadee/dispatcher.rb
+- lib/chickadee/dispatchers/command_dispatcher.rb
+- lib/chickadee/dispatchers/dispatcher_manager.rb
+- lib/chickadee/dispatchers/event_dispatcher.rb
+- lib/chickadee/dispatchers/handler_chain_struct.rb
+- lib/chickadee/dispatchers/message_bus.rb
+- lib/chickadee/dispatchers/query_dispatcher.rb
+- lib/chickadee/dispatchers/request_dispatcher.rb
 - lib/chickadee/exceptions.rb
-- lib/chickadee/handler.rb
-- lib/chickadee/query.rb
-- lib/chickadee/registry.rb
-- lib/chickadee/request.rb
-- lib/chickadee/router.rb
+- lib/chickadee/requests/command.rb
+- lib/chickadee/requests/event.rb
+- lib/chickadee/requests/query.rb
+- lib/chickadee/requests/request.rb
 - lib/chickadee/version.rb
-- spec/chickadee_spec.rb
-- spec/command_spec.rb
-- spec/query_spec.rb
-- spec/registry_spec.rb
-- spec/router_spec.rb
+- spec/dispatchers/command_dispatcher_spec.rb
+- spec/dispatchers/event_dispatcher_spec.rb
+- spec/dispatchers/handler_chain_struct_spec.rb
+- spec/dispatchers/message_bus_spec.rb
+- spec/dispatchers/query_dispatcher_spec.rb
+- spec/requests/command_spec.rb
+- spec/requests/event_spec.rb
+- spec/requests/query_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses:
@@ -122,9 +130,12 @@ signing_key:
 specification_version: 4
 summary: Lightweight domain driven design library
 test_files:
-- spec/chickadee_spec.rb
-- spec/command_spec.rb
-- spec/query_spec.rb
-- spec/registry_spec.rb
-- spec/router_spec.rb
+- spec/dispatchers/command_dispatcher_spec.rb
+- spec/dispatchers/event_dispatcher_spec.rb
+- spec/dispatchers/handler_chain_struct_spec.rb
+- spec/dispatchers/message_bus_spec.rb
+- spec/dispatchers/query_dispatcher_spec.rb
+- spec/requests/command_spec.rb
+- spec/requests/event_spec.rb
+- spec/requests/query_spec.rb
 - spec/spec_helper.rb

data/lib/chickadee/application.rb

@@ -1,27 +0,0 @@
-module Chickadee
-  class Application
-    def self.routes
-      @router ||= Router.new
-    end
-
-    def self.registry
-      @internal_registry ||= Registry.new
-    end
-
-    def initialize
-      @external_registry = Registry.new
-    end
- 
-    def call(request)
-      container = Container.new
-      self.class.registry.update_container(container)
-      @external_registry.update_container(container)
-      output = self.class.routes.call(request.class).map{|handler| container[handler].handle(request)}.last
-      output if request.query?
-    end
-
-    def register(name, service)
-      @external_registry.register(name, service, :as => :instance)
-    end
-  end
-end

data/lib/chickadee/command.rb

@@ -1,10 +0,0 @@
-module Chickadee
-  class Command < Request
-
-    private
-
-    def request_type
-      :command
-    end
-  end
-end

data/lib/chickadee/handler.rb

@@ -1,7 +0,0 @@
-module Chickadee
-  class Handler
-    def handle(request)
-      raise(NotImplementedError)
-    end
-  end
-end

data/lib/chickadee/query.rb

@@ -1,10 +0,0 @@
-module Chickadee
-  class Query < Request
-
-    private
-
-    def request_type
-      :query
-    end
-  end
-end

data/lib/chickadee/registry.rb

@@ -1,19 +0,0 @@
-module Chickadee
-  class Registry
-    def initialize
-      @registrants = []
-    end
-
-    def draw(&block)
-      instance_eval(&block) if block_given?
-    end
-
-    def register(*args)
-      @registrants << args
-    end
-
-    def update_container(container)
-      @registrants.each{|args| container.register(*args)}
-    end
-  end
-end

data/lib/chickadee/router.rb

@@ -1,78 +0,0 @@
-module Chickadee
-  class Router
-    class RequestMap
-      def initialize(map = {})
-        @map = map
-      end
-
-      def call(request)
-        if @map.key?(request)
-          @map.fetch(request).call(request)
-        else
-          app = @map[:app]
-          raise(RoutingError, 'missing run statement') unless app
-          app.call(request)
-        end
-      end
-    end
-
-    class Middleware
-      def initialize(app, handler)
-        @app = app
-        @handler = handler
-      end
-
-      def call(request)
-        @app.call(request).unshift(@handler)
-      end
-    end
-    
-    def initialize(default_app = nil, &block)
-      @run = default_app
-      @use = []
-      @map = nil
-      instance_eval(&block) if block_given?
-    end
-
-    def draw(&block)
-      instance_eval(&block) if block_given?
-    end
-
-    def use(handler, &block)
-      if @map
-        mapping = @map
-        @map = nil
-        @use << proc { |app| generate_map(app, mapping) }
-      end
-      @use << proc { |app| Middleware.new(app, handler, &block) }
-    end
-
-    def run(handler)
-      @run = proc{|request| [handler]}
-    end
-
-    def map(method_name, &block)
-      @map ||= {}
-      @map[method_name] = block
-    end
-
-    def to_app
-      app = @map ? generate_map(@run, @map) : @run
-      raise(RoutingError, 'missing run or map statement') unless app
-      app = @use.reverse.inject(app) { |a,e| e[a] }
-      app
-    end
-
-    def call(request)
-      to_app.call(request)
-    end
-
-    private
-
-    def generate_map(default_app, mapping)
-      mapped = default_app ? {:app => default_app} : {}
-      mapping.each { |r,b| mapped[r] = self.class.new(default_app, &b) }
-      RequestMap.new(mapped)
-    end
-  end
-end

data/spec/chickadee_spec.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-require 'chickadee'
-
-describe Chickadee do
-
-  class TestCommand1 < Chickadee::Command
-    attr_accessor :name
-  end
-
-  class TestQuery1 < Chickadee::Query
-    attr_accessor :name
-  end
-
-  class TestHandler1 < Chickadee::Handler
-    def handle(command)
-      "hander1 says: #{command.name}"
-    end
-  end
-
-  class TestHandler2 < Chickadee::Handler
-    def handle(command)
-      "hander2 says: #{command.name}"
-    end
-  end
-
-  context 'when command request' do
-    it 'returns nil from command' do
-      app_class = new_app_class
-      app_class.routes.draw do
-        map(TestCommand1) do
-          run :handler1
-        end
-      end
-      app_class.registry.draw do
-        register(:handler1, TestHandler1)
-      end
-
-      app = app_class.new
-      command = TestCommand1.new
-      command.name = 'Chuck Norris'
-      app.call(command).must_be_nil
-    end
-
-    it 'executes handler chain' do
-      app_class = new_app_class
-
-      handler1 = TestHandler1.new
-      handler2 = TestHandler2.new
-
-      app_class.routes.draw do
-        map(TestCommand1) do
-          use :handler1
-          run :handler2
-        end
-      end
-
-      app_class.registry.draw do
-        register(:handler1, handler1, :as => :instance)
-        register(:handler2, handler2, :as => :instance)
-      end
-
-      app = app_class.new
-      command = TestCommand1.new
-
-      handler1.expects(:handle).with(command)
-      handler2.expects(:handle).with(command)
-
-      app.call(command)
-    end
-  end
-
-  context 'when query request' do
-    it 'returns output from last handler in handler chain' do
-      app_class = new_app_class
-
-      handler1 = TestHandler1.new
-      handler2 = TestHandler2.new
-
-      app_class.routes.draw do
-        map(TestQuery1) do
-          use :handler1
-          run :handler2
-        end
-      end
-
-      app_class.registry.draw do
-        register(:handler1, handler1, :as => :instance)
-        register(:handler2, handler2, :as => :instance)
-      end
-
-      app = app_class.new
-      query = TestQuery1.new
-      query.name = 'Chuck Norris'
-      app.call(query).must_equal('hander2 says: Chuck Norris')
-    end
-
-    it 'executes handler chain' do
-      app_class = new_app_class
-
-      handler1 = TestHandler1.new
-      handler2 = TestHandler2.new
-
-      app_class.routes.draw do
-        map(TestQuery1) do
-          use :handler1
-          run :handler2
-        end
-      end
-
-      app_class.registry.draw do
-        register(:handler1, handler1, :as => :instance)
-        register(:handler2, handler2, :as => :instance)
-      end
-
-      app = app_class.new
-      query = TestQuery1.new
-
-      handler1.expects(:handle).with(query)
-      handler2.expects(:handle).with(query)
-
-      app.call(query)
-    end
-  end
-
-  def new_app_class
-    Class.new(Chickadee::Application)
-  end
-end

data/spec/registry_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-require 'chickadee'
-
-describe Chickadee::Registry do
-  describe '#update_container' do
-    it 'updates container with registered services' do
-      registry = new_registry
-      service = stub
-      container = new_container
-
-      registry.register(:myservice, service, :as => :instance)
-      registry.update_container(container)
-      container.resolve(:myservice).must_equal(service)
-    end
-  end
-
-  describe '#draw' do
-    it 'can register with block' do
-      registry = new_registry
-      service = stub
-
-      registry.draw do
-        register(:service, service)
-      end
-
-      registry.instance_variable_get(:@registrants).must_equal([[:service, service]])
-    end
-  end
-
-  def new_registry
-    Chickadee::Registry.new
-  end
-
-  def new_container
-    Chickadee::Container.new
-  end
-end

data/spec/router_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-require 'chickadee'
-
-describe Chickadee::Router do
-  it 'chains handlers' do
-    request = stub
-
-    app = builder do
-      use :handler1
-      run :handler2
-    end
-
-    app.call(request).must_equal([:handler1, :handler2])
-  end
-
-  it 'supports use after run' do
-    request = stub
-    app = builder do
-      use :handler1
-      run :handler2
-      use :handler3
-    end
-    
-    app.call(request).must_equal([:handler1, :handler3, :handler2])
-  end
-
-  it 'complains when there is no run' do
-    request = stub
-    app = builder do
-      use :handler1
-    end
-    
-    proc { app.call(request) }.must_raise(Chickadee::RoutingError)
-  end
-
-  it 'supports mapping' do
-    request = stub
-    app = builder do
-      map(request) do
-        use :handler1
-        run :handler2
-      end
-    end
-
-    app.call(request).must_equal([:handler1, :handler2])
-  end
-
-  it 'complains when there is no run with mapping' do
-    request = stub
-    app = builder do
-      use :handler1
-      map(request) do
-        use :handler2
-      end
-    end
-
-    proc { app.call(request) }.must_raise(Chickadee::RoutingError)
-  end
-
-  it 'correctly maps complex senario' do
-    request1 = stub
-    request2 = stub
-    
-    app = builder do
-      use :handler1
-
-      map(request1) do
-        use :handler2
-        run :handler3
-      end
-
-      use :handler4
-
-      map(request2) do
-        use :handler5
-      end
-
-      run :handler6
-    end
-
-    app.call(request1).must_equal([:handler1, :handler2, :handler3])
-    app.call(request2).must_equal([:handler1, :handler4, :handler5, :handler6])
-    app.call(nil).must_equal([:handler1, :handler4, :handler6])
-  end
-
-  def builder(&block)
-    Chickadee::Router.new(&block)
-  end
-end