pakada 0.2.1 → 0.3.0

data/.yardopts

@@ -0,0 +1 @@
+- LICENSE ROADMAP.md

data/Gemfile

@@ -4,3 +4,6 @@ gemspec
 
 gem "awesome_print"
 gem "rake"
+
+gem "fakefs", :git => "https://github.com/lgierth/fakefs",
+              :branch => "fix_infinite_loop"

data/README.md

@@ -1,4 +1,15 @@
-Very Extensible HTTP Container For Ruby
-=======================================
+Modularization contract for web applications
+============================================
+
+Pakada is about modular web applications: how should they look like? How should
+modules interact with each other to fit a certain idea?
+
+TODO
+----
+
+- Thread and Fiber safety
+- Documentation
+- Basic CLI for creating projects/modules
+- Create instances via CLI
+- Project templates/profiles (e.g. Blog, Forum, etc.)
 
-TODO: Write documentation

data/lib/pakada/module.rb

@@ -9,13 +9,13 @@ class Pakada
         klass.send :include, Hooked
         
         class << klass
-          attr_reader :module_name, :path
+          attr_reader :pakada_name, :path, :dependencies
         end
         
-        unless klass.module_name
-          klass.instance_variable_set :@module_name, detect_name(klass.to_s)
+        unless klass.pakada_name
+          klass.instance_variable_set :@pakada_name, detect_name(klass.to_s)
         end
-        unless klass.module_name
+        unless klass.pakada_name
           raise "Could not detect name for module #{klass}"
         end
         
@@ -25,6 +25,10 @@ class Pakada
           klass.instance_variable_set :@path, detect_path(file)
         end
         
+        unless klass.dependencies
+          klass.instance_variable_set :@dependencies, []
+        end
+        
         @descendants << klass
       end
       
@@ -56,14 +60,18 @@ class Pakada
       end
     end
     
-    def module_name
-      self.class.module_name
+    def pakada_name
+      self.class.pakada_name
     end
     
     def path
       self.class.path
     end
     
+    def dependencies
+      self.class.dependencies
+    end
+    
     def boot; end
     
     def hooks; end

data/lib/pakada/version.rb

@@ -1,3 +1,3 @@
 class Pakada
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/pakada.rb

@@ -1,88 +1,155 @@
-require "rack"
 require "hooked"
+require "pathname"
+require "rack"
 
 require "pakada/module"
 require "pakada/version"
 
 class Pakada
-  DEFAULT_APP = proc {|req_env| Pakada.request req_env }
-
-  attr_reader :env, :modules, :middleware
-  attr_accessor :app
+  include Hooked
   
-  def initialize
-    @middleware = []
+  @instances = {}
+  @stack = []
+  
+  class << self
+    attr_reader :instances, :stack
+  end
+  
+  def self.instance(name = nil, &block)
+    return @stack.last unless name
+    return instances[name] unless block
+    
+    unless instances[name]
+      dsl = Struct.new(:urls, :modules, :path).new
+      ret = block.call(dsl)
+      
+      config = Hash[*dsl.members.map {|m| m.to_sym }.zip(dsl.values).flatten(1)]
+      instances[name] = new(name, config)
+    else
+      @stack << instances[name]
+      begin
+        ret = block.call(instances[name])
+      ensure
+        @stack.pop
+      end
+    end
+    
+    ret
   end
   
-  def development?
+  def self.boot
+    instance(:default) {|ins| ins.urls = ["/"] } if instances.empty?
+    
+    @urlmap = Rack::URLMap.new instances.values.inject({}) {|map, ins|
+      ins.urls.each {|url|
+        map[url] = proc {|env|
+          instance(ins.name) { ins.call env }
+        }
+      }
+      map
+    }
+    
+    instances.values.each {|ins|
+      instance(ins.name) { ins.boot }
+    }
+  end
+  
+  def self.call(env)
+    @urlmap.call env
+  end
+
+  def self.env
+    (ENV["RACK_ENV"] || :development).to_sym
+  end
+  
+  def self.development?
     env == :development
   end
   
