georgi-kontrol 0.1.6 → 0.2

data/README.md

@@ -2,21 +2,31 @@ Kontrol - a micro framework
 ===========================
 
 Kontrol is a small web framework written in Ruby, which runs directly
-on [Rack][5]. It uses regular expressions for routing.
+on [Rack][1]. Basically you can mount a class as rack handler and
+attach a set of named routes, which will be used for route recognition
+and generation.
 
-All examples can be found in the [examples folder][3] of the kontrol
-project, which is hosted on [this github page][4].
+All examples can be found in the examples folder of the kontrol
+project, which is hosted on [github][2].
 
 ## Quick Start
 
-Create a file named `hello_world.ru`:
+We will create a simple Kontrol application with exactly one route
+named 'root'. Routes are defined within a block insider your
+application class. Each route has a name, a pattern and a block. The
+name must be defined to generate paths pointing to this route.
+
+`hello_world.ru`:
 
-    require 'kontrol'
-    
     class HelloWorld < Kontrol::Application
+      
+      def time
+        Time.now.strftime "%H:%M:%S"
+      end
+     
       map do
-        get '/' do
-          "Hello World!" 
+        root '/' do
+          text "<h1>Hello World at #{time}</h1>"
         end
       end
     end
@@ -30,21 +40,19 @@ Now run:
 Browse to `http://localhost:9292` and you will see "Hello World".
 
 
-## Features
-
-Kontrol is just a thin layer on top of Rack. It provides a routing
-algorithm, a simple template mechanism and some convenience stuff to
-work with [GitStore][1].
+## Basics
 
 A Kontrol application is a class, which provides some context to the
 defined actions. You will probably use these methods:
 
-* request: the Rack request object
-* response: the Rack response object
-* params: union of GET and POST parameters
-* cookies: shortcut to request.cookies
-* session: shortcut to `request.env['rack.session']`
-* redirect(path): renders a redirect response to specified path
+- __request__: the Rack request object
+- __response__: the Rack response object
+- __params__: union of GET and POST parameters
+- __cookies__: shortcut to request.cookies
+- __session__: shortcut to `request.env['rack.session']`
+- __redirect(path)__: renders a redirect response to specified path
+- __render(file, variables)__: render a template with specified variables
+- __text(string)__: render a string
 
 
 ## Routing
@@ -58,12 +66,12 @@ Create a file named `routing.ru`:
     
     class Routing < Kontrol::Application
       map do
-        get '/pages/(.*)' do |name|
-          "This is the page #{name}!"
+        pages '/pages/(.*)' do |name|
+          text "The path is #{ pages_path name }! "
         end
-    
-        get '/(\d*)/(\d*)' do |year, month|
-          "Archive for #{year}/#{month}"
+     
+        archive '/(\d*)/(\d*)' do |year, month|
+          text "The path is #{ archive_path year, month }! "
         end
       end
     end
@@ -74,52 +82,17 @@ Now run this application:
 
     rackup routing.ru
 
-
 You will now see, how regex groups and parameters are related. For
 example if you browse to `localhost:9292/2008/12`, the app will
-display `Archive for 2008/12`.
+display `The path is /2008/12`.
 
+The inverse operation to route recognition is route generation. That
+means a route with one or more groups can generate a url, which will
+be recognized this very route.
 
-## Nested Routes
+For example the route `/page/(.*)` named page will recognize the path
+`/page/about`, which can be generated by using `page_path('about')`.
 
-Routes can be nested. This way you can avoid repeating patterns and
-define handlers for a set of HTTP verbs. Each handler will be called
-with the same arguments.
-
-    require 'kontrol'
-    
-    class Nested < Kontrol::Application
-      map do
-        map '/blog' do
-          get '/archives' do
-            "The archives!"
-          end
-        end
-        
-        map '/(.*)' do
-          get do |path|
-            "<form method='post'><input type='submit'/></form>"
-          end
-          
-          post do |path|
-            "You posted to #{path}"
-          end
-        end
-      end
-    end
-    
-    run Nested.new
-
-Now run this app like:
-
-    rackup nested.ru
-    
-The second route catches all paths except the `/blog` route. Inside
-the second route there are two different handlers for `GET` and `POST`
-actions.
-
-So if you browse to `/something`, you will see a submit button. After
-submitting you will see the result of the second handler.
 
 ## Templates
 
