pakada-dispatch 0.0.1

data/.project

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>pakada-dispatch</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+	</buildSpec>
+	<natures>
+		<nature>com.aptana.ruby.core.rubynature</nature>
+	</natures>
+</projectDescription>

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "rake"
+gem "awesome_print"

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Lars Gierth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,4 @@
+Routing And Action Controllers For Pakada
+===================================================
+
+TODO: Write documentation

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler"
+Bundler.setup :development
+
+require "rspec/core/rake_task"
+
+task :default => :spec
+RSpec::Core::RakeTask.new :spec
+
+Bundler::GemHelper.install_tasks

data/lib/pakada-dispatch.rb

@@ -0,0 +1 @@
+require "pakada/dispatch"

data/lib/pakada/dispatch.rb

@@ -0,0 +1,43 @@
+require "pakada"
+require "rack/mount"
+
+require "pakada/dispatch/controller"
+require "pakada/dispatch/module"
+require "pakada/dispatch/version"
+
+class Pakada
+  class Dispatch
+    include Pakada::Module
+    
+    attr_reader :router
+    
+    def initialize
+      @router = Rack::Mount::RouteSet.new
+    end
+    
+    before :boot, :apply_dispatch_patches, :before => :all, do |ctx|
+      Pakada.modules.each_value do |m|
+        m.singleton_class.send :include, Pakada::Dispatch::Module
+      end
+    end
+    
+    before :boot, :load_controllers do |ctx|
+      Pakada.modules.each_value do |mod|
+        mod.load_controllers
+      end
+      Pakada.hooking.invoke :routing
+    end
+    
+    before :boot, :set_dispatch_app do |ctx|
+      Pakada.app = proc {|env| hookable :dispatch, env }
+    end
+    
+    after :boot, :freeze_router do |ctx|
+      router.rehash
+    end
+    
+    hookable :dispatch do |ctx|
+      ctx.result = router.call ctx.args
+    end
+  end
+end

data/lib/pakada/dispatch/controller.rb

@@ -0,0 +1,53 @@
+class Pakada
+  class Dispatch
+    Action = Struct.new :block, :options
+
+    module Controller
+      def self.build(&block)
+        Class.new do
+          include Controller
+          instance_eval &block if block
+        end
+      end
+      
+      attr_reader :request, :response, :params, :options
+      
+      def initialize(env)
+        @request, @response = Rack::Request.new(env), Rack::Response.new
+        @params = request.env["rack.routing_args"] || {}
+      end
+      
+      def call_action(name, options = {})
+        action = self.class.actions[name]
+        raise ArgumentError, "No such action - #{name}" unless action
+        
+        @options = action.options.merge options
+        instance_eval &action.block
+      end
+      
+      module ClassMethods
+        def actions
+          @actions ||= {}
+        end
+        
+        def action(name, options = {}, &block)
+          if block
+            actions[name] = Action.new block, options
+          elsif actions[name]
+            proc do |env|
+              controller = new env
+              controller.call_action name, options
+              controller.response.finish
+            end
+          else
+            proc {|env| [404, {"X-Cascade" => "pass"}, []] }
+          end
+        end
+      end
+      
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+    end
+  end
+end

data/lib/pakada/dispatch/module.rb

@@ -0,0 +1,70 @@
+class Pakada
+  class Dispatch
+    module Module
+      attr_reader :controllers
+      
+      def load_controllers
+        @controllers = {}
+        Dir["#{path}/controllers/*.rb"].each do |file|
+          next unless file.match %r{.*/[a-z0-9_]+\.rb$}
+          name = file.split("/").last.split(".").first
+          @controllers[name.to_sym] = Controller.build do
+            instance_eval File.read(file), file, 1
+          end
+        end if path
+      end
+      
+      def route(name = nil, opts)
+        route = opts.keys.find {|k| !k.kind_of? Symbol }
+        target = opts.delete route
+        splats = []
+        unless route.is_a? Regexp
+          route = route.gsub(/\((.*)\)/, '(\1)?')
+            .gsub(/:([a-z0-9\-_]+)/, '(?<\1>[a-z0-9\-_]+)')
+            .gsub(/\*([a-z0-9\-_]+)/) do |match|
+              splats << $1.to_sym
+              '(?<' + $1 + '>([a-z0-9\-_]/?)*)'
+            end
+          route = Regexp.compile "^#{route}$"
+        end
+        
+        defaults = opts.dup
+        target = "::" + target unless target.include? "::"
+        target = target + "#" unless target.include? "#"
+        parts = target.split /::|#/
+        defaults[:module] = parts[0].to_sym unless !parts[0] || parts[0].empty?
+        defaults[:controller] = parts[1].to_sym unless !parts[1] || parts[1].empty?
+        defaults[:action] = parts[2].to_sym unless !parts[2] || parts[2].empty?
+        
+        app = proc do |env|
+          env["pakada.dispatch.route"] = name
+          params = env["pakada.dispatch.params"] = env["rack.routing_args"].dup
+          
+          params.each_pair do |key, value|
+            if splats.include? key
+              params[key] = value.split("/").select {|v| !v.empty? }
+            end
+            if [:module, :controller, :action].include? key
+              params[key] = value.to_sym
+            end
+          end
+          
+          mod = Pakada[params[:module]]
+          controller = mod.controllers[params[:controller].to_sym] if mod
+          if controller
+            controller.action(params[:action].to_sym).call env
+          else
+            [404, {"X-Cascade" => "pass"}, []]
+          end
+        end
+        
+        defaults[:module] = module_name unless defaults[:module]
+        Pakada[:dispatch].router.add_route app, {:path_info => route}, defaults, name
+      end
+    end
+    
+    def url(*args)
+      router.url({}, *args)
+    end
+  end
+end

