hobix 0.4

data/lib/hobix/webapp/htmlform.rb

@@ -0,0 +1,107 @@
+module Hobix
+class WebApp
+  class QueryString
+    # decode self as application/x-www-form-urlencoded and returns
+    # HTMLFormQuery object.
+    def decode_as_application_x_www_form_urlencoded
+      # xxx: warning if invalid?
+      pairs = []
+      @escaped_query_string.scan(/([^&;=]*)=([^&;]*)/) {|key, val|
+        key.gsub!(/\+/, ' ')
+        key.gsub!(/%([0-9A-F][0-9A-F])/i) { [$1].pack("H*") }
+        val.gsub!(/\+/, ' ')
+        val.gsub!(/%([0-9A-F][0-9A-F])/i) { [$1].pack("H*") }
+        pairs << [key.freeze, val.freeze]
+      }
+      HTMLFormQuery.new(pairs)
+    end
+    # decode self as multipart/form-data and returns
+    # HTMLFormQuery object.
+    def decode_as_multipart_form_data( boundary )
+      # xxx: warning if invalid?
+      require 'tempfile'
+      pairs = []
+      boundary = "--" + boundary
+      eol = "\015\012"
+      str = @escaped_query_string.gsub( /(?:\r?\n|\A)#{ Regexp::quote( boundary ) }--#{ eol }.*/m, '' )
+      str.split( /(?:\r?\n|\A)#{ Regexp::quote( boundary ) }#{ eol }/m ).each do |part|
+          headers = {}
+          header, value = part.split( "#{eol}#{eol}", 2 )
+          next unless header and value
+          field_name, field_data = nil, {}
+          if header =~ /Content-Disposition: form-data;.*(?:\sname="([^"]+)")/m
+              field_name = $1
+          end
+          if header =~ /Content-Disposition: form-data;.*(?:\sfilename="([^"]+)")/m
+              body = Tempfile.new( "WebApp" )
+              body.binmode if defined? body.binmode
+              body.print value
+              body.rewind
+              field_data = {'filename' => $1, 'tempfile' => body}
+              field_data['type'] = $1 if header =~ /Content-Type: (.+?)(?:#{ eol }|\Z)/m
+          else
+              field_data = value.gsub( /#{ eol }\Z/, '' )
+          end
+          pairs << [field_name, field_data]
+      end
+      HTMLFormQuery.new(pairs)
+    end
+  end
+
+  # HTMLFormQuery represents a query submitted by HTML form. 
+  class HTMLFormQuery
+
+    def HTMLFormQuery.each_string_key_pair(arg, &block) # :nodoc:
+      if arg.respond_to? :to_ary
+        arg = arg.to_ary
+        if arg.length == 2 && arg.first.respond_to?(:to_str)
+          yield WebApp.make_frozen_string(arg.first), arg.last
+        else
+          arg.each {|elt|
+            HTMLFormQuery.each_string_key_pair(elt, &block)
+          }
+        end
+      elsif arg.respond_to? :to_pair
+        arg.each_pair {|key, val|
+          yield WebApp.make_frozen_string(key), val
+        }
+      else
+        raise ArgumentError, "non-pairs argument: #{arg.inspect}"
+      end
+    end
+
+    def initialize(*args)
+      @param = []
+      HTMLFormQuery.each_string_key_pair(args) {|key, val|
+        @param << [key, val]
+      }
+      @param.freeze
+    end
+
+    def each
+      @param.each {|key, val|
+        yield key.dup, val.dup
+      }
+    end
+
+    def [](key)
+      if pair = @param.assoc(key)
+        return pair.last.dup
+      end
+      return nil
+    end
+
+    def lookup_all(key)
+      result = []
+      @param.each {|k, val|
+        result << val if k == key
+      }
+      return result
+    end
+
+    def keys
+      @param.map {|key, val| key }.uniq
+    end
+  end
+end
+end

data/lib/hobix/webapp/message.rb

@@ -0,0 +1,177 @@
+module Hobix
+class WebApp
+  # :stopdoc:
+  class Header
+    def Header.capitalize_field_name(field_name)
+      field_name.gsub(/[A-Za-z]+/) {|s| s.capitalize }
+    end
+
+    def initialize
+      @fields = []
+    end
+
+    def freeze
+      @fields.freeze
+      super
+    end
+
+    def dup
+      result = Header.new
+      @fields.each {|_, k, v|
+        result.add(k, v)
+      }
+      result
+    end
+
+    def clear
+      @fields.clear
+    end
+
+    def remove(field_name)
+      k1 = field_name.downcase
+      @fields.reject! {|k2, _, _| k1 == k2 }
+      nil
+    end
+
+    def add(field_name, field_body)
+      field_name = WebApp.make_frozen_string(field_name)
+      field_body = WebApp.make_frozen_string(field_body)
+      @fields << [field_name.downcase.freeze, field_name, field_body]
+    end
+
+    def set(field_name, field_body)
+      field_name = WebApp.make_frozen_string(field_name)
+      remove(field_name)
+      add(field_name, field_body)
+    end
+
+    def has?(field_name)
+      @fields.assoc(field_name.downcase) != nil
+    end
+
+    def [](field_name)
+      k1 = field_name.downcase
+      @fields.each {|k2, field_name, field_body|
+        return field_body.dup if k1 == k2
+      }
+      nil
+    end
+
+    def lookup_all(field_name)
+      k1 = field_name.downcase
+      result = []
+      @fields.each {|k2, field_name, field_body|
+        result << field_body.dup if k1 == k2
+      }
+      result
+    end
+
+    def each
+      @fields.each {|_, field_name, field_body|
+        field_name = field_name.dup
+        field_body = field_body.dup
+        yield field_name, field_body
+      }
+    end
+  end
+
+  class Message
+    def initialize(header={}, body='')
+      @header_object = Header.new
+      case header
+      when Hash
+        header.each_pair {|k, v|
+          raise ArgumentError, "unexpected header field name: #{k.inspect}" unless k.respond_to? :to_str
+          raise ArgumentError, "unexpected header field body: #{v.inspect}" unless v.respond_to? :to_str
+          @header_object.add k.to_str, v.to_str
+        }
+      when Array
+        header.each {|k, v|
+          raise ArgumentError, "unexpected header field name: #{k.inspect}" unless k.respond_to? :to_str
+          raise ArgumentError, "unexpected header field body: #{v.inspect}" unless v.respond_to? :to_str
+          @header_object.add k.to_str, v.to_str
+        }
+      else
+        raise ArgumentError, "unexpected header argument: #{header.inspect}"
+      end
+      raise ArgumentError, "unexpected body: #{body.inspect}" unless body.respond_to? :to_str
+      @body_object = StringIO.new(body.to_str)
+    end
+    attr_reader :header_object, :body_object
+
+    def freeze
+      @header_object.freeze
+      @body_object.string.freeze
+      super
+    end
+
+    def output_header(out)
+      @header_object.each {|k, v|
+        out << "#{k}: #{v}\n"
+      }
+    end
+
+    def output_body(out)
+      out << @body_object.string
+    end
+
+    def output_message(out)
+      output_header(out)
+      out << "\n"
+      output_body(out)
+    end
+  end
+
+  class Request < Message
+    def initialize(request_line=nil, header={}, body='')
+      @request_line = request_line
+      super header, body
+    end
+    attr_reader :request_method,
+                :server_name, :server_port,
+                :script_name, :path_info,
+                :query_string,
+                :server_protocol,
+                :remote_addr, :content_type, :request_uri, :action_uri
+
+    def make_request_header_from_cgi_env(env)
+      env.each {|k, v|
+        next if /\AHTTP_/ !~ k
+        k = Header.capitalize_field_name($')
+        k.gsub!(/_/, '-')
+        @header_object.add k, v
+      }
+      @request_method = env['REQUEST_METHOD']
+      @server_name = ( env['SERVER_NAME'] || '' ).gsub( /\:\d+$/, '' )  # lighttpd affixes port!!
+      @server_port = env['SERVER_PORT'].to_i
+      @script_name = env['SCRIPT_NAME'] || ''
+      @path_info = env['PATH_INFO'] || ''
+      @query_string = QueryString.primitive_new_for_raw_query_string(env['QUERY_STRING'] || '')
+      @server_protocol = env['SERVER_PROTOCOL'] || ''
+      @remote_addr = env['REMOTE_ADDR'] || ''
+      @content_type = env['CONTENT_TYPE'] || ''
+
+      # non-standard:
+      @request_uri = env['REQUEST_URI'] # Apache
+
+      # hobix action uri
+      @action_uri = ( env['PATH_INFO'] || env['REQUEST_URI'] ).
+        gsub( /^(#{ Regexp::quote( File::dirname( @script_name ) ) })?\/*/, '' ).
+        gsub( /\?.+$/, '' )
+    end
+  end
+
+  class Response < Message
+    def initialize(status_line='200 OK', header={}, body='')
+      @status_line = status_line
+      super header, body
+    end
+    attr_accessor :status_line
+
+    def output_cgi_status_field(out)
+      out << "Status: #{self.status_line}\n"
+    end
+  end
+  # :startdoc:
+end
+end

data/lib/hobix/webapp/urigen.rb

@@ -0,0 +1,141 @@
+require 'uri'
+
+module Hobix
+class WebApp
+  # :stopdoc:
+  class URIGen
+    def initialize(scheme, server_name, server_port, script_name, path_info)
+      @scheme = scheme
+      @server_name = server_name
+      @server_port = server_port
+      @script_name = script_name
+      @path_info = path_info
+      uri = "#{scheme}://#{server_name}:#{server_port}"
+      uri << script_name.gsub(%r{[^/]+}) {|segment| pchar_escape(segment) }
+      uri << path_info.gsub(%r{[^/]+}) {|segment| pchar_escape(segment) }
+      @base_uri = URI.parse(uri)
+    end
+    attr_reader :base_uri
+
+    def make_relative_uri(hash)
+      script = nil
+      path_info = nil
+      query = nil
+      fragment = nil
+      hash.each_pair {|k,v|
+        case k
+        when :script then script = v
+        when :path_info then path_info = v
+        when :query then query = v
+        when :fragment then fragment = v
+        else
+          raise ArgumentError, "unexpected: #{k} => #{v}"
+        end
+      }
+
+      if !script
+        script = @script_name
+      elsif %r{\A/} !~ script
+        script = @script_name.sub(%r{[^/]*\z}) { script }
+        while script.sub!(%r{/[^/]*/\.\.(?=/|\z)}, '')
+        end
+        script.sub!(%r{\A/\.\.(?=/|\z)}, '')
+      end
+
+      path_info = '/' + path_info if %r{\A[^/]} =~ path_info
+
+      dst = "#{script}#{path_info}"
+      dst.sub!(%r{\A/}, '')
+      dst.sub!(%r{[^/]*\z}, '')
+      dst_basename = $&
+
+      src = "#{@script_name}#{@path_info}"
+      src.sub!(%r{\A/}, '')
+      src.sub!(%r{[^/]*\z}, '')
+
+      while src[%r{\A[^/]*/}] == dst[%r{\A[^/]*/}]
+        if $~
+          src.sub!(%r{\A[^/]*/}, '')
+          dst.sub!(%r{\A[^/]*/}, '')
+        else
+          break
+        end
+      end
+
+      rel_path = '../' * src.count('/')
+      rel_path << dst << dst_basename
+      rel_path = './' if rel_path.empty?
+
+      rel_path.gsub!(%r{[^/]+}) {|segment| pchar_escape(segment) }
+      if /\A[A-Za-z][A-Za-z0-9+\-.]*:/ =~ rel_path # It seems absolute URI.
+        rel_path.sub!(/:/, '%3A')
+      end
+
+      if query
+        case query
+        when QueryString
+          query = query.instance_eval { @escaped_query_string }
+        when Hash
+          query = query.map {|k, v|
+            case v
+            when String
+              "#{form_escape(k)}=#{form_escape(v)}"
+            when Array
+              v.map {|e|
+                unless String === e
+                  raise ArgumentError, "unexpected query value: #{e.inspect}"
+                end
+                "#{form_escape(k)}=#{form_escape(e)}"
+              }
+            else
+              raise ArgumentError, "unexpected query value: #{v.inspect}"
+            end
+          }.join(';')
+        else
+          raise ArgumentError, "unexpected query: #{query.inspect}"
+        end
+        unless query.empty?
+          query = '?' + uric_escape(query)
+        end
+      else
+        query = ''
+      end
+
+      if fragment
+        fragment = "#" + uric_escape(fragment)
+      else
+        fragment = ''
+      end
+
+      URI.parse(rel_path + query + fragment)
+    end
+
+    def make_absolute_uri(hash)
+      @base_uri + make_relative_uri(hash)
+    end
+
+    Alpha = 'a-zA-Z'
+    Digit = '0-9'
+    AlphaNum = Alpha + Digit
+    Mark = '\-_.!~*\'()'
+    Unreserved = AlphaNum + Mark
+    PChar = Unreserved + ':@&=+$,'
+    def pchar_escape(s)
+      s.gsub(/[^#{PChar}]/on) {|c| sprintf("%%%02X", c[0]) }
+    end
+
+    Reserved = ';/?:@&=+$,'
+    Uric = Reserved + Unreserved
+    def uric_escape(s)
+      s.gsub(/[^#{Uric}]/on) {|c| sprintf("%%%02X", c[0]) }
+    end
+
+    def form_escape(s)
+      s.gsub(/[#{Reserved}\x00-\x1f\x7f-\xff]/on) {|c|
+        sprintf("%%%02X", c[0])
+      }.gsub(/ /on) { '+' }
+    end
+  end
+  # :startdoc:
+end
+end

data/lib/hobix/webapp/webrick-servlet.rb

@@ -0,0 +1,90 @@
+# webapp/webrick-servlet.rb provides an adaptor for a webapp and WEBrick.
+#
+# webapp/webrick-servlet.rb registers a handler for .webrick extension
+# using WEBrick::HTTPServlet::FileHandler.add_handler.
+# So WEBrick based HTTP server which require webapp/webrick-servlet.rb
+# can run a web application using webapp which filename has .webrick
+# extension.
+#
+# Such HTTP server can be defined as follows.
+#
+#   require 'webapp/webrick-servlet'
+#   httpd = WEBrick::HTTPServer.new(:Port => 10080, :DocumentRoot => Dir.getwd)
+#   trap(:INT){ httpd.shutdown }
+#   httpd.start 
+#
+# Apart from that, webapp/webrick-servlet.rb provides 
+# WebApp::WEBrickServletHandler.load_servlet which load WEBrick servlet
+# using webapp.
+#
+# WebApp::WEBrickServletHandler.load_servlet can be used for constructing
+# a web site with a single web application as follows.
+#
+#   require 'webapp/webrick-servlet'
+#   servlet = ARGV.shift
+#   httpd = WEBrick::HTTPServer.new(:Port => 10080)
+#   trap(:INT){ httpd.shutdown }
+#   httpd.mount("/", WebApp::WEBrickServletHandler.load_servlet(servlet))
+#   httpd.start
+#
+# When above server accept a request to http://host:10080/foo/bar,
+# the servlet takes /foo/bar as a path_info.
+#
+# Note that the servlet loading mechanism may be used without webapp
+# because the mechanism itself is not webapp dependent.
+
+require 'webrick'
+
+module Hobix
+class WebApp
+  class WEBrickServletHandler
+    LoadedServlets = {}
+    def WEBrickServletHandler.get_instance(config, name)
+      unless LoadedServlets[name]
+        LoadedServlets[name] = load_servlet(name)
+      end
+      LoadedServlets[name]
+    end
+
+    # load a WEBrick servlet written using webapp.
+    # WEBrickServletHandler.load_servlet returns a WEBrick servlet
+    # generated by WEBrick::HTTPServlet::ProcHandler.
+    def WEBrickServletHandler.load_servlet(path)
+      begin
+        Thread.current[:webrick_load_servlet] = true
+        load path, true
+        unless Thread.current[:webrick_load_servlet].respond_to? :call
+          raise "WEBrick servlet is not registered: #{path}"
+        end
+        procedure = Thread.current[:webrick_load_servlet]
+        return WEBrick::HTTPServlet::ProcHandler.new(procedure)
+      ensure
+        Thread.current[:webrick_load_servlet] = nil
+      end
+    end
+  end
+end
+end
+WEBrick::HTTPServlet::FileHandler.add_handler('webrick',
+  Hobix::WebApp::WEBrickServletHandler)
+
+if $0 == __FILE__
+  # usage: [-p port] [docroot|servlet]
+  require 'optparse'
+  port = 10080
+  ARGV.options {|q|
+    q.def_option('--help', 'show this message') {puts q; exit(0)}
+    q.def_option('--port=portnum', 'specify server port (default: 10080)') {|num| port = num.to_i }
+    q.parse!
+  }
+  docroot = ARGV.shift || Dir.getwd
+  httpd = WEBrick::HTTPServer.new(:Port => port)
+  trap(:INT){ httpd.shutdown }
+  if File.directory? docroot
+    httpd.mount("/", WEBrick::HTTPServlet::FileHandler, docroot, WEBrick::Config::HTTP[:DocumentRootOptions])
+    httpd.start
+  else
+    httpd.mount("/", Hobix::WebApp::WEBrickServletHandler.load_servlet(docroot))
+    httpd.start
+  end
+end