nyara 0.0.1.pre

data/lib/nyara/request.rb

@@ -0,0 +1,144 @@
+# coding: binary
+
+module Nyara
+  # request and handler
+  class Request
+    # c-ext: http_method, scope, path, matched_accept, header
+    #        status, response_content_type, response_header, response_header_extra_lines
+    # todo: body, move all underline methods into Ext
+
+    class << self
+      undef new
+    end
+
+    # method predicates
+    %w[get post put delete options patch].each do |m|
+      eval <<-RUBY
+        def #{m}?
+          http_method == "#{m.upcase}"
+        end
+      RUBY
+    end
+
+    # header delegates
+    %w[content_length content_type referrer user_agent].each do |m|
+      eval <<-RUBY
+        def #{m}
+          header["#{m.split('_').map(&:capitalize).join '-'}"]
+        end
+      RUBY
+    end
+
+    def scheme
+      @scheme ||= begin
+        h = header
+        if h['X-Forwarded-Ssl'] == 'on'
+          'https'
+        elsif s = h['X-Forwarded-Scheme']
+          s
+        elsif s = h['X-Forwarded-Proto']
+          s.split(',')[0]
+        else
+          'http'
+        end
+      end
+    end
+
+    def ssl?
+      scheme == 'https'
+    end
+
+    def domain
+      @domain ||= begin
+        r = header['Host']
+        if r
+          r.split(':', 2).first
+        else
+          ''
+        end
+      end
+    end
+
+    def port
+      @port ||= begin
+        r = header['Host']
+        if r
+          r = r.split(':', 2).last
+        end
+        r ? r.to_i : 80 # or server running port?
+      end
+    end
+
+    def host
+      header['Host']
+    end
+
+    def xhr?
+      header["Requested-With"] == "XMLHttpRequest"
+    end
+
+    def accept
+      @accept ||= Ext.parse_accept_value header['Accept']
+    end
+
+    def accept_language
+      @accept_language ||= Ext.parse_accept_value header['Accept-Language']
+    end
+
+    def accept_charset
+      @accept_charset ||= Ext.parse_accept_value header['Accept-Charset']
+    end
+
+    def accept_encoding
+      @accept_encoding ||= Ext.parse_accept_value header['Accept-Encoding']
+    end
+
+    FORM_METHODS = %w[
+      POST
+      PUT
+      DELETE
+      PATCH
+    ]
+
+    FORM_MEDIA_TYPES = %w[
+      application/x-www-form-urlencoded
+      multipart/form-data
+    ]
+
+    def form?
+      if type = header['Content-Type']
+        FORM_METHODS.include?(http_method) and
+        FORM_MEDIA_TYPES.include?(type)
+      else
+        post?
+      end
+    end
+
+    def param
+      @param ||= begin
+        query_param = Ext.request_param self
+        if form?
+          Ext.parse_param query_param, body
+        end
+        query_param
+      end
+    end
+
+    def cookie
+      @cookie ||= Cookie.decode header
+    end
+
+    def session
+      @session ||= Session.decode cookie
+    end
+
+    # todo serialize the changed cookie
+
+    # todo rename and move it into Ext
+    def not_found
+      puts "not found"
+      Ext.send_data self, "HTTP/1.1 404 Not Found\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"
+      Ext.close self
+    end
+  end
+end

data/lib/nyara/route.rb