data/lib/pakada/dispatch/version.rb

@@ -0,0 +1,5 @@
+class Pakada
+  class Dispatch
+    VERSION = "0.0.1"
+  end
+end

data/pakada-dispatch.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pakada/dispatch/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pakada-dispatch"
+  s.version     = Pakada::Dispatch::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Lars Gierth"]
+  s.email       = ["lars.gierth@gmail.com"]
+  s.homepage    = "https://rubygems.org/gems/pakada-dispatch"
+  s.summary     = %q{Routing And Action Controllers For Pakada}
+  #s.description = %q{TODO: Write a gem description}
+
+  s.add_dependency "pakada"
+  s.add_dependency "rack-mount"
+  
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "fakefs"
+
+  s.files         = `git ls-files`.split("\n") - [".gitignore", ".rvmrc"]
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/controller_spec.rb

@@ -0,0 +1,138 @@
+require "spec_helper"
+
+describe Pakada::Dispatch::Controller do
+  describe ".build" do
+    it "builds an empty controller class" do
+      subject.build.should respond_to(:action)
+      subject.build.should have(0).actions
+    end
+    
+    describe "when called with a block" do
+      it "executes the block in the class' context" do
+        subject.build { action(:foo) {} }.should have(1).actions
+      end
+    end
+  end
+end
+
+describe "SomeController" do
+  subject do
+    Pakada::Dispatch::Controller.build
+  end
+  
+  describe ".action" do
+    describe "when called with a block" do
+      it "adds an action to the controller" do
+        block = proc {}
+        subject.action :foo, &block
+        subject.actions[:foo].options.should == {}
+        subject.actions[:foo].block.should == block
+      end
+    end
+    
+    describe "when called with a block and a hash" do
+      it "adds an action with options" do
+        options = double "options"
+        block = proc {}
+        subject.action :foo, options, &block
+        subject.actions[:foo].options.should == options
+      end
+    end
+    
+    describe "when called without a block" do
+      it "builds a Rack end-point" do
+        subject.action(:foo) {}
+        
+        env = {"foo" => "123"}
+        options = {:key => :value}
+        response = stub "response", :finish => [200, {}, []]
+        controller = stub "controller", :response => response
+        
+        subject.should_receive(:new).twice.with(env) { controller }
+        
+        controller.should_receive(:call_action).once.with(:foo, {})
+        subject.action(:foo).call(env).should == response.finish
+        
+        controller.should_receive(:call_action).once.with(:foo, options)
+        subject.action(:foo, options).call(env)
+      end
+      
+      describe "when called with the name of a non-existing action" do
+        it "builds an X-Cascade: pass app" do
+          subject.action(:foo).call({}).should == [
+            404, {"X-Cascade" => "pass"}, []]
+        end
+      end
+    end
+  end
+  
+  describe "#initialize" do
+    it "sets up Rack::Request and Response objects" do
+      env = {"foo" => "123"}
+      controller = subject.new env
+      
+      controller.request.env.should == env
+      controller.response.should respond_to(:finish)
+    end
+    
+    it "populates #params with the routing parameters" do
+      params = {:foo => :bar}
+      controller = subject.new "rack.routing_args" => params
+      controller.params.should == params
+      
+      controller = subject.new({})
+      controller.params.should == {}
+    end
+  end
+  
+  describe "#call_action" do
+    it "invokes the action's block in the controller's scope" do
+      subject.action(:foo) { do_something }
+      controller = subject.new({})
+      controller.should_receive :do_something
+      
+      controller.call_action :foo
+    end
+    
+    it "populates #options" do
+      subject.action(:foo, :key => :value) {}
+      controller = subject.new({})
+      
+      controller.call_action :foo
+      controller.options[:key].should == :value
+    end
+    
+    describe "when called with the name of a non-existing action" do
+      it "raises an error" do
+        controller = subject.new({})
+        proc { controller.call_action :foo }.should raise_error(ArgumentError)
+      end
+    end
+    
+    describe "when called with a hash" do
+      it "overrides the action's options" do
+        subject.action(:foo, :key => :value) {}
+        controller = subject.new({})
+        
+        controller.call_action :foo, :key => :value2
+        controller.options[:key].should == :value2
+      end
+    end
+  end
+end
+
+describe Pakada::Dispatch::Action do
+  describe "#block" do
+    it "returns the action's code block" do
+      block = double "block"
+      Pakada::Dispatch::Action.new(block).block.should == block
+    end
+  end
+  
+  describe "#options" do
+    it "returns the actions' options hash" do
+      options = double "options"
+      Pakada::Dispatch::Action.new(nil, options).options.should == options
+    end
+  end
+end

