nyara 0.0.1.pre

data/lib/nyara/config_hash.rb

@@ -0,0 +1,51 @@
+module Nyara
+  class ConfigHash
+    alias _aref []
+    alias _aset []=
+
+    # so you can find with chained keys
+    def [] *keys
+      h = self
+      keys.each do |key|
+        if h.has_key?(key)
+          if h.is_a?(ConfigHash)
+            h = h._aref key
+          else
+            h = h[key]
+          end
+        else
+          return nil # todo default value?
+        end
+      end
+      h
+    end
+
+    # so you can write:
+    # config['a', 'very', 'deep', 'key'] = 'value
+    def []= *keys, last_key, value
+      h = self
+      keys.each do |key|
+        if h.has_key?(key)
+          if h.is_a?(ConfigHash)
+            h = h._aref key
+          else
+            h = h[key]
+          end
+        else
+          new_h = ConfigHash.new
+          if h.is_a?(ConfigHash)
+            h._aset key, new_h
+          else
+            h[key] = new_h
+          end
+          h = new_h
+        end
+      end
+      if h.is_a?(ConfigHash)
+        h._aset last_key, value
+      else
+        h[last_key] = value
+      end
+    end
+  end
+end

data/lib/nyara/controller.rb

@@ -0,0 +1,336 @@
+module Nyara
+  # Contain render methods
+  module Renderable
+  end
+
+  Controller = Struct.new :request
+  class Controller
+    module ClassMethods
+      # Connect HTTP +method+, +path+ with +blk+ action
+      def http method, path, &blk
+        @route_entries ||= []
+        @used_ids = {}
+
+        action = RouteEntry.new
+        action.http_method = HTTP_METHODS[method]
+        action.path = path
+        action.set_accept_exts @accept
+        action.id = @curr_id.to_sym if @curr_id
+        action.blk = blk
+        @route_entries << action
+
+        if @curr_id
+          raise ArgumentError, "action id #{@curr_id} already in use" if @used_ids[@curr_id]
+          @used_ids[@curr_id] = true
+          @curr_id = nil
+          @meta_exist = nil
+        end
+        @accept = nil
+      end
+
+      # Set meta data for next action
+      def meta tag=nil, opts=nil
+        if @meta_exist
+          raise 'contiguous meta data descriptors, should follow by an action'
+        end
+        if tag.nil? and opts.nil?
+          raise ArgumentError, 'expect tag or options'
+        end
+
+        if opts.nil? and tag.is_a?(Hash)
+          opts = tag
+          tag = nil
+        end
+
+        if tag
+          # todo scan class
+          id = tag[/\#\w++(\-\w++)*/]
+          @curr_id = id
+        end
+
+        if opts
+          # todo add opts: strong param, etag, cache-control
+          @accept = opts[:accept]
+        end
+
+        @meta_exist = true
+      end
+
+      # HTTP GET
+      def get path, &blk
+        http 'GET', path, &blk
+      end
+
+      # HTTP POST
+      def post path, &blk
+        http 'POST', path, &blk
+      end
+
+      # HTTP PUT
+      def put path, &blk
+        http 'PUT', path, &blk
+      end
+
+      # HTTP DELETE
+      def delete path, &blk
+        http 'DELETE', path, &blk
+      end
+
+      # HTTP PATCH
+      def patch path, &blk
+        http 'PATCH', path, &blk
+      end
+
+      # HTTP OPTIONS
+      # todo generate options response for a url
+      # see http://tools.ietf.org/html/rfc5789
+      def options path, &blk
+        http 'OPTIONS', path, &blk
+      end
+
+      # ---
+      # todo http method: trace ?
+      # +++
+
+      # Set default layout
+      def layout l
+        @default_layout = l
+      end
+      attr_reader :default_layout
+
+      # Set controller name, so you can use a shorter name to reference the controller in path helper
+      def set_name n
+        @controller_name = n
+      end
+      attr_reader :controller_name
+
+      # :nodoc:
+      def preprocess_actions
+        raise "#{self}: no action defined" unless @route_entries
+
+        curr_id = :'#0'
+        next_id = proc{
+          while @used_ids[curr_id]
+            curr_id = curr_id.succ
+          end
+          @used_ids[curr_id] = true
+          curr_id
+        }
+        next_id[]
+
+        @route_entries.each do |e|
+          e.id ||= next_id[]
+          define_method e.id, &e.blk
+        end
+        @route_entries
+      end
+    end
+
+    include Renderable
+
+    # :nodoc:
+    def self.inherited klass
+      # klass will also have this inherited method
+      # todo check class name
+      klass.extend ClassMethods
+      [:@route_entries, :@usred_ids, :@default_layout].each do |iv|
+        klass.instance_variable_set iv, klass.superclass.instance_variable_get(iv)
+      end
+    end
+
+    # Path helper
+    def path_for id, *args
+      if args.last.is_a?(Hash)
+        opts = args.pop
+      end
+
+      r = Route.path_template(self.class, id) % args
+
+      if opts
+        r << ".#{opts[:format]}" if opts[:format]
+        query = opts.map do |k, v|
+          next if k == :format
+          "#{CGI.escape k.to_s}=#{CGI.escape v}"
+        end
+        query.compact!
+        r << '?' << query.join('&') unless query.empty?
+      end
+      r
+    end
+
+    # Url helper
+    # NOTE: host can include port
+    def url_for id, *args, scheme: nil, host: Config['host'], **opts
+      scheme = scheme ? scheme.sub(/\:?$/, '://') : '//'
+      host ||= 'localhost'
+      path = path_for id, *args, opts
+      scheme << host << path
+    end
+
+    def matched_accept
+      request.matched_accept
+    end
+
+    def header
+      request.header
+    end
+    alias headers header
+
+    def set_header k, v
+      request.response_header[k] = v
+    end
+
+    def add_header_line h
+      raise 'can not modify sent header' if request.response_header.frozen?
+      h = h.sub /(?<![\r\n])\z/, "\r\n"
+      request.response_header_extra_lines << s
+    end
+
+    # todo args helper
+
+    def param
+      request.param
+    end
+    alias params param
+
+    def cookie
+      request.cookie
+    end
+    alias cookies cookie
+
+    def set_cookie k, v=nil, opts
+      # todo default domain ?
+      opts = Hash[opts.map{|k,v| [k.to_sym,v]}]
+      Cookie.output_set_cookie response.response_header_extra_lines, k, v, opts
+    end
+
+    def delete_cookie k
+      # todo domain ? path ?
+      set_cookie k, expires: Time.now, max_age: 0
+    end
+
+    def clear_cookie
+      cookie.each do |k, _|
+        delete_cookie k
+      end
+    end
+    alias clear_cookies clear_cookie
+
+    def session
+      request.session
+    end
+
+    # Set response status
+    def status n
+      raise ArgumentError, "unsupported status: #{n}" unless HTTP_STATUS_FIRST_LINES[n]
+      Ext.request_set_status request, n
+    end
+
+    # Set response Content-Type, if there's no +charset+ in +ty+, and +ty+ is not text, adds default charset
+    def content_type ty
+      mime_ty = MIME_TYPES[ty.to_s]
+      raise ArgumentError, "bad content type: #{ty.inspect}" unless mime_ty
+      request.response_content_type = mime_ty
+    end
+
+    # Send respones first line and header data, and freeze +header+ to forbid further changes
+    def send_header template_deduced_content_type=nil
+      r = request
+      header = r.response_header
+
+      Ext.send_data r, HTTP_STATUS_FIRST_LINES[r.status]
+
+      header.aset_content_type \
+        r.response_content_type ||
+        header.aref_content_type ||
+        (r.accept and MIME_TYPES[r.accept]) ||
+        template_deduced_content_type
+
+      header.reverse_merge! OK_RESP_HEADER
+
+      data = header.map do |k, v|
+        "#{k}: #{v}\r\n"
+      end
+      data.concat r.response_header_extra_lines
+      data << "\r\n"
+      Ext.send_data r, data.join
+
+      # forbid further modification
+      header.freeze
+    end
+
+    # Send raw data, that is, not wrapped in chunked encoding<br>
+    # NOTE: often you should call send_header before doing this.
+    def send_data data
+      Ext.send_data request, data.to_s
+    end
+
+    # Send a data chunk, it can send_header first if header is not sent.
+    # 
+    # :call-seq:
+    #
+    #   send_chunk 'hello world!'
+    def send_chunk data
+      send_header unless request.response_header.frozen?
+      Ext.send_chunk request, data.to_s
+    end
+    alias send_string send_chunk
+
+    # Send file
+    def send_file file
+      if behind_proxy? # todo
+        header['X-Sendfile'] = file # todo escape name?
+        # todo content type and disposition
+        header['Content-Type'] = determine_ct_by_file_name
+        send_header unless request.response_header.frozen?
+      else
+        data = File.binread file
+        header['Content-Type'] = determine_ct_by_file_name
+        send_header unless request.response_header.frozen?
+        send_data data
+      end
+      Fiber.yield :term_close # is it right? content type changed
+    end
+
+    # Resume action after +seconds+
+    def sleep seconds
+      Fiber.yield seconds.to_f # todo
+    end
+
+    # One shot render, and terminate the action.
+    #
+    # :call-seq:
+    #
+    #   # render a template, engine determined by extension
+    #   render 'user/index', locals: {}
+    #
+    #   # with template source, set content type to +text/html+ if not given
+    #   render erb: "<%= 1 + 1 %>"
+    #
+    # For steam rendering, see #stream
+    def render view_path=nil, layout: self.class.default_layout, locals: nil, **opts
+      view = View.new self, view_path, layout, locals, opts
+      unless request.response_header.frozen?
+        send_header view.deduced_content_type
+      end
+      view.render
+    end
+
+    # Stream rendering
+    #
+    # :call-seq:
+    #
+    #   view = stream erb: "<% 5.times do |i| %>i<% Fiber.yield %><% end %>"
+    #   view.resume # sends "0"
+    #   view.resume # sends "1"
+    #   view.resume # sends "2"
+    #   view.end    # sends "34" and closes connection
+    def stream view_path=nil, layout: self.class.default_layout, locals: nil, **opts
+      view = View.new self, view_path, layout, locals, opts
+      unless request.response_header.frozen?
+        send_header view.deduced_content_type
+      end
+      view.stream
+    end
+  end
+end

data/lib/nyara/cookie.rb

@@ -0,0 +1,31 @@
+module Nyara
+  # http://www.ietf.org/rfc/rfc6265.txt (don't look at rfc2109)
+  module Cookie
+    extend self
+
+    def decode header
+      res = ParamHash.new
+      if data = header['Cookie']
+        Ext.parse_cookie res, data
+      end
+      res
+    end
+
+    def add_set_cookie r, k, v, expires: nil, max_age: nil, domain: nil, path: nil, secure: nil, httponly: true
+      r << "Set-Cookie: "
+      if v.nil? or v == true
+        r << "#{CGI.escape k.to_s}; "
+      else
+        r << "#{CGI.escape k.to_s}=#{CGI.escape v.to_s}; "
+      end
+      r << "Expires=#{expires.to_time.gmtime.rfc2822}; " if expires
+      r << "Max-Age=#{max_age.to_i}; " if max_age
+      # todo lint rfc1123 §2.1, rfc1034 §3.5
+      r << "Domain=#{domain}; " if domain
+      r << "Path=#{path}; " if path
+      r << "Secure; " if secure
+      r << "HttpOnly; " if httponly
+      r << "\r\n"
+    end
+  end
+end

data/lib/nyara/cpu_counter.rb

@@ -0,0 +1,65 @@
+# https://gist.github.com/jimweirich/5813834
+require 'rbconfig'
+
+module Nyara
+  # Based on a script at:
+  #   http://stackoverflow.com/questions/891537/ruby-detect-number-of-cpus-installed
+  class CpuCounter
+    def self.count
+      new.count
+    end
+
+    def count
+      case RbConfig::CONFIG['host_os']
+      when /darwin9/
+        `hwprefs cpu_count`.to_i
+      when /darwin/
+        darwin_count
+      when /linux/
+        linux_count
+      when /freebsd/
+        freebsd_count
+      when /mswin|mingw/
+        win32_count
+      end
+    end
+
+    def darwin_count
+      if cmd = resolve_command('hwprefs')
+        `#{cmd} thread_count`.to_i
+      elsif cmd = resolve_command('sysctl')
+        `#{cmd} -n hw.ncpu`.to_i
+      end
+    end
+
+    def linux_count
+      open('/proc/cpuinfo') { |f| f.readlines }.grep(/processor/).size
+    end
+
+    def freebsd_count
+      if cmd = resolve_command('sysctl')
+        `#{cmd} -n hw.ncpu`.to_i
+      end
+    end
+
+    def win32_count
+      require 'win32ole'
+      wmi = WIN32OLE.connect("winmgmts://")
+      cpu = wmi.ExecQuery("select NumberOfCores from Win32_Processor") # TODO count hyper-threaded in this
+      cpu.to_enum.first.NumberOfCores
+    end
+
+    def resolve_command(command)
+      try_command("/sbin/", command) || try_command("/usr/sbin/", command) || in_path_command(command)
+    end
+
+    def in_path_command(command)
+      `which #{command}` != '' ? command : nil
+    end
+
+    def try_command(dir, command)
+      path = dir + command
+      File.exist?(path) ? path : nil
+    end
+  end
+end

data/lib/nyara/header_hash.rb

@@ -0,0 +1,18 @@
+module Nyara
+  class HeaderHash
+    alias has_key? key?
+
+    CONTENT_TYPE = 'Content-Type'.freeze
+
+    def aref_content_type
+      self._aref CONTENT_TYPE
+    end
+
+    def aset_content_type value
+      unless value.index 'charset'
+        value = "#{value}; charset=UTF-8"
+      end
+      self._aset CONTENT_TYPE, value
+    end
+  end
+end