@@ -0,0 +1,138 @@
+module Nyara
+  # provide route preprocessing utils
+  module Route; end
+  class << Route
+    # note that controller may be not defined yet
+    def register_controller scope, controller
+      unless scope.is_a?(String)
+        raise ArgumentError, "route prefix should be a string"
+      end
+      scope = scope.dup.freeze
+      (@controllers ||= {})[scope] = controller
+    end
+
+    def compile
+      global_path_templates = {} # "name#id" => path
+      @path_templates = {}       # klass => {any_id => path}
+
+      a = @controllers.map do |scope, c|
+        if c.is_a?(String)
+          c = name2const c
+        end
+        name = c.controller_name || const2name(c)
+        raise "#{c.inspect} is not a Nyara::Controller" unless Controller > c
+
+        if @path_templates[c]
+          raise "controller #{c.inspect} was already mapped"
+        end
+
+        route_entries = c.preprocess_actions
+        @path_templates[c] = {}
+        route_entries.each do |e|
+          id = e.id.to_s
+          path = File.join scope, e.path
+          global_path_templates[name + id] = path
+          @path_templates[c][id] = path
+        end
+
+        [scope, c, route_entries]
+      end
+
+      @path_templates.keys.each do |c|
+        @path_templates[c] = global_path_templates.merge @path_templates[c]
+      end
+
+      Ext.clear_route
+      process(a).each do |entry|
+        entry.validate
+        Ext.register_route entry
+      end
+    end
+
+    def path_template klass, id
+      @path_templates[klass][id]
+    end
+
+    def clear
+      # gc mark fail if wrong order?
+      Ext.clear_route
+      @controllers = {}
+      @path_templates = {}
+    end
+
+    # private
+
+    def const2name c
+      name = c.to_s.sub /Controller$/, ''
+      name.gsub!(/(?<!\b)[A-Z]/){|s| "_#{s.downcase}" }
+      name.gsub!(/[A-Z]/, &:downcase)
+      name
+    end
+
+    def name2const name
+      name = name.gsub /(?<=\b|_)[a-z]/, &:upcase
+      name.gsub! '_', ''
+      name << 'Controller'
+      Module.const_get name
+    end
+
+    def process preprocessed
+      entries = []
+      preprocessed.each do |(scope, controller, route_entries)|
+        route_entries.each do |e|
+          e = e.dup # in case there is controller used in more than 1 maps
+          path = scope.sub /\/?$/, e.path
+          if path.empty?
+            path = '/'
+          end
+          e.prefix, suffix = analyse_path path
+          e.suffix, e.conv = compile_re suffix
+          e.scope = scope
+          e.controller = controller
+          entries << e
+        end
+      end
+      entries.sort_by! &:prefix
+      entries.reverse!
+      entries
+    end
+
+    # returns [str_re, conv]
+    def compile_re suffix
+      return ['', []] unless suffix
+      conv = []
+      re_segs = suffix.split(/(?<=%[dfsux])|(?=%[dfsux])/).map do |s|
+        case s
+        when '%d'
+          conv << :to_i
+          '(-?[0-9]+)'
+        when '%f'
+          conv << :to_f
+          # just copied from scanf
+          '([-+]?(?:0[xX](?:\.\h+|\h+(?:\.\h*)?)[pP][-+]\d+|\d+(?![\d.])|\d*\.\d*(?:[eE][-+]?\d+)?))'
+        when '%u'
+          conv << :to_i
+          '([0-9]+)'
+        when '%x'
+          conv << :hex
+          '(\h+)'
+        when '%s'
+          conv << :to_s
+          '([^/]+)'
+        else
+          Regexp.quote s
+        end
+      end
+      ["^#{re_segs.join}$", conv]
+    end
+
+    # split the path into parts
+    def analyse_path path
+      raise 'path must contain no new line' if path.index "\n"
+      raise 'path must start with /' unless path.start_with? '/'
+      path = path.sub(/\/$/, '') if path != '/'
+
+      path.split(/(?=%[dfsux])/, 2)
+    end
+  end
+end

data/lib/nyara/route_entry.rb

@@ -0,0 +1,43 @@
+module Nyara
+  class RouteEntry
+    REQUIRED_ATTRS = [:http_method, :scope, :prefix, :suffix, :controller, :id, :conv]
+    attr_accessor *REQUIRED_ATTRS
+
+    # optional
+    attr_accessor :accept_exts, :accept_mimes
+
+    # tmp
+    attr_accessor :path, :blk
+
+    def initialize &p
+      instance_eval &p if p
+    end
+
+    def set_accept_exts a
+      @accept_exts = {}
+      @accept_mimes = []
+      if a
+        a.each do |e|
+          e = e.to_s.dup.freeze
+          @accept_exts[e] = true
+          if MIME_TYPES[e]
+            v1, v2 = MIME_TYPES[e].split('/')
+            raise "bad mime type: #{MIME_TYPES[e].inspect}" if v1.nil? or v2.nil?
+            @accept_mimes << [v1, v2, e]
+          end
+        end
+      end
+      @accept_mimes = nil if @accept_mimes.empty?
+      @accept_exts = nil if @accept_exts.empty?
+    end
+
+    def validate
+      REQUIRED_ATTRS.each do |attr|
+        unless instance_variable_get("@#{attr}")
+          raise ArgumentError, "missing #{attr}"
+        end
+      end
+      raise ArgumentError, "id must be symbol" unless id.is_a?(Symbol)
+    end
+  end
+end