data/spec/dispatch_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+describe Pakada::Dispatch do
+  subject { Pakada::Dispatch.new }
+  
+  it "is a Pakada module" do
+    subject.module_name.should == :dispatch
+  end
+  
+  describe ".initialize" do
+    it "initializes the router" do
+      subject.router.should respond_to :add_route
+      subject.router.should respond_to :call
+    end
+  end
+  
+  describe ".before(:boot, :apply_dispatch_patches)" do
+    before do
+      Pakada.load_modules
+      Pakada.load_hooking
+    end
+    
+    it "freedom-patches all loaded modules" do
+      Pakada.hooking.invoke :boot
+      Pakada.modules.each_value do |m|
+        modules = m.singleton_class.included_modules
+        modules.should include(Pakada::Dispatch::Module)
+      end
+    end
+  end
+  
+  describe ".before(:boot, :load_controllers)" do
+    before do
+      Pakada.load_modules
+      Pakada.load_hooking
+    end
+    
+    it "calls .load_controllers on each module" do
+      Pakada.modules.each_value do |mod|
+        mod.should_receive :load_controllers
+      end
+      Pakada.hooking.invoke :boot
+    end
+  end
+  
+  describe ".before(:boot, :set_dispatch_app)" do
+    it "overwrites Pakada.app with its own app" do
+      Pakada.load_modules
+      Pakada.load_hooking
+      Pakada.hooking.invoke :boot
+      
+      req = {"key" => "value"}
+      resp = [200, {}, []]
+      Pakada.hooking.should_receive(:invoke).with(:dispatch, req) { resp }
+      Pakada.app.call(req).should == resp
+    end
+  end
+  
+  describe ".before(:boot, :freeze_router)" do
+    it "freezes the router" do
+      Pakada.load_modules
+      Pakada.load_hooking
+      
+      Pakada[:dispatch].router.should_receive :rehash
+      Pakada.hooking.invoke :boot
+    end
+  end
+  
+  describe ".hookable(:dispatch)" do
+    it "passes the request to the router" do
+      Pakada.load_modules
+      Pakada.load_hooking
+      
+      req = {"key" => "value"}
+      resp = [200, {}, []]
+      Pakada[:dispatch].router.should_receive(:call).with(req) { resp }
+      Pakada.hooking.invoke(:dispatch, req).should == resp
+    end
+  end
+end

data/spec/module_spec.rb