@@ -146,7 +119,7 @@ Create a templates.ru file:
     
     class Templates < Kontrol::Application
       map do
-        get '/(.*)' do |name|
+        page '/(.*)' do |name|
           render "page.rhtml", :title => name.capitalize, :body => "This is the body!"
         end
       end
@@ -165,17 +138,17 @@ passed to the `render` call.
 
 ## Using GitStore
 
-[GitStore][1] is another library, which allows you to store code and
+[GitStore][3] is another library, which allows you to store code and
 data in a convenient way in a git repository. The repository is
 checked out into memory and any data may be saved back into the
 repository.
 
-Install [GitStore][1] and [Grit][2] by:
+Install [GitStore][] by:
 
-    $ gem sources -a http://gems.github.com (you only have to do this once)
-    $ sudo gem install mojombo-grit georgi-git_store
+    $ gem sources -a http://gems.github.com
+    $ sudo gem install georgi-git_store
 
-We create a Markdown file name `pages/index.md`:
+We create a Markdown file name `index.md`:
 
     Hello World
     ===========
@@ -185,23 +158,24 @@ We create a Markdown file name `pages/index.md`:
 We have now a simple page, which should be rendered as response. We
 create a simple app in a file `git_app.ru`:
 
-    require 'kontrol'
-    require 'bluecloth'
-    
     class GitApp < Kontrol::Application
+     
+      def initialize(path)
+        super
+        @store = GitStore.new(path)
+      end
+      
       map do
-        get '/(.*)' do |name|
-          BlueCloth.new(store['pages', name + '.md']).to_html
+        page '/(.*)' do |name|
+          text BlueCloth.new(@store[name + '.md']).to_html
         end
       end
     end
-    
-    run GitApp.new
 
-Add all these files to your repo:
+Add all the page to your git repository:
 
     git init
-    git add pages/index.md
+    git add index.md
     git commit -m 'init'
 
 Run the app:
@@ -211,15 +185,10 @@ Run the app:
 Browse to `http://localhost:9292/index` and you will see the rendered
 page generated from the markdown file.
 
-This application runs straight from the git repository. You can delete
-all files except the rackup file and the app will still serve the page
-from your repo.
+This application runs straight from the git repository. You can even
+delete the page and it will still show up over the web.
 
 
-[1]: http://github.com/georgi/git_store
-[2]: http://github.com/mojombo/grit
-[3]: http://github.com/georgi/kontrol/tree/master/examples
-[4]: http://github.com/georgi/kontrol
-[5]: http://github.com/chneukirchen/rack
-[6]: http://github.com/chneukirchen/rack/tree/master/lib/rack/request.rb
-[7]: http://github.com/chneukirchen/rack/tree/master/lib/rack/response.rb
+[1]: http://github.com/chneukirchen/rack
+[2]: http://github.com/georgi/kontrol
+[3]: http://github.com/georgi/git_store

data/examples/git_app.ru

@@ -7,10 +7,10 @@ class GitApp < Kontrol::Application
     super
     @store = GitStore.new(path)
   end
-
+  
   map do
-    get '/(.*)' do |name|
-      BlueCloth.new(@store['pages', name + '.md']).to_html
+    page '/(.*)' do |name|
+      text BlueCloth.new(@store[name + '.md']).to_html
     end
   end
 end

data/examples/hello_world.ru

@@ -1,9 +1,14 @@
 require 'kontrol'
 
 class HelloWorld < Kontrol::Application
+  
+  def time
+    Time.now.strftime "%H:%M:%S"
+  end
+
   map do
