keight 0.0.1

data/bin/k8rb

@@ -0,0 +1,496 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+###
+### $Release: 0.0.1 $
+### $Copyright: copyright(c) 2014-2015 kuwata-lab.com all rights reserved $
+### $License: MIT License $
+###
+
+
+require 'digest/sha1'
+
+require 'keight'
+require 'baby_erubis'
+
+
+module K8
+
+
+  class Main
+
+    @__current = nil
+    @__actions = []
+
+    @action = proc do |action_name, desc|
+      options = []
+      method_name = nil
+      tuple = [action_name, desc, options, method_name]
+      @__current = tuple
+      @__actions << tuple
+    end
+
+    @option = proc do |optdef_str, desc|
+      tuple = @__current  or
+        raise "@option.() is called without @action.()"
+      tuple[2] << [optdef_str, desc]
+    end
+
+    def self.method_added(method_name)
+      tuple = @__current  or return
+      tuple[3] = method_name
+      @__current = nil
+    end
+
+    def self.find_action(name)
+      name = name.to_s
+      return @__actions.find {|tuple| tuple[0].to_s == name }
+    end
+
+    def self.each_action(&block)
+      @__actions.each(&block)
+    end
+
+
+    ###
+
+    def initialize(script_name=nil)
+      @script_name = script_name || File.basename($0)   # ex: 'k8rb'
+    end
+
+    attr_reader :script_name
+
+
+    ### actions
+
+    @action.(:help, "show help")
+    def do_help(action_name=nil)
+      script = self.script_name
+      sb = []
+      if action_name.nil?
+        sb <<   "Usage:"
+        sb <<   "  #{script} ACTION [..OPTIONS..]"
+        sb <<   ""
+        sb <<   "Actions:"
+        self.class.each_action do |action_name, desc, options, _|
+          next unless desc
+          help = desc.lines.first.chomp()
+          sb << "  #{script} %-15s # #{help}" % [action_name, help]
+        end
+        sb <<   ""
+        sb <<   "(Tips: try '#{script} help ACTION' for details of each action.)"
+      else
+        tuple = self.class.find_action(action_name)  or
+          raise K8::OptionError.new("help #{action_name}: no such action.")
+        action_name, desc, options, method_name = tuple
+        pnames = self.method(method_name).parameters.collect {|kind, pname|
+          case kind
+          when :req  ;  pname
+          when :opt  ;  "[#{pname}]"
+          when :rest ;  "[#{pname}...]"
+          when :key  ;  nil
+          else
+            raise "** kind=#{kind.inspect}, pname=#{pname.inspect}"
+          end
+        }.compact()
+        pnames.unshift('') unless pnames.empty?
+        argstr = pnames.join(' ')
+        sb <<   "#{script} #{action_name}  - #{desc}"
+        sb <<   ""
+        sb <<   "Usage:"
+        if options.empty?
+          sb << "  #{script} #{action_name}#{argstr}"
+        else
+          sb << "  #{script} #{action_name} [options]#{argstr}"
+          sb << ""
+          sb << "Options:"
+          options.each do |optdef_str, optdesc|
+            optstr = optdef_str.sub(/\A\s*--/, '    --').sub(/\s+\#\w+\s*\z/, '')
+            sb << "  %-20s # %s" % [optstr, optdesc] if optdesc
+          end
+        end
+      end
+      sb << ""
+      sb << ""
+      return sb.join("\n")
+    end
+
+    @action.(:init, "create project files")
+    @option.("-s, --skeleton=DIR", "directory of skeleton files")
+    def do_init(project_name, dir: nil)
+      dir ||= K8::FILEPATH.sub(/\.rb\z/, '') + "/skeleton"
+      if dir
+        File.directory?(dir)  or
+          raise "#{dir}: directory not exist."
+        o = K8::FileTool.new
+        descs = o.parse_index_file("#{dir}/index.txt")
+        o.mkdir(project_name, "project root directory")
+        files = Dir.glob("#{dir}/**/*")
+        files.concat(["#{dir}/.gitignore"])
+        files.each do |path|
+          base = path[(dir.length+1)..-1]
+          if base == "index.txt"
+            next
+          elsif base =~ /\/\.keep\z/
+            next
+          elsif File.directory?(path)
+            o.mkdir("#{project_name}/#{base}", descs[base+"/"])
+          elsif File.file?(path)
+            content = path =~ /\Astatic\/lib|\.gz\z/  \
+            ? File.read(path, encoding: 'ascii-8bit')  \
+            : K8::SkeletonTemplate.new.from_file(path, 'ascii-8bit').render()
+            o.mkfile("#{project_name}/#{base}", content, descs[base])
+          else
+            next
+          end
+        end
+        return
+      end
+      0
+    end
+
+    @action.(:mapping, "show action mappings")
+    def do_mapping()
+      ENV['APP_MODE'] ||= 'dev'
+      load_config()
+      require './config/urlpath_mapping'
+      app = K8::RackApplication.new
+      $urlpath_mapping.each do |urlpath, children|
+        app.mount(urlpath, children)
+      end
+      return app.show_mappings()
+    end
+
+    @action.(:configs, "list config keys and values")
+    @option.("--getenv", "show actual ENV value")
+    def do_configs(getenv: false)
+      ENV['APP_MODE'] ||= 'dev'
+      load_config()
+      s = ""
+      ::Config.each do |key, val, desc, secret|
+        kv = "%-20s = %s" % [key, __var_dump(val, secret, getenv)]
+        s << ("%-43s # %s\n" % [kv, desc]) if desc
+      end
+      return s
+    end
+
+    @action.(:config, "show config value")
+    @option.("--getenv", "show actual ENV value")
+    def do_config(key, getenv: false)
+      key_name = key
+      ENV['APP_MODE'] ||= 'dev'
+      load_config()
+      ::Config.each do |key, val, desc, secret|
+        if key.to_s == key_name
+          return __var_dump(val, secret, getenv)
+        end
+      end
+      $stderr.puts "#{key_name}: no such config key."
+      return 1
+    end
+
+    @action.(:'config:check', "check config values")
+    def do_config_check()
+      ENV['APP_MODE'] ||= 'dev'
+      load_config()
+      not_set = []
+      not_env = []
+      ::Config.each do |key, val, desc, secret|
+        if val.is_a?(K8::SecretValue)
+          if ! val.name
+            not_set << [key, val, desc]
+          elsif ! ENV[val.name]
+            not_env << [key, val, desc]
+          end
+        end
+      end
+      if not_set.empty? && not_env.empty?
+        puts "ok."
+        return 0
+      else
+        sb = []
+        sb <<     "**"
+        sb <<     "** NG!"
+        unless not_set.empty?
+          sb <<   "**"
+          sb <<   "** The following configs should be set, but not."
+          sb <<   "**"
+          not_set.each do |key, val, desc|
+            sb << "**   %-20s = %s" % [key, val.inspect]
+          end
+        end
+        unless not_env.empty?
+          sb <<   "**"
+          sb <<   "** The following configs expect environment variable, but not set."
+          sb <<   "**"
+          not_env.each do |key, val, desc|
+            sb << "**   %-20s = %s" % [key, val.inspect]
+          end
+        end
+        sb <<     "**"
+        puts sb.join("\n")
+        return 1
+      end
+    end
+
+    def __var_dump(val, secret, getenv)
+      if ! val.is_a?(K8::SecretValue)
+        #secret ? '<secret>' : val.inspect
+        val.inspect
+      elsif val.name
+        getenv ? ENV[val.name].inspect : "ENV['#{val.name}']"
+      else
+        '<SECRET>'
+      end
+    end
+    private :__var_dump
+
+
+    if ENV['DEBUG']
+      @action.(:debug, "debug")
+      @option.("-h, --help"       , "show help message")
+      @option.("--version"        , "print version")
+      #@option.("-f, --file=FILE"  , "filename")
+      @option.("-f FILE  #file"  , "filename")
+      @option.("-i, --indent[=N]" , "indent depth (default 2)")
+      @option.("-s"               , "be silent")
+      @option.("-S      #silent"  , "be silent")
+      @option.("-d[N]   #dbg1"    , "debug level #1")
+      @option.("  --dbg2[=N]"     , "debug level #2")
+      def do_debug(argmnt=nil, help: nil, version: nil, file: nil, indent: nil, s: nil, silent: false, dbg1: nil, dbg2: nil)
+        sb = []
+        sb << "** argmnt  = #{argmnt.inspect}"
+        sb << "** help:     #{help.inspect}"
+        sb << "** version:  #{version.inspect}"
+        sb << "** file:     #{file.inspect}"
+        sb << "** indent:   #{indent.inspect}"
+        sb << "** s:        #{s.inspect}"
+        sb << "** silent:   #{silent.inspect}"
+        sb << "** dbg1:     #{dbg1.inspect}"
+        sb << "** dbg2:     #{dbg2.inspect}"
+        return sb.join("\n")
+      end
+    end
+
+
+    ###
+
+    def load_config
+      require './config' rescue K8::ConfigError
+    end
+
+    def run(*cmd_args)
+      action_name = cmd_args.shift() || 'help'
+      tuple = self.class.find_action(action_name)  or
+        raise K8::OptionError.new("#{action_name}: unknown action.")
+      action_name, desc, options, method_name = tuple
+      optdefs = options.collect {|arr| K8::OptionDefinition.new(*arr) }
+      optparser = K8::OptionParser.new(optdefs)
+      cmd_opts = optparser.parse(cmd_args)
+      func_args = []
+      func_kwds = {}
+      method_params = self.method(method_name).parameters
+      method_params.each do |param_info|
+        kind, pname = param_info
+        case kind
+        when :req
+          ! cmd_args.empty?  or
+            raise K8::OptionError.new("#{action_name}: argument '#{pname}' required.")
+          func_args << cmd_args.shift()
+        when :opt
+          func_args << cmd_args.shift()   # may be nil
+        when :rest
+          func_args.concat(cmd_args)
+          cmd_args.clear()
+        when :key
+          k = pname.to_s
+          func_kwds[pname] = cmd_opts.delete(k) if cmd_opts.key?(k)
+          if cmd_opts.key?(pname.to_s)
+            func_kwds[pname] = cmd_opts.delete(pname.to_s)
+          end
+        else
+          $stderr.puts "*** internal error: kind=#{kind.inspect}, pname=#{pname.inspect}"
+        end
+      end
+      cmd_args.empty?  or
+        raise K8::OptionError.new("#{action_name}: too many argument.")
+      cmd_opts.empty?  or
+        raise K8::OptionError.new("#{action_name}: keyword arg not defined (#{cmd_opts.inspect}).")
+      if func_kwds.empty?
+        output = __send__(method_name, *func_args)
+      else
+        output = __send__(method_name, *func_args, func_kwds)
+      end
+      return output
+    end
+
+    def self.main
+      status = 0
+      obj = self.new()
+      begin
+        output = obj.run(*ARGV)
+        case output
+        when nil     ;
+        when String  ; puts output
+        when Integer ; status = output
+        else         ; raise "** output=#{output.inspect}"
+        end
+      rescue K8::OptionError => ex
+        $stderr.puts "ERROR (#{obj.script_name}): #{ex}"
+        output = nil
+        status = 1
+      end
+      exit status
+    end
+
+  end
+
+
+  class OptionDefinition
+
+    def initialize(defstr, desc)
+      @defstr = defstr
+      @desc   = desc
+      parse(defstr)
+    end
+
+    attr_reader :defstr, :name, :desc, :short, :long, :argstr, :arg_required
+
+    def parse(defstr)
+      case defstr
+      when /\A\s*-(\w),\s+--(\w[-\w]*)(?:=(\S*)|\[=(\S+)\])?(?:\s+\#(\w+))?\z/
+        short, long, arg1, arg2, optname = $1, $2, $3, $4, $5
+      when /\A\s*--(\w[-\w]*)(?:=(\S*)|\[=(\S+)\])?(?:\s+\#(\w+))?\z/
+        short, long, arg1, arg2, optname = nil, $1, $2, $3, $4
+      when /\A\s*-(\w)(?:\s+(\S+)|\[(\S+)\])?(?:\s+\#(\w+))?\z/
+        short, long, arg1, arg2, optname = $1, nil, $2, $3, $4
+      else
+        raise "#{defstr.inspect}: invalid option definition."
+      end
+      @short    = short
+      @long     = long
+      @argstr   = arg1 || arg2
+      @arg_required = !! arg1       # true when option argument is required
+      @name     = optname || long || short
+    end
+
+  end
+
+
+  class OptionParser
+
+    def initialize(optdefs)
+      @optdefs = optdefs
+    end
+
+    def parse(cmd_args)
+      options = {}
+      while cmd_args.length > 0 && cmd_args.first.start_with?('-')
+        optstr = cmd_args.shift()
+        if optstr == '--'
+          break
+        elsif optstr.start_with?('--')
+          optstr =~ /\A--(\w+)(?:=(.*))?\z/  or
+            raise OptionError.new("#{optstr}: invalid option.")
+          long, optarg = $1, $2
+          optdef = @optdefs.find {|x| x.long == long }  or
+            raise OptionError.new("#{optstr}: unknown option.")
+          if ! optdef.argstr && optarg
+            raise OptionError.new("#{optstr}: unexpected argument.")
+          elsif optdef.arg_required && ! optarg
+            raise OptionError.new("#{optstr}: argument required.")
+          end
+          options[optdef.name] = optarg || true
+        else
+          i = 0; len = optstr.length
+          while (i += 1) < len
+            ch = optstr[i]
+            optdef = @optdefs.find {|x| x.short == ch }  or
+              raise OptionError.new("-#{ch}: unknown option.")
+            if ! optdef.argstr             # no arg
+              optarg = true
+            elsif ! optdef.arg_required    # optional arg
+              optarg = i + 1 < len ? optstr[(i+1)..-1] : true
+              i = len - 1
+            else                           # required arg
+              optarg = optstr[(i+1)..-1]
+              if optarg.empty?
+                optarg = cmd_args.shift()  or
+                  raise OptionError.new("-#{ch}: argument required.")
+              end
+              i = len - 1
+            end
+            options[optdef.name] = optarg
+          end
+        end
+      end
+      return options
+    end
+
+  end
+
+
+  class OptionError < StandardError
+  end
+
+
+  class SkeletonTemplate < BabyErubis::Text
+
+    rexp = BabyErubis::Text::PATTERN
+    PATTERN = Regexp.compile(rexp.to_s.sub(/<%/, '\{%').sub(/%>/, '%\}'))
+
+    def pattern
+      PATTERN
+    end
+
+  end
+
+
+  class FileTool
+
+    def initialize(width: 30)
+      @width = width
+      @depth = 0
+    end
+
+    def parse_index_file(index_file)
+      dict = File.open(index_file) {|f|
+        f.grep(/^[^#]/).each_with_object({}) {|line, d|
+          path, desc = line.chomp.split(/\s+/, 2)
+          d[path] = desc
+        }
+      }
+      return dict
+    end
+
+    def report(s, desc)
+      indent = '  ' * @depth
+      puts "%s%-#{@width - indent.length}s # %s" % [indent, s, desc]
+    end
+
+    def mkrootdir(dirpath)
+      @root = dirpath
+      mkdir(dirpath)
+    end
+
+    def mkdir(dirpath, desc)
+      Dir.mkdir dirpath
+      s = dirpath.gsub(/.*?[\/\\]/, '  ') + "/"
+      report(s, desc)
+    end
+
+    def mkfile(filepath, content, desc)
+      File.open(filepath, 'wb') {|dst| dst.write(content) }
+      s = filepath.gsub(/.*?[\/\\]/, '  ')
+      report(s, desc)
+    end
+
+  end
+
+
+end
+
+
+#if __FILE__ == $0
+  K8::Main.main() unless defined? NOEXEC_SCRIPT
+#end

data/keight.gemspec

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+
+Gem::Specification.new do |o|
+  o.name          = "keight"
+  o.version       = "$Release: 0.0.1 $".split[1]
+  o.author        = "makoto kuwata"
+  o.email         = "kwa(at)kuwata-lab.com"
+  o.platform      = Gem::Platform::RUBY
+  o.homepage      = "https://github.com/kwatch/keight/tree/ruby"
+  o.license       = "MIT Lisense"
+  o.summary       = "Jet-speed webapp framework for Ruby"
+  o.description   = <<'END'
+Keight.rb is the crazy-fast webapp framework for Ruby.
+It is about 100 times faster than Rails and 20 times faster than Sinatra.
+
+See https://github.com/kwatch/keight/tree/ruby for details.
+END
+
+  o.files         = Dir[*%w[
+                      README.md MIT-LICENSE keight.gemspec setup.rb Rakefile
+                      bin/k8rb
+                      lib/keight.rb lib/keight/**/*.{[a-z]*} lib/keight/**/.{[a-z]*}
+                      test/*_test.rb test/data/* test/oktest.rb
+                      bench/bench.rb bench/benchmarker.rb
+                    ]]
+                      #lib/keight.rb lib/keight/**/*
+  o.executables   = ["k8rb"]
+  o.bindir        = ["bin"]
+  #o.test_files   = o.files.grep(/^test\//)
+  o.test_file     = "test/keight_test.rb"
+
+  o.required_ruby_version = '>= 2.0'
+  o.add_runtime_dependency 'baby_erubis', '~> 2.1', '>= 2.1.1'
+  #o.add_development_dependency "oktest", "~> 0"
+end

data/lib/keight/skeleton/.gitignore

@@ -0,0 +1,10 @@
+config/*.private
+*.cache
+*.gem
+*.rbc
+tmp/
+.bundle
+.rvmrc
+.repl_history
+.yardoc
+_yardoc

data/lib/keight/skeleton/app/action.rb

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+
+require 'keight'
+require 'baby_erubis'
+require 'baby_erubis/renderer'
+
+require './config'
+
+
+module My
+end
+
+
+class My::Action < K8::Action
+
+
+  ##
+  ## template
+  ##
+
+  include BabyErubis::HtmlEscaper
+  include BabyErubis::Renderer
+
+  ERUBY_PATH       = ['app/template']
+  ERUBY_LAYOUT     = :_layout
+  ERUBY_HTML       = BabyErubis::Html
+  ERUBY_HTML_EXT   = '.html.eruby'
+  ERUBY_TEXT       = BabyErubis::Text
+  ERUBY_TEXT_EXT   = '.eruby'
+  ERUBY_CACHE      = {}
+
+  protected
+
+  alias render_html eruby_render_html
+  alias render_text eruby_render_text
+
+
+  ##
+  ## event handler (= exception handler)
+  ##
+
+  protected
+
+  ##
+  ## Define event handlers here.
+  ##
+  ## ex:
+  ##   class Event < Exception; end
+  ##   class NotExist < Event; end
+  ##   class NotPermitted < Event; end
+  ##
+  ##   def on_NotExist(ev)    # or: define_method "on_Foo::Bar" do |ev|
+  ##     @resp.status_code = 404   # 404 Not Found
+  ##     {"error"=>"Not exist"}
+  ##   end
+  ##   def on_NotPermitted(ev)
+  ##     @resp.status_code = 403   # 403 Forbidden
+  ##     {"error"=>"Not permitted"}
+  ##   end
+  ##
+  ##   def do_show(id)
+  ##     item = Item.find(id)  or raise NotExist
+  ##     return {"item"=>{"id"=>id, "name"=>item.name}}
+  ##   end
+  ##
+
+
+end
+
+
+class My::AdminAction < My::Action
+
+  ## override template configs
+  ERUBY_PATH       = ['admin/template']
+  ERUBY_LAYOUT     = :_admin_layout
+
+end
+
+
+class My::StaticPage  < My::Action
+
+  mapping '/{urlpath:.+}',   :GET=>:do_send_file
+  STATIC_DIR = "static"
+
+  def do_send_file(urlpath)
+    filepath = "#{STATIC_DIR}/#{urlpath}"
+    File.file?(filepath)  or raise K8::HttpException.new(404)
+    #env = @req.env
+    #header_name = env['sendfile.type'] || env['HTTP_X_SENDFILE_TYPE']
+    #if header_name && ! header_name.empty?
+    #  @resp.headers[header_name] = filepath
+    #  return nil
+    #else
+      return send_file(filepath)
+    #end
+  end
+
+end

data/lib/keight/skeleton/app/api/hello.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+require 'keight'
+
+#require_relative '../action'
+
+
+class HelloAPI < K8::Action    # or My::Action
+
+  mapping ''        , :GET=>:do_index, :POST=>:do_create
+  mapping '/{id}'   , :GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete
+  ## or if you want support '/hello.json' and '/hello/123.json':
+  #mapping '{ext}'        , :GET=>:do_index, :POST=>:do_create
+  #mapping '/{id}{ext}'   , :GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete
+
+  def do_index()
+    query = @req.params_query   # QUERY_STRING
+    {"action"=>"index", "query"=>query}
+  end
+
+  def do_create()
+    form = @req.params_form   # or @req.params_json
+    {"action"=>"create", "form"=>form}
+  end
+
+  def do_show(id)
+    {"action"=>"show", "id"=>id}
+  end
+
+  def do_update(id)
+    form = @req.params_form   # or @req.params_json
+    {"action"=>"update", "id"=>id, "form"=>form}
+  end
+
+  def do_delete(id)
+    {"action"=>"delete", "id"=>id}
+  end
+
+end