@@ -0,0 +1,298 @@
+require "spec_helper"
+
+describe Pakada::Dispatch::Module do
+  describe "#load_controllers" do
+    before do
+      FakeFS.activate!
+    end
+    
+    subject do
+      FileUtils.mkdir_p "/mymodule/controllers"
+      File.open "/mymodule/controllers/foo.rb", "w" do |f|
+        f.write "action(:foo) {}"
+      end
+      
+      Class.new do
+        @module_name, @path = :foo, "/mymodule"
+        include Pakada::Module
+        include Pakada::Dispatch::Module
+      end.new
+    end
+    
+    it "iterates over the module's controllers/ directory and builds a controller for each file" do
+      subject.load_controllers
+      subject.controllers[:foo].should have(1).actions
+    end
+    
+    it "does nothing if the module doesn't have a path" do
+      subject.class.instance_variable_set :@path, nil
+      subject.load_controllers
+      subject.should have(0).controllers
+    end
+    
+    after do
+      FakeFS.deactivate!
+      FakeFS::FileSystem.clear
+      
+      Pakada::Module.descendants.delete :foo
+    end
+  end
+  
+  describe "#route" do
+    describe "when called without a symbol" do
+      it "creates an anonymous route" do
+        Pakada.boot
+        
+        Pakada[:dispatch].router.should_receive(:add_route) do |*args|
+          args[0].should respond_to(:call)
+          args[1][:path_info].should be_a(Regexp)
+          args[2].should == {
+            :module => :dispatch,
+            :controller => :foo,
+            :action => :bar
+          }
+          args[3].should be_nil
+        end
+        Pakada[:dispatch].route "/pattern" => "foo#bar"
+      end
+    end
+    
+    describe "takes a hash that" do
+      before { Pakada.boot }
+      
+      subject { Pakada[:dispatch] }
+      
+      it "contains a route-pattern => target-action pair" do
+        subject.router.should_receive(:add_route) do |*args|
+          args[0].should respond_to(:call)
+          args[1][:path_info].should == %r{^/pattern$}
+          args[2].should == {
+            :module => :foo,
+            :controller => :bar,
+            :action => :baz
+          }
+          args[3].should == :myroute
+        end
+        subject.route :myroute, "/pattern" => "foo::bar#baz"
+      end
+      
+      it "can contain default values for parameters" do
+        subject.router.should_receive(:add_route) do |*args|
+          args[0].should respond_to(:call)
+          args[1][:path_info].should == %r{^/pattern$}
+          args[2].should == {
+            :module => :dispatch,
+            :controller => :foo,
+            :action => :bar,
+            :key => :value
+          }
+          args[3].should == :myroute
+        end
+        subject.route :myroute, "/pattern" => "#bar", :key => :value, :controller => :foo
+      end
+      
+      it "whose contained default values won't override the target-action" do
+        subject.router.should_receive(:add_route) do |*args|
+          args[0].should respond_to(:call)
+          args[1][:path_info].should be_a(Regexp)
+          args[2].should == {
+            :module => :dispatch,
+            :controller => :foo,
+            :action => :bar
+          }
+          args[3].should == :myroute
+        end
+        subject.route :myroute, "/pattern" => "foo#bar", :action => :baz
+      end
+    end
+  end
+  
+  describe "#route's route-pattern" do
+    before { Pakada.boot }
+    
+    subject { Pakada[:dispatch] }
+    
+    it "can contain :normal parameters" do
+      subject.router.should_receive(:add_route) do |*args|
+        args[1][:path_info].should == %r{^/(?<key>[a-z0-9\-_]+)/(?<key2>[a-z0-9\-_]+)$}
+      end
+      subject.route :myroute, "/:key/:key2" => ""
+    end
+    
+    it "can contain *splat parameters" do
+      subject.router.should_receive(:add_route) do |*args|
+        args[1][:path_info].should == %r{^/(?<key>([a-z0-9\-_]/?)*)$}
+      end
+      subject.route :myroute, "/*key" => ""
+    end
+    
+    it "can contain optional parts" do
+      subject.router.should_receive(:add_route) do |*args|
+        args[1][:path_info].should == %r{^(/(?<key>[a-z0-9\-_]+))?/(?<key2>[a-z0-9\-_]+)$}
+      end
+      subject.route :myroute, "(/:key)/:key2" => ""
+    end
+  end
+  
+  describe "#route's target-action" do
+    before { Pakada.boot }
+    
+    subject { Pakada[:dispatch] }
+    
+    it "uses the current module's name as default :module parameter" do
+      subject.router.should_receive :add_route do |*args|
+        args[2].should == {
+          :module => :dispatch
+        }
+      end
+      subject.route "/" => ""
+    end
+    
+    it "can consist of a controller and an action" do
+      subject.router.should_receive :add_route do |*args|
+        args[2].should == {
+          :module => :dispatch,
+          :controller => :foo,
+          :action => :bar
+        }
+      end
+      subject.route "/" => "foo#bar"
+    end
+    
+    it "can consist of an action" do
+      subject.router.should_receive :add_route do |*args|
+        args[2].should == {
+          :module => :dispatch,
+          :action => :bar
+        }
+      end
+      subject.route "/" => "#bar"
+    end
+    
+    it "can consist of a controller" do
+      subject.router.should_receive :add_route do |*args|
+        args[2].should == {
+          :module => :dispatch,
+          :controller => :foo
+        }
+      end
+      subject.route "/" => "foo"
+    end
+    
+    it "can consist of a module" do
+      subject.router.should_receive :add_route do |*args|
+        args[2].should == {
+          :module => :mymodule,
+        }
+      end
+      subject.route "/" => "mymodule::"
+    end
+    
+    it "can consist of a module and a controller" do
+      subject.router.should_receive :add_route do |*args|
+        args[2].should == {
+          :module => :mymodule,
+          :controller => :foo
+        }
+      end
+      subject.route "/" => "mymodule::foo"
+    end
+    
+    it "can consist of a module and an action" do
+      subject.router.should_receive :add_route do |*args|
+        args[2].should == {
+          :module => :mymodule,
+          :action => :bar
+        }
+      end
+      subject.route "/" => "mymodule::#bar"
+    end
+  end
+  
+  describe "#route's Rack end-point" do
+    def stub_action(route, params = {}, route_name = nil, &block)
+      params = {
+        :module => subject.module_name,
+        :controller => :bar,
+        :action => :baz
+      }.merge(params)
+      
+      controller, action = double("controller"), double("action")
+      subject.controllers[:bar] = controller
+      controller.should_receive(:action).with(:baz).and_return(action)
+      action.should_receive(:call) {|env| block.call env }
+      
+      subject.router.should_receive :add_route do |app, *nothing|
+        app.call "rack.routing_args" => params
+      end
+      subject.route route_name, route => ""
+    end
+    
+    before { Pakada.boot }
+    
+    subject { Pakada[:dispatch] }
+    
+    it "splits splat parameters" do
+      stub_action "/*something", :something => "/some///thing/123" do |env|
+        env["pakada.dispatch.params"][:something].should == ["some", "thing", "123"]
+      end
+    end
+    
+    it "makes sure the module, controller and action params are symbols" do
+      stub_action "/", {
+        :module => subject.module_name.to_s,
+        :controller => "bar",
+        :action => "baz"
+      } do |env|
+        [:module, :controller, :action].each do |k|
+          env["pakada.dispatch.params"][k].should be_kind_of(Symbol)
+        end
+      end
+    end
+    
+    it "calls the respective action" do
+      called = false
+      stub_action("/") {|env| called = true }
+      
+      called.should be_true
+    end
+    
+    it "returns an X-Cascade: pass response if the module or controller doesn't exist" do
+      subject.router.should_receive :add_route do |app, *nothing|
+        env = {"rack.routing_args" => {
+          :module => :dispatch,
+          :controller => :bar,
+          :action => :foofoofoo
+        }}
+        app.call(env).should == [404, {"X-Cascade" => "pass"}, []]
+      end
+      subject.route "/" => ""
+    end
+    
+    it "puts the matched route's name into the environment if it has a name" do
+      stub_action "/with_name", {}, :myroute do |env|
+        env["pakada.dispatch.route"].should == :myroute
+      end
+      
+      stub_action "/without_name" do |env|
+        env["pakada.dispatch.route"].should be_nil
+      end
+    end
+  end
+  
+  describe "#uri" do
+    before { Pakada.boot }
+    
+    subject { Pakada[:dispatch] }
+    
+    it "passes over to #router.url" do
+      subject.route :myroute, "/:key" => "foo#bar", :key => "value"
+      
+      subject.router.should_receive(:url).with({}, :myroute, :key => "value2").and_return("/value2")
+      subject.url(:myroute, :key => "value2").should == "/value2"
+      
+      subject.router.should_receive(:url).with({}).and_return("/")
+      subject.url.should == "/"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require "bundler"
+Bundler.setup :default, :development
+
+require "pakada/dispatch"
+
+require "fakefs/safe"
+
+begin
+  require "awesome_print"
+rescue LoadError; end
+
+RSpec.configure do |config|
+  config.before(:each) { Pakada.reset_instance }
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification 
+name: pakada-dispatch
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Lars Gierth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-25 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: pakada
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rack-mount
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: fakefs
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+description: 
+email: 
+- lars.gierth@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .project
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/pakada-dispatch.rb
+- lib/pakada/dispatch.rb
+- lib/pakada/dispatch/controller.rb
+- lib/pakada/dispatch/module.rb
+- lib/pakada/dispatch/version.rb
+- pakada-dispatch.gemspec
+- spec/controller_spec.rb
+- spec/dispatch_spec.rb
+- spec/module_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://rubygems.org/gems/pakada-dispatch
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -75253869
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -75253869
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Routing And Action Controllers For Pakada
+test_files: []
+