-    get '/' do
-      "Hello World!" 
+    root '/' do
+      text "<h1>Hello World at #{time}</h1>"
     end
   end
 end

data/examples/routing.ru

@@ -2,12 +2,12 @@ require 'kontrol'
 
 class Routing < Kontrol::Application
   map do
-    get '/pages/(.*)' do |name|
-      "This is the page #{name}!"
+    pages '/pages/(.*)' do |name|
+      text "The path is #{ pages_path name }! "
     end
 
-    get '/(\d*)/(\d*)' do |year, month|
-      "Archive for #{year}/#{month}"
+    archive '/(\d*)/(\d*)' do |year, month|
+      text "The path is #{ archive_path year, month }! "
     end
   end
 end

data/examples/templates.ru

@@ -2,7 +2,7 @@ require 'kontrol'
 
 class Templates < Kontrol::Application
   map do
-    get '/(.*)' do |name|
+    page '/(.*)' do |name|
       render "page.rhtml", :title => name.capitalize, :body => "This is the body!"
     end
   end

data/lib/kontrol.rb

@@ -8,5 +8,5 @@ require 'kontrol/helpers'
 require 'kontrol/mime_types'
 require 'kontrol/template'
 require 'kontrol/application'
-require 'kontrol/builder'
 require 'kontrol/router'
+require 'kontrol/route'

data/lib/kontrol/application.rb

@@ -3,25 +3,18 @@ require 'digest/sha1'
 module Kontrol
 
   class Application
+    include Helpers
+
+    attr_reader :path
 
     class << self
+      attr_accessor :router
+      
       def map(&block)
-        if block
-          @map = Builder.new(&block)
-        else
-          @map
-        end
+        @router = Router.new(&block)
       end
-
-      def call(env)
-        @map.call(env)
-      end     
     end
     
-    include Helpers
-
-    attr_reader :path
-
     def initialize(path = '.')
       @path = File.expand_path(path)      
     end
@@ -35,20 +28,20 @@ module Kontrol
       Template.render(load_template(file), self, file, vars)
     end
 
-    def render_layout(vars)
-      render_template(vars[:layout] || "layout.rhtml", vars)
-    end
-
     # Render named template and insert into layout with given variables.
     def render(name, vars = {})
       content = render_template(name, vars)
+      layout = vars[:layout] || "layout.rhtml"
       
-      if name[0, 1] == '_' or vars[:layout] == false
-        content
+      if name[0, 1] == '_'
+        return content
+      elsif layout == false
+        response.body = content
       else
-        vars.merge!(:content => content)
-        render_layout(vars)
+        response.body = render_template(layout, vars.merge(:content => content))
       end
+
+      response['Content-Length'] = response.body.size.to_s
     end
 
     def etag(string)
@@ -75,30 +68,24 @@ module Kontrol
       end
     end
     
-    def request
-      Thread.current['request']
-    end
-
-    def response
-      Thread.current['response']
-    end
-
-    def params
-      request.params
-    end
-
-    def cookies
-      request.cookies
-    end
+    def request ; Thread.current['request']   end
+    def response; Thread.current['response']  end
+    def params  ; request.params              end
+    def cookies ; request.cookies             end
+    def session ; request.env['rack.session'] end
+    def post?   ; request.post?               end
+    def get?    ; request.get?                end
+    def put?    ; request.put?                end
+    def delete? ; request.delete?             end
 
-    def session
-      request.env['rack.session']
+    def text(s)
+      response.body = s
+      response['Content-Length'] = response.body.size.to_s
     end
 
     def redirect(path)
       response['Location'] = path
       response.status = 301
-      response.body = "Redirect to: #{path}"      
     end
 
     def guess_content_type
@@ -106,31 +93,42 @@ module Kontrol
       MIME_TYPES[ext] || 'text/html'
     end
 
+    def router
+      self.class.router
+    end
+
     def call(env)
       Thread.current['request'] = Rack::Request.new(env)
