RubyGems - georgi-kontrol - Versions diffs - 0.1 - Mend

georgi-kontrol 0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

data/.gitignore ADDED Viewed

	@@ -0,0 +1 @@
1	+ *~

data/LICENSE ADDED Viewed

@@ -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 ADDED Viewed

@@ -0,0 +1,113 @@
+Kontrol - a micro framework
+===========================
+Kontrol is a small web framework written in Ruby, which runs directly
+on Rack. It provides a simple pattern matching algorithm for routing
+and uses GitStore as data storage.
+## Quick Start
+Create a config.ru file and try this little "Hello World" app:
+    require 'kontrol'
+    run Kontrol::Application.new do
+      get '/' do
+        "Hello World!"
+      end
+    end
+Now run `rackup` and browse to `http://localhost:9292` you will see the "Hello World".
+## Routing
+Routing is just as simple as using regular expressions with
+groups. Each group will be provided as argument to the block.
+Some examples:
+    require 'kontrol'
+    run Kontrol::Application.new do
+      get '/pages/(.*)' do |name|
+        "This is the page #{name}!"
+      end
+      get '/(\d*)/(\d*)', :content_type => 'text/html' do |year, month|
+        "Archive for #{year} #{month}"
+      end
+    end
+The second route has the requirement, that the `content-type` header
+should be 'text/html'.
+## Nested Routes
+You may nest your routes like you want:
+    require 'kontrol'
+    run Kontrol::Application.new do
+      map '/blog' do
+        get '/archives' do
+          "The archives!"
+        end
+      end
+    end
+This app can be reached at '/blog/archives'.
+## Storing your data in a git repository
+Using GitStore for your code and data is a convenient way for
+developing small scale apps. The whole repository is loaded into the
+memory and any change in the repository is reflected immediately in
+you in-memory copy.
+Just init a new repo: `git init`
+Now we create a template named `templates/layout.rhtml`:
+    <html>
+      <body>
+        <%= @content %>
+      </body>
+    </html>
+And now another template named `templates/page.rhtml`:
+    <h1><%= @title %></h1>
+    <%= @body %>
+Now we create a Markdown file name `pages/index.md`:
+    Hello World from **Markdown** !
+Create a config.ru file:
+    require 'kontrol'
+    run Kontrol::Application.new do
+      get '/(.*)' do |name|
+        body = store["pages/#{name}.md"]
+        render "page.rhtml", :title => name.capitalize, :body => body
+      end
+    end
+Add all these files to your repo:
+    git add templates/layout.rhtml
+    git add templates/page.rhtml
+    git add pages/index.md
+    git add config.ru
+    git commit -m 'added templates and config.ru'
+Now just run `rackup` and browse to `http://localhost:9292/index`
+You will see the rendered template with the inserted content of the
+Markdown file.

data/lib/kontrol/application.rb ADDED Viewed