-  def testing?
+  def self.testing?
     env == :testing
   end
   
-  def production?
+  def self.staging?
+    env == :staging
+  end
+  
+  def self.production?
     env == :production
   end
   
-  def [](name)
-    modules[name]
+  def self.modules
+    instance.modules if instance
   end
   
-  def boot
-    load_env
-    load_modules
-    load_hooks
-    
-    modules.each_value {|m| m.boot } unless testing?
+  def self.[](pakada_name)
+    modules[pakada_name] if modules
+  end
+  
+  def self.middleware
+    instance.middleware if instance
+  end
+  
+  def self.urls
+    instance.urls if instance
   end
   
-  def load_env
-    @env = (ENV["RACK_ENV"] || :development).to_sym
+  def self.path
+    instance.path if instance
   end
   
-  def load_modules
-    @modules = Pakada::Module.descendants.inject({}) do |h, m|
-      h[m.module_name] = m.new; h
+  attr_reader :name, :urls, :path
+  attr_reader :modules, :middleware
+  
+  def initialize(name, config = {})
+    @name = name
+    config[:urls]    ||= []
+    config[:modules] ||= Module.descendants
+    config[:path]    ||= name == :default ? "" : "instances/#{name}"
+    
+    modules, resolved = Array(config[:modules]).dup, false
+    until resolved
+      j ||= modules.size
+      i, j = j, 0
+      
+      modules.reverse[0...i].map {|mod|
+        mod.dependencies
+      }.flatten.each {|dep|
+        unless modules.include? dep
+          modules << dep
+          j += 1
+        end
+      }
+      
+      resolved = true if j == 0
     end
+    @modules = modules.inject({}) {|hash, mod|
+      hash[mod.pakada_name] = mod.new; hash
+    }
+    
+    path = File.expand_path(config[:path])
+    @urls, @path = Array(config[:urls]), Pathname.new(path)
+    @middleware = []
   end
   
-  def load_hooks
-    modules.each_value {|m| m.hooks } unless testing?
+  def boot
+    [:hooks, :boot].each {|m|
+      modules.each_value {|mod| mod.send m }
+    } unless Pakada.testing?
   end
   
   def call(req_env)
-    to_app.call req_env 
+    to_app.call req_env
   end
   
   def to_app
-    builder = Rack::Builder.new
-    middleware.each {|mw| builder.use *(Array === mw ? mw : [mw]) }
-    builder.run app || DEFAULT_APP
-    builder.to_app
+    Rack::Builder.new.tap {|b|
+      middleware.each {|mw| b.use *(Array === mw ? mw : [mw]) }
+      b.run proc {|req_env| request req_env }
+    }.to_app
   end
   
   def request(req_env)
     Rack::Response.new("Hi, I'm Pakada #{VERSION}").finish
   end
-  
-  class << self
-    def instance
-      @instance ||= new
-    end
-    
-    def reset_instance
-      @instance = nil
-    end
-    
-    def method_missing(m, *args, &block)
-      super(m, *args, &block) unless instance.respond_to? m
-      instance.send m, *args, &block
-    end
-    
-    def respond_to?(m, private = false)
-      super(m, private) || instance.respond_to?(m, private)
-    end
-  end
 end

data/pakada.gemspec

@@ -9,17 +9,19 @@ Gem::Specification.new do |s|
   s.authors     = ["Lars Gierth"]
   s.email       = ["lars.gierth@gmail.com"]
   s.homepage    = "https://rubygems.org/gems/pakada"
-  s.summary     = %q{Very Extensible HTTP Container For Ruby}
+  s.summary     = %q{Modularization contract for web applications}
   #s.description = %q{TODO: Write a gem description}
 
   s.add_dependency "rack"
-  s.add_dependency "hooked", "~> 0.2"
+  s.add_dependency "hooked"
 
   s.add_development_dependency "rspec"
   s.add_development_dependency "fakefs"
   s.add_development_dependency "fakefs-require"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "rdiscount"
 
