keight 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4c4b037e58fd8fe6bf09a20d6d682b749eb33aa1
+  data.tar.gz: ad00095bed413d481bba4c1ad309e93a5363781e
+SHA512:
+  metadata.gz: 6ad2bde75007e0b5b65349d899f05cc27b85146845702e3057d888df325288a87bc182575e9752db1c24c5fb0ae79fa4e9965c0e3fd8e8e9127453bda55fa6fc
+  data.tar.gz: f9fa23872351a09629b3365d312ff5d4b45fdff6c90aa2cebd7f905f2ac3f9157ec1f51d1fe93fa2ab5c52a7e3ddf8ea361e302f04810d5b4687363b3e10c38e

data/MIT-LICENSE

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

data/README.md

@@ -0,0 +1,263 @@
+Keight.rb README
+================
+
+($Release: 0.0.1 $)
+
+
+Overview
+--------
+
+Keight.rb is the very fast web application framework for Ruby.
+It is about 100 times faster than Rails and 20 times faster than Sinatra.
+
+*Keight.rb is under development and is subject to change without notice.*
+
+
+Benchmarks
+----------
+
+Measured with `app.call(env)` style in order to exclude server overhead:
+
+| FW      | Request            | sec/1000req | req/sec  |
+|:--------|:-------------------|------------:|---------:|
+| Rails   | GET /api/hello     |      7.5188 |    133.0 |
+| Rails   | GET /api/hello/123 |      8.0030 |    125.0 |
+| Sinatra | GET /api/hello     |      1.5034 |    665.2 |
+| Sinatra | GET /api/hello/123 |      1.6328 |    612.4 |
+| Rack    | GET /api/hello     |      0.0789 |  12674.3 |
+| Keight  | GET /api/hello     |      0.0773 |  12936.6 |
+| Keight  | GET /api/hello/123 |      0.1385 |   7220.2 |
+
+* Ruby     2.2.3
+* Rails    4.2.4
+* Sinatra  1.4.6
+* Rack     1.6.4 (= Rack::Request + Rack::Response)
+* Keight   0.1.0
+
+(Script: https://gist.github.com/kwatch/c634e91d2d6a6c4b1d40 )
+
+
+Quick Tutorial
+--------------
+
+```console
+$ gem install keight
+$ vi hello.rb
+$ vi config.ru
+$ rackup -c config.ru -p 8000
+```
+
+hello.rb:
+
+```ruby
+# -*- coding: utf-8 -*-
+require 'keight'
+
+class HelloAction < K8::Action
+
+  mapping ''       , :GET=>:do_index, :POST=>:do_create
+  mapping '/{id}'  , :GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete
+
+  def do_index
+    #{"message"=>"Hello"}   # JSON
+    "<h1>Hello</h1>"        # HTML
+  end
+
+  def do_show(id)
+    ## 'id' or 'xxx_id' will be converted into integer.
+    "<h1>Hello: id=#{id.inspect}</h1>"
+  end
+
+  def do_create    ; "<p>create</p>"; end
+  def do_update(id); "<p>update</p>"; end
+  def do_delete(id); "<p>delete</p>"; end
+
+end
+```
+
+config.rb:
+
+```ruby
+# -*- coding: utf-8 -*-
+require 'keight'
+require './hello'
+
+app = K8::RackApplication.new
+app.mount '/hello', HelloAction
+
+run app
+```
+
+Open http://localhost:8000/hello or http://localhost:8000/hello/123 by browser.
+
+Do you like it? If so, try `k8rb init myapp1` to generate project skeleton.
+
+```console
+$ k8rb init myapp1
+$ cd myapp1
+$ export APP_ENV=dev    # 'dev', 'prod', or 'stg'
+$ k8rb mapping
+$ k8rb configs
+$ rackup -c config.ru -p 8000
+$ ab -n 1000000 -c 100 http://127.0.0.1:8000/api/hello
+```
+
+
+CheatSheet
+----------
+
+```ruby
+require 'keight'
+
+class HelloAction < K8::Action
+
+  ## mapping
+  mapping '',    :GET=>:do_hello_world
+  mapping '/{name:[a-zA-Z]+}',   :GET=>:do_hello
+
+  ## request, response, and helpers
+
+  def do_hello_world
+    do_hello('World')
+  end
+
+  def do_hello(name)
+
+    ## request
+    @req                   # K8::Request object (!= Rack::Request)
+    @req.env               # Rack environment
+    @req.method            # ex: :GET, :POST, :PUT, ...
+    @req.request_method    # ex: "GET", "POST", "PUT", ...
+    @req.path              # ex: '/api/hello'
+    @req.query             # query string (Hash)
+    @req.form              # form data (Hash)
+    @req.multipart         # multipart form data ([Hash, Hash])
+    @req.json              # JSON data (Hash)
+    @req.params            # query, form, multipart or json
+    @req.cookies           # cookies (Hash)
+    @req.xhr?              # true when requested by jQuery etc
+    @req.client_ip_addr    # ex: '127.0.0.1'
+
+    ## response
+    @resp                  # K8::Response object (!= Rack::Response)
+    @resp.status_code      # ex: 200
+    @resp.status           # alias of @resp.status_code
+    @resp.headers          # Hash object
+    @resp.set_cookie(k, v) # cookie
+    @resp.content_type     # same as @resp.headers['Content-Type']
+    @resp.content_length   # same as @resp.headers['Content-Length'].to_i
+
+    ## session (requires Rack::Session)
+    @sess[key] = val       # set session data
+    @sess[key]             # get session data
+
+    ## helpers
+    token = csrf_token()   # get csrf token
+    validation_failed()    # same as @resp.status_code = 422
+    return redirect_to(location, 302, flash: "message")
+    return send_file(filepath)
+
+  end
+
+
+  ## hook methods
+
+  def before_action        # setup
+    super
+  end
+
+  def after_action(ex)     # teardown
+    super
+  end
+
+  def handle_content(content)   # convert content
+    if content.is_a?(Hash)
+      @resp.content_type = 'application/json'
+      return [JSON.dump(content)]
+    end
+    super
+  end
+
+  def handle_exception(ex)   # exception handler
+    meth = "on_#{ex.class}"
+    return __send__(meth, ex) if respond_to?(meth)
+    super
+  end
+
+  def csrf_protection_required?
+    x = @req.method
+    return x == :POST || x == :PUT || x == :DELETE
+  end
+
+end
+
+## urlpath mapping
+urlpath_mapping = [
+  ['/'               , './app/page/welcome:WelcomePage'],
+  ['/api', [
+    ['/books'        , './app/api/books:BooksAPI'],
+    ['/books/{book_id}/comments'
+                     , './app/api/book_comments:BookCommentsAPI'],
+    ['/orders'       , './app/api/orders:OrdersAPI'],
+  ]],
+]
+
+## application
+opts = {
+  urlpath_cache_size:  0,    # 0 means cache disabled
+}
+app = K8::RackApplication.new(urlpath_mapping, opts)
+```
+
+
+FAQ
+---
+
+#### Why Keight.rb is so fast?
+
+I don't think Keight.rb is so fast. Other frameworks are just too slow.
+
+**You should know that Rails is slow due to Rails itself, and not to Ruby.**
+
+
+#### How to setup template engine?
+
+Try `k8rb init myapp1; cd myapp1; less app/action.rb`.
+
+
+#### How to support static files?
+
+Try `k8rb init myapp1; cd myapp1; less app/action.rb`.
+
+
+#### How to setup session?
+
+Try `k8rb init myapp1; cd myapp1; less config.ru`.
+
+
+#### Can I use Rack::Request and Rack::Response instead of Keight's?
+
+Try `K8::REQUEST_CLASS = Rack::Request; K8::RESPONSE_CLASS = Rack::Response`.
+
+
+#### What `urlpath_cache_size: 0` means?
+
+`K8::RackApplication` can take `urlpath_cache_size: n` keyword arugment.
+
+* If `n == 0` then Keight.rb doesn't cache urlpath mapping containig
+  urlpath parameters such as `/api/books/{id}`.
+* If `n > 0` then Keight.rb caches latest `n` entries of urlpath mapping
+  containing urlpath parameters.
+* Keight.rb always caches urlpath mapping which has no urlpath parameters.
+  For example, `/api/books` is always cached regardless
+  `urlpath_cache_size:` value.
+
+If you need more performance, try `urlpath_cache_size: 1000` or so.
+
+
+License and Copyright
+---------------------
+
+$License: MIT License $
+
+$Copyright: copyright(c) 2014-2015 kuwata-lab.com all rights reserved $

data/Rakefile

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+
+###
+
+RELEASE   = ENV['rel'] || '0.0.0'
+COPYRIGHT = 'copyright(c) 2014-2015 kuwata-lab.com all rights reserved'
+LICENSE   = 'MIT License'
+
+PROJECT   = 'keight'
+
+###
+
+task :default => :test
+
+def edit_content(content)
+  s = content
+  s = s.gsub /\$Release\:.*?\$/,   "$Release\: #{RELEASE} $"
+  s = s.gsub /\$Copyright\:.*?\$/, "$Copyright\: #{COPYRIGHT} $"
+  s = s.gsub /\$License\:.*?\$/,   "$License\: #{LICENSE} $"
+  s = s.gsub /\$Release\$/,   RELEASE
+  s = s.gsub /\$Copyright\$/, COPYRIGHT
+  s = s.gsub /\$License\$/,   LICENSE
+  s
+end
+
+
+desc "run test scripts"
+task :test do
+  #sh "ruby -r minitest/autorun test/*_test.rb"
+  sh "ruby test/#{PROJECT}_test.rb"
+end
+
+
+desc "remove *.rbc"
+task :clean do
+  rm_f [Dir.glob("lib/**/*.rbc"), Dir.glob("test/**/*.rbc")]
+end
+
+
+desc "copy files into 'dist/#{RELEASE}'"
+task :dist => :clean do
+  require_release_number()
+  spec_src = File.open("#{PROJECT}.gemspec") {|f| f.read }
+  spec = eval spec_src
+  dir = "dist/#{RELEASE}"
+  rm_rf dir
+  mkdir_p dir
+  sh "tar cf - #{spec.files.join(' ')} | (cd #{dir}; tar xvf -)"
+  spec.files.each do |fpath|
+    next if fpath =~ /\.(gz|jpg|png|form)\z/
+    #filepath = File.join(dir, fpath)
+    #content = File.open(filepath, 'rb:utf-8') {|f| f.read }
+    #new_content = edit_content(content)
+    #File.open(filepath, 'wb:utf-8') {|f| f.write(new_content) }
+    content = File.open(File.join(dir, fpath), 'r+b:utf-8') do |f|
+      content = f.read
+      new_content = edit_content(content)
+      f.rewind()
+      f.truncate(0)
+      f.write(new_content)
+    end
+  end
+end
+
+
+desc "create rubygem pacakge"
+task :package => :dist do
+  require_release_number()
+  chdir "dist/#{RELEASE}" do
+    sh "gem build *.gemspec"
+  end
+  mv Dir.glob("dist/#{RELEASE}/*.gem"), 'dist'
+end
+
+
+desc "release gem"
+task :release => :package do
+  require_release_number()
+  sh "git tag ruby-#{RELEASE}"
+  chdir "dist" do
+    sh "gem push #{PROJECT}-#{RELEASE}.gem"
+  end
+end
+
+
+def require_release_number
+  if RELEASE == '0.0.0'
+    $stderr.puts "*** Release number is not speicified"
+    $stderr.puts "*** Usage: rake <task> rel=X.X.X"
+    raise StandardError
+  end
+end

data/bench/bench.rb

@@ -0,0 +1,278 @@
+# -*- coding: utf-8 -*-
+
+$LOAD_PATH << '.'
+
+require 'rack'
+require 'sinatra/base'     rescue nil
+require 'rack-multiplexer' rescue nil
+require 'keight'           rescue nil
+
+
+if defined?(Rack)
+
+  class RackApp1
+    def call(env)
+      [200, {"Content-Type"=>"text/html"}, ["<h1>hello</h1>"]]
+    end
+  end
+
+  class RackApp2
+    def call(env)
+      req  = Rack::Request.new(env)
+      [200, {"Content-Type"=>"text/html"}, ["<h1>hello</h1>"]]
+    end
+  end
+
+  class RackApp3
+    def call(env)
+      resp = Rack::Response.new
+      #[resp.status, resp.headers, ["<h1>hello</h1>"]]
+      [200, {"Content-Type"=>"text/html"}, ["<h1>hello</h1>"]]
+    end
+  end
+
+  class RackApp4
+    def call(env)
+      req  = Rack::Request.new(env)
+      resp = Rack::Response.new
+      #[resp.status, resp.headers, ["<h1>hello</h1>"]]
+      [200, {"Content-Type"=>"text/html"}, ["<h1>hello</h1>"]]
+    end
+  end
+
+  rack_app1 = RackApp1.new
+  rack_app2 = RackApp2.new
+  rack_app3 = RackApp3.new
+  rack_app4 = RackApp4.new
+
+end
+
+
+$api_entries   = %w[books authors account orders ranking about news support]
+$admin_entries = ('a'..'z').each_with_index.collect {|c,i| "%s%02d" % [c*3, i+1] }
+
+
+if defined?(Sinatra)
+
+  class SinaApp < Sinatra::Base
+
+    for x in $api_entries
+      get    "/api/#{x}"          do "<h1>index</h1>"  end
+      post   "/api/#{x}"          do "<h1>create</h1>" end
+      #get    "/api/#{x}/new"      do "<h1>new</h1>"    end
+      get    "/api/#{x}/:id"      do "<h1>show</h1>"   end
+      put    "/api/#{x}/:id"      do "<h1>update</h1>" end
+      delete "/api/#{x}/:id"      do "<h1>delete</h1>" end
+      #get    "/api/#{x}/:id/edit" do "<h1>edit</h1>"   end
+    end
+
+    for x in $admin_entries   # 'aaa01', 'bbb02', ..., 'zzz26'
+      get    "/admin/#{x}"        do '<p>index</p>'    end
+      post   "/admin/#{x}"        do '<p>create</p>'   end
+      get    "/admin/#{x}/:id"    do '<p>show</p>'     end
+      put    "/admin/#{x}/:id"    do '<p>update</p>'   end
+      delete "/admin/#{x}/:id"    do '<p>delete</p>'   end
+    end
+
+  end
+
+  sina_app = SinaApp.new
+
+end
+
+
+if defined?(Rack::Multiplexer)
+
+  mplx_dummy = proc {|env|
+    [200, {"Content-Type"=>"text/html"}, ["<h1>hello</h1>"]]
+    #req  = Rack::Request.new(env)
+    #resp = Rack::Response.new
+    #[resp.status, resp.headers, ["<h1>index</h1>"]]
+  }
+
+  mplx_app1 = Rack::Multiplexer.new
+
+  for x in $api_entries
+    mplx_app1.get    "/api/#{x}",           mplx_dummy
+    mplx_app1.post   "/api/#{x}",           mplx_dummy
+    #mplx_app1.get    "/api/#{x}/new",       mplx_dummy
+    mplx_app1.get    "/api/#{x}/:id",       mplx_dummy
+    mplx_app1.post   "/api/#{x}/:id",       mplx_dummy
+    mplx_app1.delete "/api/#{x}/:id",       mplx_dummy
+    #mplx_app1.get    "/api/#{x}/:id/edit",  mplx_dummy
+  end
+  for x in $admin_entries   # 'aaa01', 'bbb02', ..., 'zzz26'
+    mplx_app1.get    "/admin/#{x}",         mplx_dummy
+    mplx_app1.post   "/admin/#{x}",         mplx_dummy
+    mplx_app1.get    "/admin/#{x}/:id",     mplx_dummy
+    mplx_app1.put    "/admin/#{x}/:id",     mplx_dummy
+    mplx_app1.delete "/admin/#{x}/:id",     mplx_dummy
+  end
+
+  mplx_api = Rack::Multiplexer.new
+  for x in $api_entries
+    mplx_api.get    "/api/#{x}",           mplx_dummy
+    mplx_api.post   "/api/#{x}",           mplx_dummy
+   #mplx_api.get    "/api/#{x}/new",       mplx_dummy
+    mplx_api.get    "/api/#{x}/:id",       mplx_dummy
+    mplx_api.post   "/api/#{x}/:id",       mplx_dummy
+    mplx_api.delete "/api/#{x}/:id",       mplx_dummy
+   #mplx_api.get    "/api/#{x}/:id/edit",  mplx_dummy
+  end
+  mplx_admin = Rack::Multiplexer.new
+  for x in $admin_entries   # 'aaa01', 'bbb02', ..., 'zzz26'
+    mplx_admin.get    "/admin/#{x}",         mplx_dummy
+    mplx_admin.post   "/admin/#{x}",         mplx_dummy
+    mplx_admin.get    "/admin/#{x}/:id",     mplx_dummy
+    mplx_admin.put    "/admin/#{x}/:id",     mplx_dummy
+    mplx_admin.delete "/admin/#{x}/:id",     mplx_dummy
+  end
+  mplx_app2 = proc {|env|
+    urlpath = env['PATH_INFO']
+    if urlpath.start_with?('/api')
+      mplx_api.call(env)
+    elsif urlpath.start_with?('/admin')
+      mplx_admin.call(env)
+    else
+      [404, {}, []]
+    end
+  }
+
+end
+
+
+if defined?(K8)
+
+  class DummyAction < K8::Action
+    mapping '',       :GET=>:do_index, :POST=>:do_create
+    #mapping '/new',   :GET=>:do_new
+    mapping '/{id}',  :GET=>:do_show, :PUT=>:do_edit, :DELETE=>:do_delete
+    #mapping '/{id}/edit', :GET=>:do_edit
+    def do_index        ; "<h1>index</h1>"; end
+    def do_create       ; "<h1>create</h1>"; end
+    def do_new          ; "<h1>new</h1>"; end
+    def do_show(id)     ; "<h1>show</h1>"; end
+    def do_update(id)   ; "<h1>update</h1>"; end
+    def do_delete(id)   ; "<h1>delete</h1>"; end
+    def do_edit(id)     ; "<h1>edit</h1>"; end
+  end
+  #
+  k8_app_opts = {urlpath_cache_size: 0}
+  k8_app = K8::RackApplication.new(k8_app_opts)
+  k8_app.mount '/api', [
+    ['/books',   DummyAction],
+    ['/books/{id}/comments', DummyAction],
+    ['/authors', DummyAction],
+    ['/authors/{id}/comments', DummyAction],
+    ['/account', DummyAction],
+    ['/orders',  DummyAction],
+    ['/ranking', DummyAction],
+    ['/about',   DummyAction],
+    ['/news',    DummyAction],
+    ['/support', DummyAction],
+  ]
+  pairs = $admin_entries.collect {|x|  # 'aaa01', 'bbb02', ..., 'zzz26'
+    ["/#{x}", DummyAction]
+  }
+  k8_app.mount '/admin', pairs
+  #
+  k8_app.find('/')     # warm up
+
+end
+
+
+def _chk(tuple)
+  tuple[0] == 200  or raise "200 expected but got #{tuple[0]}"
+  GC.start
+end
+
+$environ = Rack::MockRequest.env_for("http://localhost/")
+$environ['REQUEST_METHOD'] = 'GET'
+
+def newenv(path)
+  env = $environ.dup
+  env['PATH_INFO'] = path
+  env
+end
+
+
+require 'benchmarker'
+
+
+Benchmarker.new(:width=>30, :loop=>100000) do |bm|
+
+  flag_rack = flag_sinatra = flag_multiplexer = flag_keight = false
+  flag_rack        = defined?(Rack)
+  #flag_sinatra     = defined?(Sinatra)
+  flag_multiplexer = defined?(Rack::Multiplexer)
+  flag_keight      = defined?(K8)
+
+  urlpaths = %w[/api/books /api/books/123 /api/support /api/support/123
+                /admin/aaa01 /admin/aaa01/123 /admin/zzz26 /admin/zzz26/123]
+
+
+  tuple = nil
+
+
+  ### empty task
+
+  bm.empty_task do
+    newenv("/api/hello")
+  end
+
+
+  ### Rack
+  if flag_rack
+    rack_apps = [rack_app1, rack_app2, rack_app3, rack_app4]
+    for rack_app, i in rack_apps.each_with_index
+      bm.task("(Rack#{i+1}) /some/where") do
+        tuple = rack_app.call(newenv("/some/where"))
+      end
+      _chk(tuple)
+    end
+  end
+
+
+  ### Sinatra
+  if flag_sinatra
+    for upath in urlpaths
+      bm.task("(Sina) #{upath}") do
+        tuple = sina_app.call(newenv(upath))
+      end
+      _chk(tuple)
+    end
+  end
+
+
+  ### Rack::Multiplexer
+  if flag_multiplexer
+    for upath in urlpaths
+      bm.task("(Mplx) #{upath}") do
+        tuple = mplx_app1.call(newenv(upath))
+      end
+      _chk(tuple)
+    end
+  end
+
+  if flag_multiplexer
+    for upath in urlpaths
+      bm.task("(Mplx') #{upath}") do
+        tuple = mplx_app2.call(newenv(upath))
+      end
+      _chk(tuple)
+    end
+  end
+
+
+  ### Keight
+
+  if flag_keight
+    for upath in urlpaths
+      bm.task("(K8) #{upath}") do
+        tuple = k8_app.call(newenv(upath))
+      end
+      _chk(tuple)
+    end
+  end
+
+end