@@ -0,0 +1,247 @@
+module Kontrol
+  class Application
+    include Helpers
+    class << self
+      def config_reader(file, *names)
+        names.each do |name|
+          name = name.to_s
+          define_method(name) { config[file][name] }
+        end
+      end
+    end
+    attr_reader :path, :store, :last_commit
+    config_reader 'assets.yml', :javascript_files, :stylesheet_files
+    def initialize(options = {}, &block)
+      options.each do |k, v|
+        send "#{k}=", v
+      end
+      @mtime = {}
+      @last_mtime = Time.now
+      @path = File.expand_path('.')
+      @store = GitStore.new(path)
+      @store.load
+      map(&block) if block
+    end
+    def assets
+      store['assets'] ||= GitStore::Tree.new
+    end
+    def config
+      store['config'] ||= GitStore::Tree.new
+    end
+    def templates
+      store['templates'] ||= GitStore::Tree.new
+    end
+    def repo
+      @store.repo
+    end
+    def check_reload
+      commit = store.repo.commits('master', 1)[0]
+      if commit and (last_commit.nil? or last_commit.id != commit.id)
+        @last_commit = commit
+        @last_mtime = last_commit.committed_date
+        @mtime = {}
+        store.load
+        load_store_from_disk
+      elsif ENV['RACK_ENV'] != 'production'
+        load_store_from_disk
+      end
+    end
+    def load_store_from_disk
+      store.each_with_path do |blob, path|
+        path = "#{self.path}/#{path}"
+        if File.exist?(path)
+          mtime = File.mtime(path)
+          if mtime != @mtime[path]
+            @mtime[path] = mtime
+            @last_mtime = mtime if mtime > @last_mtime
+            blob.load(File.read(path))
+          end
+        end
+      end
+    end
+    def camelize(str)
+      str.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+    # Render template with given variables.
+    def render_template(file, vars)
+      templates[file] or raise "template #{file} not found"
+      Template.render(templates[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)
+      if name[0, 1] == '_' || name.match(/\.rxml$/)
+        content
+      else
+        vars.merge!(:content => content)
+        render_layout(vars)
+      end
+    end
+    def if_modified_since(date = @last_mtime.httpdate)
+      response['Last-Modified'] = date
+      if request.env['HTTP_IF_MODIFIED_SINCE'] == date
+        response.status = 304
+      else
+        yield
+      end
+    end
+    def render_javascripts
+      if_modified_since do
+        javascript_files.map { |file| assets["javascripts/#{file.strip}.js"] }.join
+      end
+    end
+    def render_stylesheets
+      if_modified_since do
+        stylesheet_files.map { |file| assets["stylesheets/#{file.strip}.css"] }.join
+      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 redirect(path)
+      response['Location'] = path
+      response.status = 301
+      response.body = "Redirect to: #{path}"
+    end
+    def guess_content_type
+      ext = File.extname(request.path_info)[1..-1]
+      MIME_TYPES[ext] || 'text/html'
+    end
+    def map(&block)
+      @map = Builder.new(&block)
+    end
+    def call(env)
+      Thread.current['request'] = Rack::Request.new(env)
+      Thread.current['response'] = Rack::Response.new([], nil, { 'Content-Type' => '' })
+      check_reload
+      env['kontrol.app'] = self
+      map = @map || store['map.rb'] or raise "no map defined"
+      status, header, body = map.call(env)
+      response.status = status if response.status.nil?
+      response.header.merge!(header)
+      response.body = body if response.body.empty?
+      response['Content-Type'] = guess_content_type if response['Content-Type'].empty?
+      response.finish
+    end
+    def inspect
+      "#<Kontrol::Application @path=#{path}>"
+    end
+    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
+end

data/lib/kontrol/builder.rb ADDED Viewed

@@ -0,0 +1,78 @@
+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

data/lib/kontrol/helpers.rb ADDED Viewed

@@ -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/router.rb ADDED Viewed

@@ -0,0 +1,50 @@
+module Kontrol
+  class Router
+    def initialize
+      @routing = []
+    end
+    def map(pattern, block, options = {})
+      @routing << [pattern, block, options]
+    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("/")
+      for pattern, app, options in @routing
+        match = path.match(/^#{pattern}/)
+        if match and 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)
+        end
+      end
+      [404, {"Content-Type" => "text/plain"}, ["Not Found: #{env['REQUEST_URI']}"]]
+    end
+  end
+end

data/lib/kontrol/template.rb ADDED Viewed

@@ -0,0 +1,48 @@
+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)
+      @__app__ = app
+    end
+    def __binding__
+      binding
+    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
+    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 ADDED Viewed

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

data/test/application_spec.rb ADDED Viewed

@@ -0,0 +1,122 @@
+require 'kontrol'
+require 'rack/mock'
+describe Kontrol::Builder do
+  REPO = File.expand_path(File.dirname(__FILE__) + '/test_repo')
+  before do
+    FileUtils.rm_rf REPO
+    Dir.mkdir REPO
+    Dir.chdir REPO
+    `git init`
+    @app = Kontrol::Application.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)
+    @app.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
+    end
+    get("/one").body.should == 'one'
+    post("/one").body.should == 'two'
+    delete("/one").body.should == 'three'
+    put("/two").body.should == 'four'
+  end
+  it "should reload after a commit" do
+    file 'file', 'file'
+    map do
+      get '/(.*)' do |path|
+        store[path]
+      end
+    end
+    get("/file").body.should == 'file'
+    file 'file', 'changed'
+    get("/file").body.should == 'changed'
+  end
+  it "should serve assets" do
+    file 'config/assets.yml', '{ javascript_files: [index], stylesheet_files: [styles] }'
+    file 'assets/javascripts/index.js', 'index'
+    file 'assets/stylesheets/styles.css', 'styles'
+    file 'assets/file', 'file'
+    map do
+      get '/assets/javascripts\.js' do
+        render_javascripts
+      end
+      get '/assets/stylesheets\.css' do
+        render_stylesheets
+      end
+      get '/assets/(.*)' do |path|
+        if_modified_since do
+          assets[path]
+        end
+      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'
+    last_mod = get("/assets/file")['Last-Modified']
+    get("/assets/file", 'HTTP_IF_MODIFIED_SINCE' => last_mod).status.should == 304
+  end
+  it "should render templates" do
+    file 'templates/layout.rhtml', '<%= @content %>'
+    file 'templates/index.rhtml', '<%= @body %>'
+    map do
+      get '/' do
+        render 'index.rhtml', :body => 'BODY'
+      end
+    end
+    get('/').body.should == 'BODY'
+  end
+end

metadata ADDED Viewed

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: georgi-kontrol
+version: !ruby/object:Gem::Version
+  version: "0.1"
+platform: ruby
+authors:
+- Matthias Georgi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2008-12-17 00:00:00 -08:00
+default_executable:
+dependencies: []
+description: A small web framework running as rack application.
+email: matti.georgi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .gitignore
+- LICENSE
+- README.md
+- lib/kontrol.rb
+- lib/kontrol/application.rb
+- lib/kontrol/builder.rb
+- lib/kontrol/helpers.rb
+- lib/kontrol/router.rb
+- lib/kontrol/template.rb
+- test/application_spec.rb
+has_rdoc: true
+homepage: http://github.com/georgi/kontrol
+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.2.0
+signing_key:
+specification_version: 2
+summary: a micro web framework
+test_files: []