-      Thread.current['response'] = Rack::Response.new([], nil, { 'Content-Type' => '' })
-
-      env['kontrol.app'] = self
+      Thread.current['response'] = Rack::Response.new([], 200, { 'Content-Type' => '' })
 
-      status, header, body = self.class.call(env)
+      route, match = router.__recognize__(request)
 
-      response.status = status if response.status.nil?
-      response.header.merge!(header)
-      response.body = body if response.body.empty?
-      
-      if response.status != 304
-        response.body ||= ''
+      if route
+        method = "process_#{route.name}"
+        self.class.send(:define_method, method, &route.block)
+        send(method, *match.to_a[1..-1])
+      else
+        response.body = "<h1>404 - Page Not Found</h1>"
         response['Content-Length'] = response.body.size.to_s
+        response.status = 404
       end
-      
-      response['Content-Type'] = guess_content_type if response['Content-Type'].empty?
 
+      response['Content-Type'] = guess_content_type if response['Content-Type'].empty?
       response.finish
     end
 
     def inspect
       "#<#{self.class.name} @path=#{path}>"
     end
+
+    def method_missing(name, *args, &block)
+      if match = name.to_s.match(/^(.*)_path$/)
+        router.__find__(match[1]).generate(*args)
+      else
+        super
+      end
+    end
+    
   end
 
 end

data/lib/kontrol/mime_types.rb

@@ -0,0 +1,62 @@
+module Kontrol
+
+    MIME_TYPES = {
+      "ai"    => "application/postscript",
+      "asc"   => "text/plain",
+      "avi"   => "video/x-msvideo",
+      "bin"   => "application/octet-stream",
+      "bmp"   => "image/bmp",
+      "class" => "application/octet-stream",
+      "cer"   => "application/pkix-cert",
+      "crl"   => "application/pkix-crl",
+      "crt"   => "application/x-x509-ca-cert",
+      "css"   => "text/css",
+      "dms"   => "application/octet-stream",
+      "doc"   => "application/msword",
+      "dvi"   => "application/x-dvi",
+      "eps"   => "application/postscript",
+      "etx"   => "text/x-setext",
+      "exe"   => "application/octet-stream",
+      "gif"   => "image/gif",
+      "htm"   => "text/html",
+      "html"  => "text/html",
+      "ico"   => "image/x-icon",
+      "jpe"   => "image/jpeg",
+      "jpeg"  => "image/jpeg",
+      "jpg"   => "image/jpeg",
+      "js"    => "text/javascript",
+      "lha"   => "application/octet-stream",
+      "lzh"   => "application/octet-stream",
+      "mov"   => "video/quicktime",
+      "mp3"   => "audio/mpeg",
+      "mpe"   => "video/mpeg",
+      "mpeg"  => "video/mpeg",
+      "mpg"   => "video/mpeg",
+      "pbm"   => "image/x-portable-bitmap",
+      "pdf"   => "application/pdf",
+      "pgm"   => "image/x-portable-graymap",
+      "png"   => "image/png",
+      "pnm"   => "image/x-portable-anymap",
+      "ppm"   => "image/x-portable-pixmap",
+      "ppt"   => "application/vnd.ms-powerpoint",
+      "ps"    => "application/postscript",
+      "qt"    => "video/quicktime",
+      "ras"   => "image/x-cmu-raster",
+      "rb"    => "text/plain",
+      "rd"    => "text/plain",
+      "rtf"   => "application/rtf",
+      "rss"   => "application/rss+xml",
+      "sgm"   => "text/sgml",
+      "sgml"  => "text/sgml",
+      "tif"   => "image/tiff",
+      "tiff"  => "image/tiff",
+      "txt"   => "text/plain",
+      "xbm"   => "image/x-xbitmap",
+      "xls"   => "application/vnd.ms-excel",
+      "xml"   => "text/xml",
+      "xpm"   => "image/x-xpixmap",
+      "xwd"   => "image/x-xwindowdump",
+      "zip"   => "application/zip",
+    }
+    
+end

data/lib/kontrol/route.rb

