technomancy-rack 0.3.0

data/lib/rack/builder.rb

@@ -0,0 +1,56 @@
+module Rack
+  # Rack::Builder implements a small DSL to iteratively construct Rack
+  # applications.
+  #
+  # Example:
+  #
+  #  app = Rack::Builder.new {
+  #    use Rack::CommonLogger
+  #    use Rack::ShowExceptions
+  #    map "/lobster" do
+  #      use Rack::Lint
+  #      run Rack::Lobster.new
+  #    end
+  #  }
+  #
+  # +use+ adds a middleware to the stack, +run+ dispatches to an application.
+  # You can use +map+ to construct a Rack::URLMap in a convenient way.
+
+  class Builder
+    def initialize(&block)
+      @ins = []
+      instance_eval(&block)
+    end
+
+    def use(middleware, *args, &block)
+      @ins << if block_given?
+        lambda { |app| middleware.new(app, *args, &block) }
+      else
+        lambda { |app| middleware.new(app, *args) }
+      end
+    end
+
+    def run(app)
+      @ins << app #lambda { |nothing| app }
+    end
+
+    def map(path, &block)
+      if @ins.last.kind_of? Hash
+        @ins.last[path] = Rack::Builder.new(&block).to_app
+      else
+        @ins << {}
+        map(path, &block)
+      end
+    end
+
+    def to_app
+      @ins[-1] = Rack::URLMap.new(@ins.last)  if Hash === @ins.last
+      inner_app = @ins.last
+      @ins[0...-1].reverse.inject(inner_app) { |a, e| e.call(a) }
+    end
+
+    def call(env)
+      to_app.call(env)
+    end
+  end
+end

data/lib/rack/cascade.rb

@@ -0,0 +1,36 @@
+module Rack
+  # Rack::Cascade tries an request on several apps, and returns the
+  # first response that is not 404 (or in a list of configurable
+  # status codes).
+
+  class Cascade
+    attr_reader :apps
+
+    def initialize(apps, catch=404)
+      @apps = apps
+      @catch = [*catch]
+    end
+
+    def call(env)
+      status = headers = body = nil
+      raise ArgumentError, "empty cascade"  if @apps.empty?
+      @apps.each { |app|
+        begin
+          status, headers, body = app.call(env)
+          break  unless @catch.include?(status.to_i)
+        end
+      }
+      [status, headers, body]
+    end
+
+    def add app
+      @apps << app
+    end
+
+    def include? app
+      @apps.include? app
+    end
+
+    alias_method :<<, :add
+  end
+end

data/lib/rack/commonlogger.rb

@@ -0,0 +1,56 @@
+module Rack
+  # Rack::CommonLogger forwards every request to an +app+ given, and
+  # logs a line in the Apache common log format to the +logger+, or
+  # rack.errors by default.
+
+  class CommonLogger
+    def initialize(app, logger=nil)
+      @app = app
+      @logger = logger
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
+      @env = env
+      @logger ||= self
+      @time = Time.now
+      @status, @header, @body = @app.call(env)
+      [@status, @header, self]
+    end
+
+    # By default, log to rack.errors.
+    def <<(str)
+      @env["rack.errors"].write(str)
+      @env["rack.errors"].flush
+    end
+
+    def each
+      length = 0
+      @body.each { |part|
+        length += part.size
+        yield part
+      }
+
+      @now = Time.now
+
+      # Common Log Format: http://httpd.apache.org/docs/1.3/logs.html#common
+      # lilith.local - - [07/Aug/2006 23:58:02] "GET / HTTP/1.1" 500 -
+      #             %{%s - %s [%s] "%s %s%s %s" %d %s\n} %
+      @logger << %{%s - %s [%s] "%s %s%s %s" %d %s %0.4f\n} %
+        [@env["REMOTE_ADDR"] || "-",
+         @env["REMOTE_USER"] || "-",
+         @now.strftime("%d/%b/%Y %H:%M:%S"),
+         @env["REQUEST_METHOD"],
+         @env["PATH_INFO"],
+         @env["QUERY_STRING"].empty? ? "" : "?"+@env["QUERY_STRING"],
+         @env["HTTP_VERSION"],
+         @status.to_s[0..3],
+         (length.zero? ? "-" : length.to_s),
+         @now - @time
+        ]
+    end
+  end
+end

data/lib/rack/file.rb

