hobix 0.6

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