nyara 0.0.1.pre

data/lib/nyara/view.rb

@@ -0,0 +1,317 @@
+module Nyara
+  module Renderable
+  end
+
+  # A support class which provides:
+  # - layout / locals for rendering
+  # - template search
+  # - template default content-type mapping
+  # - template precompile
+  # - streaming
+  #
+  # Streaming is implemented in this way: when +Fiber.yield+ is called, we flush +View#out+ and send the data.
+  # This adds a bit limitations to the layouts.
+  # Consider this case (+friend+ fills into View#out, while +enemy+ doesn't):
+  #
+  #   friend layout { enemy layout { friend page } }
+  #
+  # Friend layout and friend page shares one buffer, but enemy layout just concats +buffer.join+ before we flush friend layout.
+  # So the simple solution is: templates other than stream-friendly ones are not allowed to be a layout.
+  #
+  # Note on Erubis: to support streaming, Erubis is disabled even loaded.
+  class View
+    # ext (without dot) => most preferrable content type (e.g. "text/html")
+    ENGINE_DEFAULT_CONTENT_TYPES = ParamHash.new
+
+    # ext (without dot) => stream friendly
+    ENGINE_STREAM_FRIENDLY = ParamHash.new
+
+    class Buffer < Array
+      def join
+        r = super
+        clear
+        r
+      end
+    end
+
+    class << self
+      def init
+        @root = Config['views']
+        @meth2ext = {} # meth => ext (without dot)
+        @meth2sig = {}
+      end
+      attr_reader :root
+
+      # +path+ needs extension
+      def on_delete path
+        meth = path2meth path
+        Renderable.class_eval do
+          undef meth
+        end
+
+        @meth2ext.delete meth
+        @meth2sig.delete meth
+      end
+
+      def on_delete_all
+        meths = @meth2sig
+        Renderable.class_eval do
+          meths.each do |meth, _|
+            undef meth
+          end
+        end
+        @meth2sig.clear
+        @meth2ext.clear
+      end
+
+      # +path+ needs extension
+      # returns dot_ext for further use
+      def on_update path
+        meth = path2meth path
+        return unless @meth2sig[meth] # has not been searched before, see also View.template
+
+        ext = File.extname(path)[1..-1]
+        return unless ext
+        src = precompile ext do
+          Dir.chdir(@root){ File.read path, encoding: 'utf-8' }
+        end
+
+        if src
+          sig = @meth2sig[meth].map{|k| "#{k}: nil" }.join ','
+          sig = '_={}' if sig.empty?
+          Renderable.class_eval <<-RUBY, path, 1
+            def render #{sig}
+              #{src}
+            end
+            alias :#{meth.inspect} render
+          RUBY
+        else
+          t = Dir.chdir @root do
+            # todo display template error
+            Tilt.new path rescue return
+          end
+          # partly precompiled
+          Renderable.send :define_method, meth do |locals=nil, &p|
+            t.render self, locals, &p
+          end
+        end
+
+        @meth2ext[meth] = ext
+      end
+
+      # define inline render method and add Content-Type mapping
+      def register_engine ext, default_content_type, stream_friendly=false
+        # todo figure out fname and line
+        meth = engine2meth ext
+        file = "file".inspect
+        line = 1
+
+        if stream_friendly
+          Renderable.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def render locals={}
+              @_nyara_locals = locals
+              src = locals.map{|k, _| "\#{k} = @_nyara_locals[:\#{k}];" }.join
+              src << View.precompile(#{ext.inspect}){ @_nyara_view.in }
+              instance_eval src, #{file}, #{line}
+            end
+            alias :#{meth.inspect} render
+          RUBY
+          ENGINE_STREAM_FRIENDLY[ext] = true
+        else
+          Renderable.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def render locals=nil
+              Tilt[#{ext.inspect}].new(#{file}, #{line}){ @_nyara_view.in }.render self, locals
+            end
+            alias :#{meth.inspect} render
+          RUBY
+        end
+        ENGINE_DEFAULT_CONTENT_TYPES[ext] = default_content_type
+      end
+
+      # returns +[meth, ext_without_dot]+
+      def template path, locals={}
+        if File.extname(path).empty?
+          @ext_list ||= Tilt.mappings.keys.delete_if(&:empty?).join ','
+          Dir.chdir @root do
+            paths = Dir.glob("#{path}.{#@ext_list}")
+            if paths.size > 1
+              raise ArgumentError, "more than 1 matching views: #{paths.inspect}, add file extension to distinguish them"
+            end
+            path = paths.first
+          end
+        end
+
+        meth = path2meth path
+        ext = @meth2ext[meth]
+        return [meth, ext] if ext
+
+        @meth2sig[meth] = locals.keys
+        ext = on_update path
+        raise "template not found or not valid in Tilt: #{path}" unless ext
+        [meth, ext]
+      end
+
+      # private
+
+      # Block is lazy invoked when it's ok to read the template source.
+      def precompile ext
+        src_method =\
+          case ext
+          when 'slim'
+            :slim_src
+          when 'erb', 'rhtml'
+            :erb_src
+          when 'haml'
+            :haml_src
+          end
+        return unless src_method
+
+        send src_method, yield
+      end
+
+      def erb_src template
+        @erb_compiler ||= begin
+          c            = ERB::Compiler.new '<>' # trim mode
+          c.pre_cmd    = ["_erbout = @_nyara_view.out"]
+          c.put_cmd    = "_erbout.push"   # after newline
+          c.insert_cmd = "_erbout.push"   # before newline
+          c.post_cmd   = ["_erbout.join"]
+          c
+        end
+        src, enc = @erb_compiler.compile template
+        # todo do sth with enc?
+        src
+      end
+
+      def slim_src template
+        # todo pretty by env
+        t = Slim::Template.new(nil, nil, pretty: false){ template }
+        src = t.instance_variable_get :@src
+        if src.start_with?('_buf = []')
+          src.sub! '_buf = []', '_buf = @_nyara_view.out'
+        end
+        src
+      end
+
+      def haml_src template
+        e = Haml::Engine.new template
+        # todo trim mode
+        <<-RUBY
+_hamlout = Haml::Buffer.new(nil, encoding: 'utf-8')
+_hamlout.buffer = @_nyara_view.out
+#{e.precompiled}
+_hamlout.buffer.join
+RUBY
+      end
+
+      def path2meth path
+        "!!#{path}"
+      end
+
+      def engine2meth engine
+        "!:#{engine}"
+      end
+    end
+
+    # NOTE this is the list used in View.precompile
+    %w[slim erb rhtml haml].each {|e| register_engine e, 'text/html', true }
+
+    %w[ad adoc asciidoc erubis builder liquid mab markdown mkd md
+      textile rdoc radius nokogiri wiki creole mediawiki mw
+    ].each {|e| register_engine e, 'text/html' }
+
+    register_engine 'str', 'text/plain'
+    register_engine 'coffee', 'application/javascript'
+    register_engine 'yajl', 'application/javascript'
+    register_engine 'rcsv', 'application/csv'
+    register_engine 'sass', 'text/stylesheet'
+    register_engine 'scss', 'text/stylesheet'
+    register_engine 'less', 'text/stylesheet'
+
+    # If view_path not given, find template source in opts
+    def initialize instance, view_path, layout, locals, opts
+      locals ||= {}
+      if view_path
+        raise ArgumentError, "unkown options: #{opts.inspect}" unless opts.empty?
+        meth, ext = View.template(view_path, locals)
+
+        unless @deduced_content_type = ENGINE_DEFAULT_CONTENT_TYPES[ext]
+          raise ArgumentError, "unkown template engine: #{ext.inspect}"
+        end
+
+        @layouts = [[meth, ext]]
+      else
+        raise ArgumentError, "too many options, expected only 1: #{opts.inspect}" if opts.size > 1
+        ext, template = opts.first
+        meth = View.engine2meth ext
+
+        unless @deduced_content_type = ENGINE_DEFAULT_CONTENT_TYPES[ext]
+          raise ArgumentError, "unkown template engine: #{ext.inspect}"
+        end
+
+        @layouts = [meth]
+        @in = template
+      end
+
+      unless layout.is_a?(Array)
+        layout = layout ? [layout] : []
+      end
+      layout.each do |l|
+        pair = View.template(l)
+        # see notes on View
+        raise "can not use #{meth} as layout" unless ENGINE_STREAM_FRIENDLY[pair[1]]
+        @layouts << pair
+      end
+
+      @locals = locals
+      @instance = instance
+      @instance.instance_variable_set :@_nyara_view, self
+      @out = Buffer.new
+    end
+    attr_reader :deduced_content_type, :in, :out
+
+    def render
+      @rest_layouts = @layouts.dup
+      @instance.send_chunk _render
+      Fiber.yield :term_close
+    end
+
+    # :nodoc:
+    def _render
+      t, _ = @rest_layouts.pop
+      if @rest_layouts.empty?
+        @instance.send t, @locals
+      else
+        @instance.send t do
+          _render
+        end
+      end
+    end
+
+    def stream
+      @rest_layouts = @layouts.dup
+      @fiber = Fiber.new do
+        @rest_result = _render
+        nil
+      end
+      self
+    end
+
+    def resume
+      r = @fiber.resume
+      Fiber.yield r if r
+      unless @out.empty?
+        @instance.send_chunk @out.join
+        @out.clear
+      end
+    end
+
+    def end
+      while @fiber.alive?
+        resume
+      end
+      @instance.send_chunk @rest_result
+      Fiber.yield :term_close
+    end
+  end
+end

data/lib/nyara.rb

@@ -0,0 +1,25 @@
+# auto run
+require_relative "nyara/nyara"
+
+at_exit do
+  Nyara::Route.compile
+  Nyara::View.init
+  Nyara.start_server
+end
+
+module Nyara
+  class SimpleController < Controller
+  end
+end
+
+%w[on tag get post put delete patch options].each do |m|
+  eval <<-RUBY
+  def #{m} *xs, &blk
+    Nyara::SimpleController.#{m} *xs, &blk
+  end
+  RUBY
+end
+
+configure do
+  map '/', 'nyara::simple'
+end

data/nyara.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name = "nyara"
+  s.version = "0.0.1.pre"
+  s.author = "Zete Lui"
+  s.email = "nobody@example.com"
+  s.homepage = "https://github.com/luikore/nyara"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Fast, slim and fuzzy ruby web framework + server"
+  s.description = "Fast, slim and fuzzy ruby web framework + server, based on preforked event queue and Fiber. NO rack NOR eventmachine are used."
+  s.required_ruby_version = ">=2.0.0"
+  s.licenses = ['BSD']
+
+  s.files = Dir.glob('{rakefile,nyara.gemspec,readme.md,**/*.{rb,h,c,cc,inc}}')
+  s.files += Dir.glob('ext/http-parser/{AUTHORS,CONTRIBUTIONS,LICENSE-MIT}')
+  s.files += Dir.glob('ext/multipart-parser-c/README.md')
+  s.require_paths = ["lib"]
+  s.extensions = ["ext/extconf.rb"]
+  s.rubygems_version = '2.0.3'
+  s.has_rdoc = false
+end

data/rakefile

@@ -0,0 +1,91 @@
+require "rake"
+
+Dir.chdir __dir__
+
+status_file = "ext/inc/status_codes.inc"
+version_file = "ext/inc/version.inc"
+
+desc "code generate"
+task :gen => [status_file, version_file]
+
+desc "generate #{status_file}"
+file status_file do
+  puts "generating: #{status_file}"
+  require "nokogiri"
+  require "open-uri"
+  f = File.open status_file, 'w'
+  f.puts "#define HTTP_STATUS_CODES(XX)\\"
+  Nokogiri::XML(open("http://www.iana.org/assignments/http-status-codes/http-status-codes.xml")).css("record").each do |r|
+    value = r.css('value').text
+    next if value.index '-'
+    description = r.css('description').text
+    f.puts %Q|  XX(#{value}, "#{description}");\\|
+  end
+  f.puts "// end define"
+  f.close
+end
+
+desc "generate #{version_file}"
+file version_file => 'nyara.gemspec' do
+  puts "generating: #{version_file}"
+  lines = File.readlines('nyara.gemspec')
+  version = nil
+  lines.each do |line|
+    if line =~ /s\.version =/
+      version = line[/\d+(\.\d+)*(\.pre)?/]
+      break
+    end
+  end
+  abort 'version not found' unless version
+  File.open version_file, 'w' do |f|
+    f.puts %Q{#define NYARA_VERSION "#{version}"}
+  end
+end
+
+desc "build ext"
+task :build do
+  Dir.chdir 'ext' do
+    sh 'make'
+  end
+end
+
+desc "test"
+task :test => :build do
+  sh 'rspec', '-c'
+end
+
+desc "build and test"
+task :default => :test
+
+desc "build and install gem"
+task :gem do
+  sh 'rm', '-f', '*.gem'
+  sh 'gem', 'build', 'nyara.gemspec'
+  gem_package = Dir.glob('*.gem').first
+  sh 'gem', 'install', '--no-rdoc', '--no-ri', gem_package
+end
+
+desc "clean"
+task :clean do
+  sh 'rm', '-f', '*.gem'
+  Dir.chdir 'ext' do
+    sh 'make', 'clean'
+  end
+end
+
+# -- utils --
+
+desc "collect line stat"
+task :lines do
+  c = 0
+  Dir.glob('{**/*.rb,ext/*.{c,cc,h}}') do |f|
+    c += (File.read(f).count "\n")
+  end
+  puts "#{c} lines"
+end
+
+desc "list Nyara::Ext methods"
+task :list_ext do
+  require_relative "lib/nyara/nyara"
+  puts Nyara::Ext.methods - Module.methods
+end

data/readme.md

@@ -0,0 +1,35 @@
+git submodule update --recursive
+rake gen
+rake gem
+
+# Why fast
+
+## Solid http parsers written in C
+
+These evented parsers are used:
+
+- http_parser with chunked encoding support
+- multipart request parser
+
+And these are implemented in addition:
+
+- `Accept-*` parser
+- mime type parser and content type matcher
+- url-encoded parser for parsing path / query / request body
+
+## Fast first-line routing and request class
+
+## Thin evented IO layer built for *nix and Fiber
+
+# How fast
+
+Speed is feature, there are specs on:
+
+- Accept-* parse vs rack
+- MIME parse vs rack
+- query parse vs rack
+- query parse vs houdini
+- layout engine vs tilt
+- evented IO vs eventmachine
+- helloworld vs sinatra
+- pseudo real app speed vs jruby sinatra threaded mode

data/spec/ext_mime_match_spec.rb

@@ -0,0 +1,27 @@
+require_relative "spec_helper"
+
+module Nyara
+  describe Ext, '.mime_match' do
+    it "#mime_match_seg" do
+      a = Ext.mime_match_seg 'text', 'text', 'html'
+      assert_equal true, a
+
+      a = Ext.mime_match_seg 'text/html', 'text', 'stylesheet'
+      assert_equal false, a
+
+      a = Ext.mime_match_seg '*', 'text', 'html'
+      assert_equal true, a
+    end
+
+    it "#mime_match works with wildcards" do
+      a = Ext.mime_match %w'*', [%w'text html html']
+      assert_equal 'html', a
+
+      a = Ext.mime_match %w'application/javascript text/*', [%w'some text txt', %w'text html html']
+      assert_equal 'html', a
+
+      a = Ext.mime_match %w'text/*', [%w'some text txt']
+      assert_nil a
+    end
+  end
+end

data/spec/ext_parse_accept_value_spec.rb

@@ -0,0 +1,29 @@
+require_relative "spec_helper"
+
+module Nyara
+  describe Ext, ".parse_accept_value" do
+    it 'works' do
+      a = Ext.parse_accept_value ''
+      assert_equal [], a
+
+      a = Ext.parse_accept_value "text/plain; q=0.5, text/html,text/x-dvi; q=3.8, text/x-c"
+      assert_equal %w[text/html text/x-dvi text/x-c text/plain], a
+    end
+
+    it "ignores q <= 0" do
+      a = Ext.parse_accept_value "text/plain; q=0.0, text/html"
+      assert_equal(%w'text/html', a)
+
+      a = Ext.parse_accept_value "*, text/plain; q=-3"
+      assert_equal(%w'*', a)
+
+      a = Ext.parse_accept_value "text/plain; q=0, text/*"
+      assert_equal(%w'text/*', a)
+    end
+
+    it ".parse_accept_value should be robust" do
+      a = Ext.parse_accept_value 'q=0.1, text/html'
+      assert_equal 'text/html', a[1]
+    end
+  end
+end

data/spec/ext_parse_spec.rb

@@ -0,0 +1,138 @@
+require_relative "spec_helper"
+
+module Nyara
+  describe Ext, "parse" do
+    # note: this method is only used in C code
+    context "#parse_url_encoded_seg" do
+      [false, true].each do |nested|
+        context (nested ? 'nested mode' : 'flat mode') do
+          it "normal parse" do
+            assert_equal({'a' => 'b'}, parse('a=b', nested))
+          end
+
+          it "param seg end with '='" do
+            assert_equal({'a' => ''}, parse('a=', nested))
+          end
+
+          it "param seg begin with '='" do
+            assert_equal({'' => 'b'}, parse('=b', nested))
+          end
+
+          it "param seg without value" do
+            assert_equal({'a' => ''}, parse('a', nested))
+          end
+
+          it "raises error" do
+            assert_raise ArgumentError do
+              parse 'a=&b'
+            end
+          end
+        end
+      end
+
+      context "nested key" do
+        it "parses nested key" do
+          res = {"a"=>{"b"=>[[{"c"=>"1"}]]}}
+          assert_equal res, Ext.parse_url_encoded_seg({}, "a[b][][][c]=1", true)
+        end
+
+        it 'allows "[]" as input' do
+          res = {""=>[""]}
+          assert_equal res, Ext.parse_url_encoded_seg({}, "[]", true)
+        end
+
+        it 'ignores empty input' do
+          res = {}
+          assert_equal res, Ext.parse_url_encoded_seg({}, "", true)
+        end
+
+        it "content hash is ParamHash" do
+          h = ParamHash.new
+          assert_equal ParamHash, Ext.parse_url_encoded_seg(h, "a[b]=c", true)[:a].class
+        end
+      end
+
+      def parse str, nested
+        h = {}
+        Ext.parse_url_encoded_seg h, str, nested
+      end
+    end
+
+    context "#parse_path" do
+      before :each do
+        @output = ''
+      end
+
+      it "parses" do
+        i = '/%23+%24'
+        assert_equal i.bytesize, parse(i)
+        assert_equal "/\x23 \x24", @output
+      end
+
+      it "truncates ? after %" do
+        i = '/hello%f3%?world'
+        len = parse i
+        assert_equal '/hello%f3%?'.bytesize, len
+        assert_equal "/hello\xf3%", @output
+      end
+
+      it "truncates ? after begin" do
+        i = '?a'
+        len = parse i
+        assert_equal 1, len
+        assert_equal '', @output
+      end
+
+      it "truncates ? before end" do
+        i = 'a?'
+        len = parse i
+        assert_equal 2, len
+        assert_equal 'a', @output
+      end
+
+      it "truncates ? after unescaped char" do
+        i = 'a?a'
+        len = parse i
+        assert_equal 2, len
+        assert_equal 'a', @output
+      end
+
+      it "truncates ? after escaped char" do
+        i = '%40?'
+        len = parse i
+        assert_equal 4, len
+        assert_equal "\x40", @output
+      end
+
+      def parse input
+        Ext.parse_path @output, input
+      end
+    end
+
+    context ".parse_cookie" do
+      it "parses complex cookie" do
+        history = CGI.escape '历史'
+        cookie = "pgv_pvi; pgv_si= ; pgv_pvi=som; sid=1d6c75f0 ; PLHistory=<#{history}>;"
+        h = Ext.parse_cookie ParamHash.new, cookie
+        assert_equal '1d6c75f0', h['sid']
+        assert_equal '', h['pgv_si']
+        assert_equal '', h['pgv_pvi'] # left orverrides right
+        assert_equal '<历史>', h['PLHistory']
+      end
+
+      it "parses empty cookie" do
+        cookie = ''
+        h = Ext.parse_cookie ParamHash.new, cookie
+        assert_empty h
+      end
+    end
+
+    context ".parse_param" do
+      it "parses param with non-utf-8 chars" do
+        bad_s = CGI.escape "\xE2"
+        h = Ext.parse_param ParamHash.new, bad_s
+        assert_equal "", h["\xE2"]
+      end
+    end
+  end
+end