@@ -0,0 +1,112 @@
+require 'time'
+
+module Rack
+  # Rack::File serves files below the +root+ given, according to the
+  # path info of the Rack request.
+  #
+  # Handlers can detect if bodies are a Rack::File, and use mechanisms
+  # like sendfile on the +path+.
+
+  class File
+    attr_accessor :root
+    attr_accessor :path
+
+    def initialize(root)
+      @root = root
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    F = ::File
+
+    def _call(env)
+      if env["PATH_INFO"].include? ".."
+        return [403, {"Content-Type" => "text/plain"}, ["Forbidden\n"]]
+      end
+
+      @path = F.join(@root, Utils.unescape(env["PATH_INFO"]))
+      ext = F.extname(@path)[1..-1]
+
+      if F.file?(@path) && F.readable?(@path)
+        [200, {
+           "Last-Modified"  => F.mtime(@path).rfc822,
+           "Content-Type"   => MIME_TYPES[ext] || "text/plain",
+           "Content-Length" => F.size(@path).to_s
+         }, self]
+      else
+        return [404, {"Content-Type" => "text/plain"},
+                ["File not found: #{env["PATH_INFO"]}\n"]]
+      end
+    end
+
+    def each
+      F.open(@path, "rb") { |file|
+        while part = file.read(8192)
+          yield part
+        end
+      }
+    end
+
+    # :stopdoc:
+    # From WEBrick.
+    MIME_TYPES = {
+      "ai"    => "application/postscript",
+      "asc"   => "text/plain",
+      "avi"   => "video/x-msvideo",
+      "bin"   => "application/octet-stream",
+      "bmp"   => "image/bmp",
+      "class" => "application/octet-stream",
+      "cer"   => "application/pkix-cert",
+      "crl"   => "application/pkix-crl",
+      "crt"   => "application/x-x509-ca-cert",
+     #"crl"   => "application/x-pkcs7-crl",
+      "css"   => "text/css",
+      "dms"   => "application/octet-stream",
+      "doc"   => "application/msword",
+      "dvi"   => "application/x-dvi",
+      "eps"   => "application/postscript",
+      "etx"   => "text/x-setext",
+      "exe"   => "application/octet-stream",
+      "gif"   => "image/gif",
+      "htm"   => "text/html",
+      "html"  => "text/html",
+      "jpe"   => "image/jpeg",
+      "jpeg"  => "image/jpeg",
+      "jpg"   => "image/jpeg",
+      "js"    => "text/javascript",
+      "lha"   => "application/octet-stream",
+      "lzh"   => "application/octet-stream",
+      "mov"   => "video/quicktime",
+      "mpe"   => "video/mpeg",
+      "mpeg"  => "video/mpeg",
+      "mpg"   => "video/mpeg",
+      "pbm"   => "image/x-portable-bitmap",
+      "pdf"   => "application/pdf",
+      "pgm"   => "image/x-portable-graymap",
+      "png"   => "image/png",
+      "pnm"   => "image/x-portable-anymap",
+      "ppm"   => "image/x-portable-pixmap",
+      "ppt"   => "application/vnd.ms-powerpoint",
+      "ps"    => "application/postscript",
+      "qt"    => "video/quicktime",
+      "ras"   => "image/x-cmu-raster",
+      "rb"    => "text/plain",
+      "rd"    => "text/plain",
+      "rtf"   => "application/rtf",
+      "sgm"   => "text/sgml",
+      "sgml"  => "text/sgml",
+      "tif"   => "image/tiff",
+      "tiff"  => "image/tiff",
+      "txt"   => "text/plain",
+      "xbm"   => "image/x-xbitmap",
+      "xls"   => "application/vnd.ms-excel",
+      "xml"   => "text/xml",
+      "xpm"   => "image/x-xpixmap",
+      "xwd"   => "image/x-xwindowdump",
+      "zip"   => "application/zip",
+    }
+    # :startdoc:
+  end
+end

data/lib/rack/handler/cgi.rb