@@ -0,0 +1,28 @@
+module Kontrol
+
+  class Route
+    attr_accessor :name, :pattern, :options, :block
+    
+    def initialize(name, pattern, options, block)
+      @name = name
+      @pattern = pattern
+      @block = block
+      @options = options || {}
+      @format = pattern.gsub(/\(.*?\)/, '%s')
+      @regexp = /^#{pattern}/
+    end
+
+    def recognize(request)
+      match = request.path_info.match(@regexp)
+      valid = @options.all? { |key, val| request.send(key).match(val) }
+
+      return match if match and valid
+    end
+
+    def generate(*args)
+      @format % args
+    end
+    
+  end
+
+end

data/lib/kontrol/router.rb

@@ -1,47 +1,33 @@
 module Kontrol
 
   class Router
+    
+    def initialize(&block)
+      @routes = []
+      @map = {}
 
-    def initialize
-      @routing = []      
+      instance_eval(&block) if block
     end
 
-    def map(pattern, block, options = {})
-      @routing << [pattern, block, options]
+    def __find__(name)
+      @map[name.to_sym]
     end
 
-    OPTION_MAPPING = {
-      :method => 'REQUEST_METHOD',
-      :port => 'SERVER_PORT',
-      :host => 'HTTP_HOST',
-      :accept => 'HTTP_ACCEPT',
-      :query => 'QUERY_STRING',
-      :content_type => 'CONTENT_TYPE'      
-    }
-
-    def options_match(env, options)      
-      options.all? do |name, pattern| 
-        value = env[OPTION_MAPPING[name] || name]
-        value and pattern.match(value)
-      end
-    end
-
-    def call(env)
-      path = env["PATH_INFO"].to_s.squeeze("/")      
-
-      @routing.each do |pattern, app, options|        
-        if (match = path.match(/^#{pattern}/)) && options_match(env, options)
-          env = env.dup
-          (env['kontrol.args'] ||= []).concat(match.to_a[1..-1])
-          if match[0] == pattern
-            env["SCRIPT_NAME"] += match[0]
-            env["PATH_INFO"] = path[match[0].size..-1]
-          end          
-          return app.call(env)
+    def __recognize__(request)
+      @routes.each do |route|
+        if match = route.recognize(request)
+          return route, match
         end
       end
+      
+      return nil
+    end
 
-      [404, {"Content-Type" => "text/plain"}, ["Not Found: #{env['REQUEST_URI']}"]]
+    def method_missing(name, pattern, *args, &block)
+      route = Route.new(name, pattern, args.first, block)
+      
+      @routes << route
+      @map[name] = route
     end
 
   end

data/lib/kontrol/template.rb

@@ -6,8 +6,12 @@ module Kontrol
     include Helpers
 
     # Initialize this template with an ERB instance.
-    def initialize(app)
+    def initialize(app, vars)
       @__app__ = app
+      
+      vars.each do |k, v|
+        instance_variable_set "@#{k}", v
+      end
     end
 
     def __binding__
@@ -15,19 +19,9 @@ module Kontrol
     end
 
     def self.render(erb, app, file, vars)
-      template = Template.new(app)
-
-      for name, value in vars
-        template.send :instance_variable_set, "@#{name}", value
-      end
-
-      result = erb.result(template.__binding__)
-
-      for name in template.instance_variables
-        vars[name[1..-1]] = template.send(:instance_variable_get, name) unless name == '@__app__'
-      end
-
-      return result
+      template = Template.new(app, vars)
+      
+      return erb.result(template.__binding__)
 
     rescue => e
       e.backtrace.each do |s|

data/test/application_spec.rb

@@ -1,135 +1,111 @@
 require 'kontrol'
-require 'git_store'
 require 'rack/mock'
 
-describe Kontrol::Builder do
-
-  REPO = File.exist?('/tmp') ? '/tmp/test' : File.expand_path(File.dirname(__FILE__) + '/repo')
+describe Kontrol::Application do
 
   before do
-    FileUtils.rm_rf REPO
-    Dir.mkdir REPO
-    Dir.chdir REPO
-    `git init`
-
-    ENV['RACK_ENV'] = 'production'
-
     @class = Class.new(Kontrol::Application)
-    @app = @class.new(REPO)
+    @app = @class.new
     @request = Rack::MockRequest.new(@app)
   end
 
   def get(*args)
     @request.get(*args)
   end
-
-  def post(*args)
-    @request.post(*args)
-  end
-
-  def delete(*args)
-    @request.delete(*args)
-  end
-
-  def put(*args)
-    @request.put(*args)
-  end
   
   def map(&block)
     @class.map(&block)
   end
-  
-  def file(file, data)
-    FileUtils.mkpath(File.dirname(file))
-    open(file, 'w') { |io| io << data }
-    `git add #{file}`
-    `git commit -m 'spec'`
-    File.unlink(file)    
-  end
 
-  it "should understand all verbs" do
-    map do
-      get '/one' do 'one' end
-      post '/one' do 'two' end
-      delete '/one' do 'three' end
-      put '/two' do 'four' end
+  it "should do simple pattern matching" do
+    map do      
+      one '/one' do
+        response.body = 'one'
+      end
+      
+      two '/two' do
+        response.body = 'two'
+      end
     end
 
     get("/one").body.should == 'one'
-    post("/one").body.should == 'two'
-    delete("/one").body.should == 'three'
-    put("/two").body.should == 'four'
+    get("/two").body.should == 'two'
   end
 
-  it "should redirect" do
+  it "should have a router" do
     map do
-      get '/' do redirect 'x' end
+      root '/'
     end
 
-    get('/')['Location'].should == 'x'
-    get('/').status.should == 301
+    @class.router.should_not be_nil
   end
+  
+  it "should generate paths" do
+    map do
+      root '/'
+      about '/about'
+      page '/page/(.*)'
+    end
 
-  it "should reload after a commit" do
-    file 'file', 'file'
+    @app.root_path.should == '/'
+    @app.about_path.should == '/about'
+    @app.page_path('world').should == '/page/world'
+  end
 
+  it "should redirect" do
     map do
-      get '/(.*)' do |path|
-        store[path]
+      root '/' do
+        redirect 'x'
       end
     end
 
-    get("/file").body.should == 'file'
-
-    file 'file', 'changed'
-
-    get("/file").body.should == 'changed'
+    get('/')['Location'].should == 'x'
+    get('/').status.should == 301
   end
 
-  it "should serve assets" do
-    file 'assets/javascripts/index.js', 'index'
-    file 'assets/stylesheets/styles.css', 'styles'
-    file 'assets/file', 'file'
-    
+  it "should respond with not modified" do
     map do
-      get '/assets/javascripts\.js' do
-        scripts = store['assets/javascripts'].to_a.join
-        if_none_match(etag(scripts)) { scripts }
+      assets '/assets/(.*)' do
+        script = "script"
+        if_none_match(etag(script)) do
+          text script
+        end
       end
+    end
 
-      get '/assets/stylesheets\.css' do
-        styles = store['assets/stylesheets'].to_a.join
-        if_none_match(etag(styles)) { styles }
-      end
+    get("/assets/test.js").body.should == 'script'
+    
+    etag = get("/assets/file")['Etag']    
+    get("/assets/file", 'HTTP_IF_NONE_MATCH' => etag).status.should == 304
+  end
 
-      get '/assets/(.*)' do |path|
-        file = store['assets'][path]
-        if_none_match(etag(file)) { file }
+  it "should render text" do
+    map do
+      index '/' do
+        text "Hello"
       end
     end
 
-    get("/assets/javascripts.js").body.should == 'index'
-    get("/assets/javascripts.js")['Content-Type'].should == 'text/javascript'
-    get("/assets/stylesheets.css").body.should == 'styles'
-    get("/assets/stylesheets.css")['Content-Type'].should == 'text/css'
-    
-    get("/assets/file").body.should == 'file'
-    etag = get("/assets/file")['Etag']
-    
-    get("/assets/file", 'HTTP_IF_NONE_MATCH' => etag).status.should == 304
+    get('/').body.should == 'Hello'
+    get('/')['Content-Length'].should == '5'
   end
 
   it "should render templates" do
-    file 'templates/layout.rhtml', '<%= @content %>'
-    file 'templates/index.rhtml', '<%= @body %>'
-    
+    def @app.load_template(file)
+      if file == "layout.rhtml"
+        ERB.new '<html><%= @content %></html>'
+      else
+        ERB.new '<p><%= @body %></p>'
+      end
+    end
+
     map do
-      get '/' do
+      index '/' do
         render 'index.rhtml', :body => 'BODY'
       end
     end
 
-    get('/').body.should == 'BODY'     
+    get('/').body.should == '<html><p>BODY</p></html>'
   end
   
 end

data/test/route_spec.rb

@@ -0,0 +1,50 @@
+require 'kontrol'
+
+describe Kontrol::Route do
+
+  it "should recognize a request" do
+    route = Kontrol::Route.new(:test, "/test", nil, nil)
+    request = Rack::Request.new('PATH_INFO' => '/test')
+
+    match = route.recognize(request)
+
+    match.should_not be_nil
+    match[0].should == '/test'
+  end
+
+  it "should recognize a request by options" do
+    route = Kontrol::Route.new(:test, "/test", { :request_method => 'GET' }, nil)
+    request = Rack::Request.new('PATH_INFO' => '/test', 'REQUEST_METHOD' => 'GET')
+
+    match = route.recognize(request)
+
+    match.should_not be_nil
+    match[0].should == '/test'
+  end
+
+  it "should recognize a request with groups" do
+    route = Kontrol::Route.new(:test, "/test/(.*)/(.*)", nil, nil)
+    request = Rack::Request.new('PATH_INFO' => '/test/me/here')
+
+    match = route.recognize(request)
+
+    match.should_not be_nil
+    match[0].should == '/test/me/here'
+    match[1].should == 'me'
+    match[2].should == 'here'
+  end
+
+  it "should generate a path" do
+    route = Kontrol::Route.new(:test, "/test", nil, nil)
+
+    route.generate.should == '/test'
+  end
+  
+  it "should generate a path with groups" do
+    route = Kontrol::Route.new(:test, "/test/(.*)/me/(\d\d)", nil, nil)
+
+    route.generate(1, 22).should == '/test/1/me/22'
+  end
+
+end
+

data/test/router_spec.rb

@@ -0,0 +1,53 @@
+require 'kontrol'
+
+describe Kontrol::Router do
+
+  before :each do
+    @router = Kontrol::Router.new
+  end
+
+  def request(env)
+    Rack::Request.new(env)
+  end
+  
+  it "should find a route" do
+    @router.test '/test'
+    route = @router.__find__(:test)
+
+    route.name.should == :test
+    route.pattern.should == '/test'
+  end
+
+  it "should recognize a route" do
+    request = request('PATH_INFO' => '/test')    
+    
+    @router.test '/test'
+    route, match = @router.__recognize__(request)
+
+    route.name.should == :test
+    route.pattern.should == '/test'
+  end
+
+  it "should recognize routes in right order" do
+    request = request('PATH_INFO' => '/test')
+    
+    @router.root '/'
+    @router.test '/test'
+    
+    route, match = @router.__recognize__(request)
+
+    route.name.should == :root
+    route.pattern.should == '/'
+  end
+  
+  it "should not recognize a not matching route" do
+    request = request('PATH_INFO' => '/test')
+    
+    @router.root '/other'
+    
+    route, match = @router.__recognize__(request)
+
+    route.should be_nil
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: georgi-kontrol
 version: !ruby/object:Gem::Version 
-  version: 0.1.6
+  version: "0.2"
 platform: ruby
 authors: 
 - Matthias Georgi
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-04-12 00:00:00 -07:00
+date: 2008-04-13 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
-description: A small web framework running as rack application.
+description: Small web framework running on top of rack.
 email: matti.georgi@gmail.com
 executables: []
 
@@ -22,26 +22,24 @@ extensions: []
 extra_rdoc_files: 
 - README.md
 files: 
-- .gitignore
 - LICENSE
 - README.md
+- examples/git_app.ru
+- examples/hello_world.ru
+- examples/routing.ru
+- examples/templates.ru
+- examples/templates/layout.rhtml
+- examples/templates/page.rhtml
 - lib/kontrol.rb
 - lib/kontrol/application.rb
-- lib/kontrol/builder.rb
 - lib/kontrol/helpers.rb
+- lib/kontrol/mime_types.rb
+- lib/kontrol/route.rb
 - lib/kontrol/router.rb
 - lib/kontrol/template.rb
 - test/application_spec.rb
-- examples/routing.ru
-- examples/pages
-- examples/pages/index.md
-- examples/git_app.ru
-- examples/templates.ru
-- examples/templates
-- examples/templates/page.rhtml
-- examples/templates/layout.rhtml
-- examples/nested.ru
-- examples/hello_world.ru
+- test/route_spec.rb
+- test/router_spec.rb
 has_rdoc: true
 homepage: http://github.com/georgi/kontrol
 post_install_message: 

data/.gitignore

@@ -1,2 +0,0 @@
-*~
-test/repo

data/examples/nested.ru

@@ -1,23 +0,0 @@
-require 'kontrol'
-
-class Nested < Kontrol::Application
-  map do
-    map '/blog' do
-      get '/archives' do
-        "The archives!"
-      end
-    end
-    
-    map '(.*)' do
-      get do |path|
-        "<form method='post'><input type='submit'/></form>"
-      end
-      
-      post do |path|
-        "You called #{path}"
-      end
-    end
-  end
-end
-
-run Nested.new

data/examples/pages/index.md

@@ -1,5 +0,0 @@
-Hello World
-===========
-
-This is the **Index** page!
-

data/lib/kontrol/builder.rb

@@ -1,78 +0,0 @@
-module Kontrol
-
-  def self.map(&block)
-    Builder.new(&block)
-  end
-
-  class Builder
-
-    def initialize(&block)
-      @router = Router.new
-      @ins = []
-      instance_eval(&block) if block
-    end
-
-    def use(middleware, *args, &block)
-      @ins << lambda { |app| middleware.new(app, *args, &block) }
-    end
-
-    def run(app)
-      @ins << app
-    end
-
-    def get(*args, &block)
-      map_method(:get, *args, &block)
-    end
-
-    def put(*args, &block)
-      map_method(:put, *args, &block)
-    end
-
-    def post(*args, &block)
-      map_method(:post, *args, &block)
-    end
-
-    def delete(*args, &block)
-      map_method(:delete, *args, &block)
-    end
-
-    def map(pattern, &block)
-      @router.map(pattern, Builder.new(&block))
-    end
-
-    def call(env)
-      to_app.call(env)
-    end
-
-    def to_app
-      @ins.reverse.inject(@router) { |a, e| e.call(a) }
-    end
-
-    private
-
-    def method_from_proc(obj, proc)
-      name = "proc_#{proc.object_id}"
-      unless obj.respond_to?(name)
-        singleton = class << obj; self; end
-        singleton.send(:define_method, name, &proc)
-      end
-      obj.method(name)
-    end
-
-    def map_method(method, pattern = '.*', options = {}, &block)
-      on(pattern, options.merge(:method => method.to_s.upcase), &block)
-    end
-
-    def on(pattern = '.*', options = {}, &block)
-      wrap = lambda do |env|
-        env['kontrol.app'] or raise "no kontrol.app given"
-        meth = method_from_proc(env['kontrol.app'], block)
-        body = meth.call(*env['kontrol.args'])
-        [200, {}, body]
-      end
-      @router.map(pattern, wrap, options)
-    end
-
-  end  
-
-end