data/lib/nyara/session.rb

@@ -0,0 +1,104 @@
+module Nyara
+  # cookie based
+  # usually it's no need to call cache or database data a "session"
+  module Session
+    extend self
+
+    CIPHER_BLOCK_SIZE = 256/8
+
+    # session is by default DSA + SHA2/SHA1 signed, sub config options are:
+    #
+    # - name       (session entry name in cookie, default is 'spare_me_plz')
+    # - key        (DSA private key string, in der or pem format, use random if not given)
+    # - cipher_key (if exist, use aes-256-cbc to cipher the "sig&json", the first 256bit is sliced for iv)
+    #              (it's no need to set cipher_key if using https)
+
+    # init from config
+    def init
+      c = Config['session'] || {}
+      @name = (c['name'] || 'spare_me_plz').to_s
+
+      if c['key']
+        @dsa = OpenSSL::PKey::DSA.new c['key']
+      else
+        @dsa = OpenSSL::PKey::DSA.generate 256
+      end
+
+      # DSA can sign on any digest since 1.0.0
+      @dss = OpenSSL::VERSION >= '1.0.0' ? OpenSSL::Digest::SHA256 : OpenSSL::Digest::DSS1
+
+      @cipher_key = pad_256_bit c['cipher_key']
+    end
+
+    attr_reader :name
+
+    def encode h, cookie
+      str = h.to_json
+      sig = @dsa.syssign @dss.digest str
+      str = "#{Base64.urlsafe_encode64 sig}&#{str}"
+      cookie[@name] = @cipher_key ? cipher(str) : str
+    end
+
+    def decode cookie
+      str = cookie[@name].to_s
+      return empty_hash if str.empty?
+
+      str = decipher(str) if @cipher_key
+      sig, str = str.split '&', 2
+      return empty_hash unless str
+
+      begin
+        sig = Base64.urlsafe_decode64 sig
+        verified = @dsa.sysverify @dss.digest(str), sig
+        if verified
+          h = JSON.parse str, create_additions: false, object_class: ParamHash
+        end
+      ensure
+        return empty_hash unless h
+      end
+
+      if h.is_a?(ParamHash)
+        h
+      else
+        empty_hash
+      end
+    end
+
+    # private
+
+    def cipher str
+      iv = rand(36**CIPHER_BLOCK_SIZE).to_s(36).ljust CIPHER_BLOCK_SIZE
+      c = new_cipher true, iv
+      Base64.urlsafe_encode64(iv.dup << c.update(str) << c.final)
+    end
+
+    def decipher str
+      str = Base64.urlsafe_decode64 str
+      iv = str.byteslice 0...CIPHER_BLOCK_SIZE
+      str = str.byteslice CIPHER_BLOCK_SIZE..-1
+      return '' if !str or str.empty?
+      c = new_cipher false, iv
+      c.update(str) << c.final rescue ''
+    end
+
+    def pad_256_bit s
+      s = s.to_s
+      return nil if s.empty?
+      len = CIPHER_BLOCK_SIZE
+      s[0...len].ljust len, '*'
+    end
+
+    def empty_hash
+      # todo invoke hook?
+      ParamHash.new
+    end
+
+    def new_cipher encrypt, iv
+      c = OpenSSL::Cipher.new 'aes-256-cbc'
+      encrypt ? c.encrypt : c.decrypt
+      c.key = @cipher_key
+      c.iv = iv
+      c
+    end
+  end
+end