@@ -0,0 +1,57 @@
+module Rack
+  module Handler
+    class CGI
+      def self.run(app, options=nil)
+        serve app
+      end
+
+      def self.serve(app)
+        env = ENV.to_hash
+        env.delete "HTTP_CONTENT_LENGTH"
+
+        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+
+        env.update({"rack.version" => [0,1],
+                     "rack.input" => STDIN,
+                     "rack.errors" => STDERR,
+
+                     "rack.multithread" => false,
+                     "rack.multiprocess" => true,
+                     "rack.run_once" => true,
+
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
+                   })
+
+        env["QUERY_STRING"] ||= ""
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["REQUEST_PATH"] ||= "/"
+
+        status, headers, body = app.call(env)
+        begin
+          send_headers status, headers
+          send_body body
+        ensure
+          body.close  if body.respond_to? :close
+        end
+      end
+
+      def self.send_headers(status, headers)
+        STDOUT.print "Status: #{status}\r\n"
+        headers.each { |k, vs|
+          vs.each { |v|
+            STDOUT.print "#{k}: #{v}\r\n"
+          }
+        }
+        STDOUT.print "\r\n"
+        STDOUT.flush
+      end
+
+      def self.send_body(body)
+        body.each { |part|
+          STDOUT.print part
+          STDOUT.flush
+        }
+      end
+    end
+  end
+end

data/lib/rack/handler/fastcgi.rb

@@ -0,0 +1,83 @@
+require 'fcgi'
+
+module Rack
+  module Handler
+    class FastCGI
+      def self.run(app, options={})
+        file = options[:File] and STDIN.reopen(UNIXServer.new(file))
+        port = options[:Port] and STDIN.reopen(TCPServer.new(port))
+        FCGI.each { |request|
+          serve request, app
+        }
+      end
+
+      module ProperStream       # :nodoc:
+        def each                # This is missing by default.
+          while line = gets
+            yield line
+          end
+        end
+
+        def read(*args)
+          if args.empty?
+            super || ""           # Empty string on EOF.
+          else
+            super
+          end
+        end
+      end
+
+      def self.serve(request, app)
+        env = request.env
+        env.delete "HTTP_CONTENT_LENGTH"
+
+        request.in.extend ProperStream
+
+        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+
+        env.update({"rack.version" => [0,1],
+                     "rack.input" => request.in,
+                     "rack.errors" => request.err,
+
+                     "rack.multithread" => false,
+                     "rack.multiprocess" => true,
+                     "rack.run_once" => false,
+
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
+                   })
+
+        env["QUERY_STRING"] ||= ""
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["REQUEST_PATH"] ||= "/"
+        env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
+
+        status, headers, body = app.call(env)
+        begin
+          send_headers request.out, status, headers
+          send_body request.out, body
+        ensure
+          body.close  if body.respond_to? :close
+          request.finish
+        end
+      end
+
+      def self.send_headers(out, status, headers)
+        out.print "Status: #{status}\r\n"
+        headers.each { |k, vs|
+          vs.each { |v|
+            out.print "#{k}: #{v}\r\n"
+          }
+        }
+        out.print "\r\n"
+        out.flush
+      end
+
+      def self.send_body(out, body)
+        body.each { |part|
+          out.print part
+          out.flush
+        }
+      end
+    end
+  end
+end

data/lib/rack/handler/lsws.rb

@@ -0,0 +1,52 @@
+require 'lsapi'
+#require 'cgi'
+module Rack
+  module Handler
+    class LSWS
+      def self.run(app, options=nil)
+        while LSAPI.accept != nil
+          serve app
+        end
+      end
+      def self.serve(app)
+        env = ENV.to_hash
+        env.delete "HTTP_CONTENT_LENGTH"
+        env["SCRIPT_NAME"] = "" if env["SCRIPT_NAME"] == "/"
+        env.update({"rack.version" => [0,1],
+                     "rack.input" => STDIN,
+                     "rack.errors" => STDERR,
+                     "rack.multithread" => false,
+                     "rack.multiprocess" => true,
+                     "rack.run_once" => false,
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
+                   })
+        env["QUERY_STRING"] ||= ""
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["REQUEST_PATH"] ||= "/"
+        status, headers, body = app.call(env)
+        begin
+          send_headers status, headers
+          send_body body
+        ensure
+          body.close if body.respond_to? :close
+        end
+      end
+      def self.send_headers(status, headers)
+        print "Status: #{status}\r\n"
+        headers.each { |k, vs|
+          vs.each { |v|
+            print "#{k}: #{v}\r\n"
+          }
+        }
+        print "\r\n"
+        STDOUT.flush
+      end
+      def self.send_body(body)
+        body.each { |part|
+          print part
+          STDOUT.flush
+        }
+      end
+    end
+  end
+end