-  s.files         = `git ls-files`.split("\n") - [".gitignore", ".rvmrc", "config.ru"]
+  s.files         = `git ls-files`.split("\n") - [".gitignore", ".travis.yml", "config.ru"]
   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"]

data/spec/module_spec.rb

@@ -67,7 +67,7 @@ describe Pakada::Module do
       klass = Class.new
       Pakada::Module.should_receive(:detect_name).with(klass.to_s).once { :some_module }
       klass.send(:include, Pakada::Module)
-      klass.module_name.should == :some_module
+      klass.pakada_name.should == :some_module
     end
     
     it "crashes if it can't detect a name" do
@@ -79,10 +79,10 @@ describe Pakada::Module do
     it "respects an already set name" do
       Pakada::Module.should_not_receive(:detect_name)
       klass = Class.new do
-        @module_name = :some_module
+        @pakada_name = :some_module
         include Pakada::Module
       end
-      klass.module_name.should == :some_module
+      klass.pakada_name.should == :some_module
     end
     
     it "tries to determine the module's path" do
@@ -97,7 +97,7 @@ describe Pakada::Module do
       
       Pakada::Module.should_receive(:detect_path).with(file).once { path }
       klass = Class.new do
-        @module_name = :some_module
+        @pakada_name = :some_module
         include Pakada::Module
       end
       klass.path.should == path
@@ -108,7 +108,7 @@ describe Pakada::Module do
     it "respects an already set path" do
       Pakada::Module.should_not_receive(:detect_path)
       klass = Class.new do
-        @module_name = :some_module
+        @pakada_name = :some_module
         @path = "/my/path"
         include Pakada::Module
       end
@@ -117,7 +117,7 @@ describe Pakada::Module do
     
     it "adds the module to the list of descendants" do
       klass = Class.new do
-        @module_name = :some_module
+        @pakada_name = :some_module
         include Pakada::Module
       end
       Pakada::Module.descendants.should include(klass)
@@ -128,7 +128,7 @@ end
 describe "SomeModule" do
   before :each do
     @klass = Class.new do
-      @module_name = :foo
+      @pakada_name = :foo
       @path = "/opt/pakada"
       include Pakada::Module
     end
@@ -147,13 +147,13 @@ describe "SomeModule" do
     @obj.should respond_to(:hooked)
   end
   
-  describe ".module_name" do
+  describe ".pakada_name" do
     it "contains the module's name" do
-      @klass.module_name.should == :foo
+      @klass.pakada_name.should == :foo
     end
     
     it "is read-only" do
-      proc { @klass.module_name = :bar }.should raise_error(NoMethodError)
+      proc { @klass.pakada_name = :bar }.should raise_error(NoMethodError)
     end
   end
   
@@ -167,9 +167,9 @@ describe "SomeModule" do
     end
   end
   
-  describe "#module_name" do
-    it "is a shortcut for ::module_name" do
-      @obj.module_name.should == @klass.module_name
+  describe "#pakada_name" do
+    it "is a shortcut for ::pakada_name" do
+      @obj.pakada_name.should == @klass.pakada_name
     end
   end
   

data/spec/pakada_spec.rb

@@ -1,235 +1,339 @@
 require "spec_helper"
 
 describe Pakada do
