kontrol 0.3

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2008 Matthias Georgi <http://www.matthias-georgi.de>
+ 
+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 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,201 @@
+Kontrol - a micro framework
+===========================
+
+Kontrol is a small web framework written in Ruby, which runs directly
+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 of the kontrol
+project, which is hosted on [github][2].
+
+## Quick Start
+
+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`:
+
+    class HelloWorld < Kontrol::Application
+      
+      def time
+        Time.now.strftime "%H:%M:%S"
+      end
+     
+      map do
+        root '/' do
+          text "<h1>Hello World at #{time}</h1>"
+        end
+      end
+    end
+        
+    run HelloWorld.new
+    
+Now run:
+
+    rackup hello_world.ru
+
+Browse to `http://localhost:9292` and you will see "Hello World".
+
+
+## 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
+- __render(file, variables)__: render a template with specified variables
+- __text(string)__: render a string
+
+
+## Routing
+
+Routing is just as simple as using regular expressions with
+groups. Each group will be provided as argument to the block.
+
+Create a file named `routing.ru`:
+
+    require 'kontrol'
+    
+    class Routing < Kontrol::Application
+      map do
+        pages '/pages/(.*)' do |name|
+          text "The path is #{ pages_path name }! "
+        end
+     
+        archive '/(\d*)/(\d*)' do |year, month|
+          text "The path is #{ archive_path year, month }! "
+        end
+      end
+    end
+    
+    run Routing.new
+    
+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 `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.
+
+For example the route `/page/(.*)` named page will recognize the path
+`/page/about`, which can be generated by using `page_path('about')`.
+
+
+## Templates
+
+Rendering templates is as simple as calling a template file with some
+parameters, which are accessible inside the template as instance
+variables. Additionally you will need a layout template.
+
+Create a template named `templates/layout.rhtml`:
+
+    <html>
+      <body>
+        <%= @content %>
+      </body>
+    </html>
+
+And now another template named `templates/page.rhtml`:
+
+    <h1><%= @title %></h1>
+    <%= @body %>
+
+Create a templates.ru file:
+
+    require 'kontrol'
+    
+    class Templates < Kontrol::Application
+      map do
+        page '/(.*)' do |name|
+          render "page.rhtml", :title => name.capitalize, :body => "This is the body!"
+        end
+      end
+    end
+    
+    run Templates.new
+
+Now run this example:
+
+    rackup templates.ru
+
+If you browse to any path on `localhost:9292`, you will see the
+rendered template. Note that the title and body parameters have been
+passed to the `render` call.
+
+
+## Using GitStore
+
+[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][] by:
+
+    $ gem sources -a http://gems.github.com
+    $ sudo gem install georgi-git_store
+
+We create a Markdown file name `index.md`:
+
+    Hello World
+    ===========
+
+    This is the **Index** page!
+
+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'
+    require 'git_store'
+
+    class GitApp < Kontrol::Application
+     
+      def initialize(path)
+        super
+        @store = GitStore.new(path)
+      end
+      
+      map do
+        page '/(.*)' do |name|
+          text BlueCloth.new(@store[name + '.md']).to_html
+        end
+      end
+    end
+
+    run GitApp.new
+
+
+Add all the page to your git repository:
+
+    git init
+    git add index.md
+    git commit -m 'init'
+
+Run the app:
+
+    rackup git_app.ru
+
+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 even
+delete the page and it will still show up over the web.
+
+
+[1]: http://github.com/chneukirchen/rack
+[2]: http://github.com/georgi/kontrol
+[3]: http://github.com/georgi/git_store

data/examples/git_app.ru

@@ -0,0 +1,19 @@
+require 'kontrol'
+require 'bluecloth'
+require 'git_store'
+
+class GitApp < Kontrol::Application
+
+  def initialize(path)
+    super
+    @store = GitStore.new(path)
+  end
+  
+  map do
+    page '/(.*)' do |name|
+      text BlueCloth.new(@store[name]).to_html
+    end
+  end
+end
+
+run GitApp.new

data/examples/hello_world.ru

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

data/examples/routing.ru

@@ -0,0 +1,15 @@
+require 'kontrol'
+
+class Routing < Kontrol::Application
+  map do
+    pages '/pages/(.*)' do |name|
+      text "The path is #{ pages_path name }! "
+    end
+
+    archive '/(\d*)/(\d*)' do |year, month|
+      text "The path is #{ archive_path year, month }! "
+    end
+  end
+end
+
+run Routing.new

data/examples/templates/layout.rhtml

@@ -0,0 +1,5 @@
+<html>
+  <body>
+    <%= @content %>
+  </body>
+</html>

data/examples/templates/page.rhtml

@@ -0,0 +1,2 @@
+<h1><%= @title %></h1>
+<%= @body %>

data/examples/templates.ru

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

data/lib/kontrol/application.rb

@@ -0,0 +1,155 @@
+require 'digest/sha1'
+
+module Kontrol
+
+  class Application
+    include Helpers
+
+    attr_reader :path
+
+    class << self
+      attr_accessor :router
+      
+      def map(&block)
+        @router = Router.new(&block)
+      end
+    end
+    
+    def initialize(path = '.')
+      @path = File.expand_path(path)      
+    end
+
+    def load_template(file)
+      ERB.new(File.read("#{self.path}/templates/#{file}"))
+    end
+    
+    # Render template with given variables.
+    def render_template(file, vars)
+      template = load_template(file) or raise "not found: #{path}"
+      Template.render(template, self, "#{self.path}/templates/#{file}", vars)
+    end
+
+    # Render named template and insert into layout with given variables.
+    def render(name, options = {})
+      options = options.merge(:request => request, :params => params)
+      content = render_template(name, options)
+      layout = options.delete(:layout)
+      
+      if name[0, 1] == '_'
+        return content
+        
+      elsif layout == false
+        response.body = content
+      else
+        options.merge!(:content => content)
+        response.body = render_template(layout || "layout.rhtml", options)
+      end
+
+      response['Content-Length'] = response.body.size.to_s
+    end
+
+    def etag(string)
+      Digest::SHA1.hexdigest(string)
+    end
+
+    def if_modified_since(time)
+      date = time.respond_to?(:httpdate) ? time.httpdate : time
+      response['Last-Modified'] = date
+      
+      if request.env['HTTP_IF_MODIFIED_SINCE'] == date
+        response.status = 304
+      else
+        yield        
+      end
+    end
+    
+    def if_none_match(etag)
+      response['Etag'] = etag
+      if request.env['HTTP_IF_NONE_MATCH'] == etag
+        response.status = 304
+      else
+        yield
+      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 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 post    ; request.post? and yield     end
+    def get     ; request.get? and yield      end
+    def put     ; request.put? and yield      end
+    def delete  ; request.delete? and yield   end
+
+    def text(s)
+      response.body = s
+      response['Content-Length'] = response.body.size.to_s
+    end
+
+    def redirect(path)
+      response['Location'] = path
+      response.status = 301
+    end
+
+    def guess_content_type
+      ext = File.extname(request.path_info)[1..-1]
+      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([], 200, { 'Content-Type' => '' })
+
+      route, match = router.__recognize__(request)
+
+      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.finish
+    end
+
+    def inspect
+      "#<#{self.class.name} @path=#{path}>"
+    end
+
+    def respond_to?(name)
+      if match = name.to_s.match(/^(.*)_path$/)
+        router.__find__(match[1])
+      else
+        super
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      if match = name.to_s.match(/^(.*)_path$/)
+        if route = router.__find__(match[1])
+          route.generate(*args)
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+    
+  end
+
+end
+

data/lib/kontrol/helpers.rb

@@ -0,0 +1,41 @@
+module Kontrol
+
+  module Helpers
+
+    # Render a HTML tag with given name. 
+    # The last argument specifies the attributes of the tag.
+    # The second argument may be the content of the tag.
+    def tag(name, *args)
+      text, attr = args.first.is_a?(Hash) ? [nil, args.first] : args
+      attributes = attr.map { |k, v| %Q{#{k}="#{v}"} }.join(' ')
+      "<#{name} #{attributes}>#{text}</#{name}>"
+    end
+
+    # Render a link
+    def link_to(text, path, options = {})
+      tag :a, text, options.merge(:href => path)
+    end
+
+    def markdown(text, *args)
+      BlueCloth.new(text, *args).to_html
+    rescue => e      
+      "#{text}<br/><br/><strong style='color:red'>#{e.message}</strong>"
+    end
+
+    def strip_tags(str)
+      str.to_s.gsub(/<\/?[^>]*>/, "")
+    end
+
+    def urlify(string)
+      string.downcase.gsub(/[ -]+/, '-').gsub(/[^-a-z0-9_]+/, '')
+    end
+
+    HTML_ESCAPE = { '&' => '&amp;', '"' => '&quot;', '>' => '&gt;', '<' => '&lt;', ' ' => '&nbsp;' }
+
+    def h(s)
+      s.to_s.gsub(/[ &"><]/) { |special| HTML_ESCAPE[special] }
+    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,30 @@
+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.map { |arg|
+        arg.respond_to?(:to_param) ? arg.to_param : arg.to_s
+      }
+    end
+    
+  end
+
+end

data/lib/kontrol/router.rb

@@ -0,0 +1,35 @@
+module Kontrol
+
+  class Router
+    
+    def initialize(&block)
+      @routes = []
+      @map = {}
+
+      instance_eval(&block) if block
+    end
+
+    def __find__(name)
+      @map[name.to_sym]
+    end
+
+    def __recognize__(request)
+      @routes.each do |route|
+        if match = route.recognize(request)
+          return route, match
+        end
+      end
+      
+      return nil
+    end
+
+    def method_missing(name, pattern, *args, &block)
+      route = Route.new(name, pattern, args.first, block)
+      
+      @routes << route
+      @map[name] = route
+    end
+
+  end
+
+end

data/lib/kontrol/template.rb

@@ -0,0 +1,42 @@
+module Kontrol
+
+  # This class renders an ERB template for a set of attributes, which
+  # are accessible as instance variables.
+  class Template
+    include Helpers
+
+    # Initialize this template with an ERB instance.
+    def initialize(app, vars)
+      @__app__ = app
+      
+      vars.each do |k, v|
+        instance_variable_set "@#{k}", v
+      end
+    end
+   
+    def __binding__
+      binding
+    end
+
+    def self.render(erb, app, file, vars)
+      template = Template.new(app, vars)
+      
+      return erb.result(template.__binding__)
+
+    rescue => e
+      e.backtrace.each do |s|
+        s.gsub!('(erb)', file)
+      end
+      raise e
+    end
+
+    def method_missing(id, *args, &block)
+      if @__app__.respond_to?(id)
+        return @__app__.send(id, *args, &block)
+      end
+      super
+    end
+
+  end
+
+end

data/lib/kontrol.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'rack'
+require 'erb'
+require 'yaml'
+require 'logger'
+
+require 'kontrol/helpers'
+require 'kontrol/mime_types'
+require 'kontrol/template'
+require 'kontrol/application'
+require 'kontrol/router'
+require 'kontrol/route'

data/test/application_spec.rb

@@ -0,0 +1,121 @@
+require 'kontrol'
+require 'rack/mock'
+
+describe Kontrol::Application do
+
+  before do
+    @class = Class.new(Kontrol::Application)
+    @app = @class.new
+    @request = Rack::MockRequest.new(@app)
+    
+    def @app.load_template(file)
+      if file == "layout.rhtml"
+        ERB.new '<html><%= @content %></html>'
+      else
+        ERB.new '<p><%= @body %></p>'
+      end
+    end
+  end
+
+  def get(*args)
+    @request.get(*args)
+  end
+  
+  def map(&block)
+    @class.map(&block)
+  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'
+    get("/two").body.should == 'two'
+  end
+
+  it "should have a router" do
+    map do
+      root '/'
+    end
+
+    @class.router.should_not be_nil
+  end
+  
+  it "should generate paths" do
+    map do
+      root '/'
+      about '/about'
+      page '/page/(.*)'
+    end
+
+    @app.root_path.should == '/'
+    @app.about_path.should == '/about'
+    @app.page_path('world').should == '/page/world'
+  end
+
+  it "should redirect" do
+    map do
+      root '/' do
+        redirect 'x'
+      end
+    end
+
+    get('/')['Location'].should == 'x'
+    get('/').status.should == 301
+  end
+
+  it "should respond with not modified" do
+    map do
+      assets '/assets/(.*)' do
+        script = "script"
+        if_none_match(etag(script)) do
+          text script
+        end
+      end
+    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
+
+  it "should render text" do
+    map do
+      index '/' do
+        text "Hello"
+      end
+    end
+
+    get('/').body.should == 'Hello'
+    get('/')['Content-Length'].should == '5'
+  end
+
+  it "should render no layout" do
+    map do
+      index '/' do
+        render 'index.rhtml', :body => 'BODY', :layout => false
+      end
+    end
+
+    get('/').body.should == '<p>BODY</p>'
+  end
+
+  it "should render templates" do
+    map do
+      index '/' do
+        render 'index.rhtml', :body => 'BODY'
+      end
+    end
+
+    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

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: kontrol
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+platform: ruby
+authors: 
+- Matthias Georgi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-07 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Small web framework running on top of rack.
+email: matti.georgi@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- 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/helpers.rb
+- lib/kontrol/mime_types.rb
+- lib/kontrol/route.rb
+- lib/kontrol/router.rb
+- lib/kontrol/template.rb
+- test/application_spec.rb
+- test/route_spec.rb
+- test/router_spec.rb
+has_rdoc: true
+homepage: http://github.com/georgi/kontrol
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: a micro framework
+test_files: []
+