-  subject { Pakada.instance }
-  
-  it "forwards all messages to the Singleton instance" do
-    Pakada.instance.should_receive(:message)
-    Pakada.message
-    
-    proc { Pakada.other_message }.should raise_error(NoMethodError, /`other_message'/)
-  end
-  
-  it "forwards .respond_to? to the Singleton instance" do
-    Pakada.instance.should_receive(:respond_to?).with(:message, true) { true }
-    Pakada.respond_to?(:message, true).should be_true
-    
-    Pakada.instance.should_not_receive(:respond_to?).with(:instance)
-    Pakada.respond_to?(:instance)
-  end
-  
-  describe ".instance" do
-    it "creates a new Singleton instance and returns it" do
-      Pakada.stub(:new) { double "a Pakada instance" }
-      Pakada.instance.should == Pakada.instance
+  context ".instance" do
+    it "returns the instances stack's top element" do
+      Pakada.instance.should be_nil
+      
+      Pakada.instances[:foo] = stub("instance")
+      Pakada.instance(:foo) {|ins|
+        Pakada.instance.should equal(ins)
+      }
+      
+      Pakada.instance.should be_nil
     end
   end
   
-  describe ".reset_instance" do
-    it "unsets the Singleton instance" do
-      instance = Pakada.instance
-      Pakada.reset_instance
-      Pakada.instance.should_not == instance
+  context ".instance(name)" do
+    let(:ins) { stub "instance" }
+    
+    it "returns the specified instance" do
+      Pakada.instance(:i_dont_exist).should be_nil
+      
+      Pakada.instances[:foo] = ins
+      Pakada.instance(:foo).should equal(ins)
     end
   end
   
-  describe ".boot" do
-    before :each do
-      subject.stub :load_env
-      subject.stub :load_modules
-      subject.stub :load_hooks
-      
-      modules = [:foo, :bar, :baz].inject({}) do |modules, name|
-        modules[name] = stub "#{name} module", :boot => nil
-        modules
-      end
-      subject.stub(:modules).and_return modules
+  context ".instance(name, &block)" do
+    before do
+      Pakada.stub :instances => {
+        :foo => stub("instance: foo"),
+        :bar => stub("instance: bar")
+      }
     end
     
-    it "calls .load_env" do
-      subject.should_receive :load_env
-      subject.boot
-    end
-
-    it "calls .load_modules" do
-      subject.should_receive :load_modules
-      subject.boot
-    end
+    let(:foo) { Pakada.instances[:foo] }
+    let(:bar) { Pakada.instances[:bar] }
     
-    it "calls .load_hooks" do
-      subject.should_receive :load_hooks
-      subject.boot
+    it "executes the block in the specified instance's context" do
+      Pakada.instance(:foo) {|ins|
+        ins.should equal(foo)
+        Pakada.instance.should equal(foo)
+        
+        Pakada.instance(:bar) {|ins|
+          ins.should equal(bar)
+          Pakada.instance.should equal(bar)
+        }
+        
+        Pakada.instance.should equal(foo)
+      }
     end
     
-    it "calls #boot on each module" do
-      subject.modules.each_value {|m| m.should_receive :boot }
-      subject.boot
-    end
+    let(:create) { stub "instance: create_me" }
+    let(:urls) { stub "urls" }
+    let(:modules) { stub "modules" }
+    let(:path) { stub "path" }
     
-    it "doesn't call #boot in testing environments" do
-      subject.stub(:env).and_return :testing
-      subject.modules.each_value {|m| m.should_not_receive :boot }
-      subject.boot
+    it "creates the specified instance if it doesn't exist" do
+      Pakada.should_receive(:new).with(:create_me,
+        :urls => urls, :modules => modules, :path => path
+      ).and_return create
+
+      Pakada.instance(:create_me) {|dsl|
+        dsl.urls, dsl.modules, dsl.path = urls, modules, path
+      }
+      
+      Pakada.instances[:create_me].should equal(create)
     end
   end
   
-  describe ".load_env" do
-    before :each do
-      @env = ENV["RACK_ENV"]
+  context ".boot" do
+    before do
+      Pakada.instance(:foo) {|ins|
+        ins.urls = "/", "/foo"
+      }
+      Pakada.instance(:bar) {}
     end
     
-    after :each do
-      ENV["RACK_ENV"] = @env
+    let(:foo) { Pakada.instance :foo }
+    let(:bar) { Pakada.instance :bar }
+    let(:env) { stub "env" }
+    let(:response) { stub "response" }
+    
+    it "creates a Rack::URLMap with end-points for each instance" do
+      foo.should_receive(:call).twice {|e|
+        Pakada.instance.should equal(foo)
+        env.should equal(e)
+        response
+      }
+      
+      Rack::URLMap.should_receive(:new) {|map|
+        map.each {|url, app|
+          foo.urls.should include(url)
+          app.call(env).should equal(response)
+        }
+      }
+      
+      Pakada.boot
     end
     
-    it "uses RACK_ENV to determine the runtime environment" do
-      ENV["RACK_ENV"] = "something"
-      subject.load_env
-      subject.env.should == :something
+    it "calls #boot on each instance" do
+      foo.should_receive :boot
+      bar.should_receive :boot
+      Pakada.boot
     end
     
-    it "is uses 'development' as the default environment" do
-      ENV.delete "RACK_ENV"
-      subject.load_env
-      subject.env.should == :development
+    let(:default) { Pakada.instance :default }
+    
+    it "creates a default instance if there are no others" do
+      Pakada.instances.clear
+      
+      Rack::URLMap.should_receive(:new) {|map|
+        default.should_receive(:call) {
+          Pakada.instance.should == default
+        }
+        map["/"].call({})
+      }
+      
+      Pakada.boot
     end
   end
   
-  describe ".load_modules!" do
-    it "loads the modules" do
-      mod = double "module"
-      modcls = double "module class", :module_name => :foo
-      modcls.should_receive(:new) { mod }
-      Pakada::Module.stub(:descendants) { [modcls] }
-      
-      subject.load_modules
-      subject.modules[:foo].should == mod
+  context ".call(env)" do
+    let(:urlmap) { stub "url map" }
+    let(:env) { stub "env" }
+    let(:response) { stub "response" }
+    
+    before do
+      Rack::URLMap.stub :new => urlmap
+      Pakada.boot
+    end
+    
+    it "forwards to the URL map" do
+      urlmap.should_receive(:call) {|e|
+        e.should equal(env)
+        response
+      }
+      Pakada.call(env).should equal(response)
     end
   end
   
-  describe ".load_hooks" do
-    before :each do
-      subject.stub(:modules).and_return({})
-      [:foo, :bar].each do |m|
-        subject.modules[m] = stub("#{m} module")
-      end
-    end
+  context ".env" do
+    after { ENV.delete "RACK_ENV" }
     
-    it "calls #hooks on each module" do
-      subject.modules.each_value {|m| m.should_receive :hooks }
-      subject.load_hooks
+    it "reflects the runtime environment" do
+      ENV["RACK_ENV"] = "envenvenv"
+      Pakada.env.should equal(:envenvenv)
     end
     
-    it "doesn't call #hooks in testing environments" do
-      subject.stub(:env).and_return :testing
-      subject.modules.each_value {|m| m.should_not_receive :hooks }
-      subject.load_hooks
+    it "defaults to :development" do
+      Pakada.env.should equal(:development)
     end
   end
   
-  describe ".[]" do
-    it "forwards to .modules" do
-      subject.stub(:modules).and_return :some_module => stub("module")
-      subject[:some_module].should == subject.modules[:some_module]
+  context ".development?" do
+    it "is true if env == :development" do
+      Pakada.stub :env => :development
+      Pakada.development?.should be_true
     end
   end
   
-  describe ".development?" do
-    it "is a shortcut for .env == :development" do
-      subject.stub(:env) { :development }
-      subject.development?.should be_true
-      
-      subject.stub(:env) { :something }
-      subject.development?.should be_false
+  context ".testing?" do
+    it "is true if env == :testing" do
+      Pakada.stub :env => :testing
+      Pakada.testing?.should be_true
     end
   end
   
-  describe ".testing?" do
-    it "is a shortcut for .env == :testing" do
-      subject.stub(:env) { :testing }
-      subject.testing?.should be_true
-      
-      subject.stub(:env) { :something }
-      subject.testing?.should be_false
+  context ".staging?" do
+    it "is true if env == :staging" do
+      Pakada.stub :env => :staging
+      Pakada.staging?.should be_true
     end
   end
   
-  describe ".production?" do
-    it "is a shortcut for .env == :production" do
-      subject.stub(:env) { :production }
-      subject.production?.should be_true
-      
-      subject.stub(:env) { :something }
-      subject.production?.should be_false
+  context ".production?" do
+    it "is true if env == :production" do
+      Pakada.stub :env => :production
+      Pakada.production?.should be_true
     end
   end
   
-  describe ".middleware" do
-    it "is a simple Array" do
-      Array.should === subject.middleware
+  context "#initialize(name, config)" do
+    let(:module1) do
+      stub :new => stub, :pakada_name => :module1, :dependencies => [module2]
+    end
+    let(:module2) do
+      stub :new => stub, :pakada_name => :module2, :dependencies => [module3]
+    end
+    let(:module3) do
+      stub :new => stub, :pakada_name => :module3, :dependencies => []
+    end
+    let(:instance) { Pakada.new :foo, :modules => [module1] }
+    
+    it "sets the instance name" do
+      instance.name.should equal(:foo)
+    end
+    
+    it "resolves and initializes the modules" do
+      instance.modules[:module1].should equal(module1.new)
+      instance.modules[:module2].should equal(module2.new)
+      instance.modules[:module3].should equal(module3.new)
+    end
+    
+    it "sets the URL list" do
+      ins = Pakada.new(:foo, :urls => "http://example.org")
+      ins.urls.should == ["http://example.org"]
     end
     
-    it "is empty initially" do
-      subject.middleware.should be_empty
+    it "expands the path" do
+      ins = Pakada.new(:foo, :path => "bar/foo")
+      ins.path.to_s.should == File.join(Dir.pwd, "bar/foo")
+      ins.path.absolute?.should be_true
     end
   end
   
-  describe ".to_app" do
-    before :each do
-      @builder = stub "builder"
-      Rack::Builder.stub(:new).and_return @builder
+  context "#initialize(name)" do
+    let(:instance) { Pakada.new :foo }
+    
+    before do
+      1.upto(5) {|i|
+        Pakada::Module.descendants << stub({
+          :new => stub("module#{i}"),
+          :pakada_name => :"module#{i}",
+          :dependencies => []
+        })
+      }
     end
-
-    it "builds a Rack endpoint" do
-      mw = proc do |pos|
-        Class.new do
-          attr_reader :app, :pos
-          def initialize(app); @app, @pos = app, pos; end
-        end
-      end
-      subject.stub(:middleware).and_return [mw.call(0), mw.call(1)]
-      
-      pending "what about middleware insertion order?"
+    
+    it "uses an empty URL list" do
+      instance.urls.should be_empty
     end
     
-    it "handles middleware arguments" do
-      @builder.stub(:run)
-      @builder.stub(:to_app)
+    it "uses all available modules" do
+      instance.should have(5).modules
+    end
+    
+    it "uses instances/<name> as path" do
+      instance.path.to_s.should == File.join(Dir.pwd, "instances", "foo")
+    end
+  end
+  
+  context "#initialize(name = :default)" do
+    it "uses the current directory as path" do
+      instance = Pakada.new(:default)
+      instance.path.to_s.should == Dir.pwd
+    end
+  end
+  
+  context "#boot" do
+    let(:foo) { instance.modules[:foo] }
+    let(:bar) { instance.modules[:bar] }
+    let(:instance) { Pakada.instance :instance }
+    
+    before do
+      Pakada.instance(:instance) {}
+      instance.stub :modules => {
+        :foo => stub("foo module"),
+        :bar => stub("bar module")
+      }
+    end
+    
+    it "calls #hooks and #boot on each module" do
+      foo.should_receive :hooks
+      foo.should_receive :boot
+      bar.should_receive :hooks
+      bar.should_receive :boot
       
-      mw = [
-        [stub("mw#0"), stub("mw arg#0"), stub("mw arg#1")],
-        stub("mw#1")
-      ]
-      subject.stub(:middleware).and_return mw
+      instance.boot
+    end
+    
+    it "does nothing if env == :testing" do
+      Pakada.stub :env => :testing
+      foo.should_not_receive :hooks
+      foo.should_not_receive :boot
+      bar.should_not_receive :hooks
+      bar.should_not_receive :boot
       
-      @builder.should_receive(:use).with *mw[0]
-      @builder.should_receive(:use).with mw[1]
-      subject.to_app
+      instance.boot
     end
   end
   
-  describe ".call" do
-    it "forwards to .to_app.call" do
-      req, resp = stub("request"), stub("response")
-      subject.stub(:to_app).and_return stub("app")
+  context "#call(env)" do
+    let(:instance) { Pakada.new :foo }
+    let(:env) { stub "env" }
+    let(:response) { stub "response" }
+    
+    before { instance.stub :to_app => stub("#to_app") }
+    
+    it "forwards to #to_app.call" do
+      instance.to_app.should_receive(:call) {|e|
+        e.should equal(env)
+        response
+      }
       
-      subject.to_app.should_receive(:call).with(req).and_return resp
-      subject.call(req).should == resp
+      instance.call(env).should equal(response)
     end
   end
   
-  describe "::DEFAULT_APP" do
-    it "calls .request" do
-      req, resp = stub("request"), stub("response")
-      Pakada.should_receive(:request).with(req).and_return resp
+  context "#to_app" do
+    let(:instance) { Pakada.new :foo }
+    let(:mw1) { stub "middleware#1" }
+    let(:mw2) { [stub("middleware#2"), stub("arg")] }
+    let(:app) { stub "app" }
+    let(:builder) { stub "builder" }
+    let(:env) { stub "env" }
+    let(:response) { stub "response" }
+    
+    before { Rack::Builder.stub :new => builder }
+    
+    it "builds a Rack app of middleware and endpoint" do
+      builder.should_receive(:use).with mw1
+      builder.should_receive(:use).with *mw2
+      builder.should_receive(:run) {|endpoint|
+        instance.should_receive(:request) {|e|
+          e.should equal(env)
+          response
+        }
+        endpoint.call(env).should equal(response)
+      }
+      builder.should_receive(:to_app) { app }
       
-      Pakada::DEFAULT_APP.call(req).should == resp
+      instance.middleware << mw1 << mw2
+      instance.to_app.should equal(app)
     end
   end
   
-  describe ".request" do
-    it "prints a tender welcome greeting" do
-      Pakada.request({})[2].body.to_s.should =~ /Pakada #{Pakada::VERSION}/
+  context "#request(env)" do
+    let(:response) { Pakada.instance(:default).request({}) }
+    
+    before { Pakada.boot }
+    
+    it "returns a tender greeting" do
+      response[0].should equal(200)
+      response[1]["Content-Type"].should == "text/html"
+      response[2].body.join.should match(/Pakada #{Pakada::VERSION}/)
     end
   end
 end

data/spec/spec_helper.rb

@@ -11,5 +11,8 @@ begin
 rescue LoadError; end
 
 RSpec.configure do |config|
-  config.before(:each) { Pakada.reset_instance }
+  config.before(:each) {
+    Pakada.instances.clear
+    Pakada::Module.descendants.clear
+  }
 end

metadata

@@ -1,83 +1,102 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: pakada
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.3.0
   prerelease: 
-  version: 0.2.1
 platform: ruby
-authors: 
+authors:
 - Lars Gierth
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-05-06 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-08-01 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rack
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &80222130 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  version_requirements: *80222130
+- !ruby/object:Gem::Dependency
   name: hooked
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &80221440 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: "0.2"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+  version_requirements: *80221440
+- !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &80220860 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
+  version_requirements: *80220860
+- !ruby/object:Gem::Dependency
   name: fakefs
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &80220160 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
+  version_requirements: *80220160
+- !ruby/object:Gem::Dependency
   name: fakefs-require
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &80219690 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *id005
+  version_requirements: *80219690
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &80219040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *80219040
+- !ruby/object:Gem::Dependency
+  name: rdiscount
+  requirement: &80218590 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *80218590
 description: 
-email: 
+email:
 - lars.gierth@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .rspec
+- .yardopts
 - Gemfile
 - LICENSE
 - README.md
@@ -91,36 +110,26 @@ files:
 - spec/spec_helper.rb
 homepage: https://rubygems.org/gems/pakada
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: -121495153
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: -121495153
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.1
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
-summary: Very Extensible HTTP Container For Ruby
+summary: Modularization contract for web applications
 test_files: []
-