mack 0.8.2 → 0.8.3

data/lib/gems/rack-0.9.1/lib/rack/file.rb

@@ -0,0 +1,85 @@
+require 'time'
+require 'rack/mime'
+
+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)
+      @path_info = Utils.unescape(env["PATH_INFO"])
+      return forbidden  if @path_info.include? ".."
+
+      @path = F.join(@root, @path_info)
+
+      begin
+        if F.file?(@path) && F.readable?(@path)
+          serving
+        else
+          raise Errno::EPERM
+        end
+      rescue SystemCallError
+        not_found
+      end
+    end
+
+    def forbidden
+      body = "Forbidden\n"
+      [403, {"Content-Type" => "text/plain",
+             "Content-Length" => body.size.to_s},
+       [body]]
+    end
+
+    # NOTE:
+    #   We check via File::size? whether this file provides size info
+    #   via stat (e.g. /proc files often don't), otherwise we have to
+    #   figure it out by reading the whole file into memory. And while
+    #   we're at it we also use this as body then.
+
+    def serving
+      if size = F.size?(@path)
+        body = self
+      else
+        body = [F.read(@path)]
+        size = body.first.size
+      end
+
+      [200, {
+        "Last-Modified"  => F.mtime(@path).httpdate,
+        "Content-Type"   => Mime.mime_type(F.extname(@path), 'text/plain'),
+        "Content-Length" => size.to_s
+      }, body]
+    end
+
+    def not_found
+      body = "File not found: #{@path_info}\n"
+      [404, {"Content-Type" => "text/plain",
+         "Content-Length" => body.size.to_s},
+       [body]]
+    end
+
+    def each
+      F.open(@path, "rb") { |file|
+        while part = file.read(8192)
+          yield part
+        end
+      }
+    end
+  end
+end

data/lib/gems/{rack-0.4.0 → rack-0.9.1}/lib/rack/handler.rb

@@ -29,16 +29,20 @@ module Rack
     autoload :FastCGI, "rack/handler/fastcgi"
     autoload :Mongrel, "rack/handler/mongrel"
     autoload :EventedMongrel, "rack/handler/evented_mongrel"
+    autoload :SwiftipliedMongrel, "rack/handler/swiftiplied_mongrel"
     autoload :WEBrick, "rack/handler/webrick"
     autoload :LSWS, "rack/handler/lsws"
     autoload :SCGI, "rack/handler/scgi"
+    autoload :Thin, "rack/handler/thin"
 
     register 'cgi', 'Rack::Handler::CGI'
     register 'fastcgi', 'Rack::Handler::FastCGI'
     register 'mongrel', 'Rack::Handler::Mongrel'
     register 'emongrel', 'Rack::Handler::EventedMongrel'
+    register 'smongrel', 'Rack::Handler::SwiftipliedMongrel'
     register 'webrick', 'Rack::Handler::WEBrick'
     register 'lsws', 'Rack::Handler::LSWS'
     register 'scgi', 'Rack::Handler::SCGI'
+    register 'thin', 'Rack::Handler::Thin'
   end
 end

data/lib/gems/{rack-0.4.0 → rack-0.9.1}/lib/rack/handler/evented_mongrel.rb

@@ -2,7 +2,7 @@ require 'swiftcore/evented_mongrel'
 
 module Rack
   module Handler
-    class EventedMongrel < Mongrel
+    class EventedMongrel < Handler::Mongrel
     end
   end
 end

data/lib/gems/{rack-0.4.0 → rack-0.9.1}/lib/rack/handler/fastcgi.rb

@@ -51,6 +51,8 @@ module Rack
         env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
         env["REQUEST_PATH"] ||= "/"
         env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
+        env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
+        env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
 
         status, headers, body = app.call(env)
         begin

data/lib/gems/{rack-0.4.0 → rack-0.9.1}/lib/rack/handler/mongrel.rb

@@ -60,15 +60,19 @@ module Rack
 
         begin
           response.status = status.to_i
+          response.send_status(nil)
+
           headers.each { |k, vs|
             vs.each { |v|
               response.header[k] = v
             }
           }
+          response.send_header
+
           body.each { |part|
-            response.body << part
+            response.write part
+            response.socket.flush
           }
-          response.finished
         ensure
           body.close  if body.respond_to? :close
         end

data/lib/gems/rack-0.9.1/lib/rack/handler/swiftiplied_mongrel.rb

@@ -0,0 +1,8 @@
+require 'swiftcore/swiftiplied_mongrel'
+
+module Rack
+  module Handler
+    class SwiftipliedMongrel < Handler::Mongrel
+    end
+  end
+end

data/lib/gems/rack-0.9.1/lib/rack/handler/thin.rb

@@ -0,0 +1,15 @@
+require "thin"
+
+module Rack
+  module Handler
+    class Thin
+      def self.run(app, options={})
+        server = ::Thin::Server.new(options[:Host] || '0.0.0.0',
+                                    options[:Port] || 8080,
+                                    app)
+        yield server if block_given?
+        server.start
+      end
+    end
+  end
+end

data/lib/gems/{rack-0.4.0 → rack-0.9.1}/lib/rack/handler/webrick.rb

@@ -3,7 +3,7 @@ require 'stringio'
 
 module Rack
   module Handler
-    class WEBrick < WEBrick::HTTPServlet::AbstractServlet
+    class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
       def self.run(app, options={})
         server = ::WEBrick::HTTPServer.new(options)
         server.mount "/", Rack::Handler::WEBrick, app
@@ -41,9 +41,13 @@ module Rack
         begin
           res.status = status.to_i
           headers.each { |k, vs|
-            vs.each { |v|
-              res[k] = v
-            }
+            if k.downcase == "set-cookie"
+              res.cookies.concat vs.to_a
+            else
+              vs.each { |v|
+                res[k] = v
+              }
+            end
           }
           body.each { |part|
             res.body << part

data/lib/gems/rack-0.9.1/lib/rack/head.rb

@@ -0,0 +1,19 @@
+module Rack
+
+class Head
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    status, headers, body = @app.call(env)
+
+    if env["REQUEST_METHOD"] == "HEAD"
+      [status, headers, []]
+    else
+      [status, headers, body]
+    end
+  end
+end
+
+end

data/lib/gems/{rack-0.4.0 → rack-0.9.1}/lib/rack/lint.rb

@@ -29,8 +29,8 @@ module Rack
 
     ## A Rack application is an Ruby object (not a class) that
     ## responds to +call+.
-    def call(env=nil) 
-      dup._call(env) 
+    def call(env=nil)
+      dup._call(env)
     end
 
     def _call(env)
@@ -49,6 +49,7 @@ module Rack
       check_headers headers
       ## and the *body*.
       check_content_type status, headers
+      check_content_length status, headers, env
       [status, headers, self]
     end
 
@@ -162,11 +163,9 @@ module Rack
       ## * There must be a valid error stream in <tt>rack.errors</tt>.
       check_error env["rack.errors"]
 
-      ## * The <tt>REQUEST_METHOD</tt> must be one of +GET+, +POST+, +PUT+,
-      ##   +DELETE+, +HEAD+, +OPTIONS+, +TRACE+.
+      ## * The <tt>REQUEST_METHOD</tt> must be a valid token.
       assert("REQUEST_METHOD unknown: #{env["REQUEST_METHOD"]}") {
-        %w[GET POST PUT DELETE
-           HEAD OPTIONS TRACE].include?(env["REQUEST_METHOD"])
+        env["REQUEST_METHOD"] =~ /\A[0-9A-Za-z!\#$%&'*+.^_`|~-]+\z/
       }
 
       ## * The <tt>SCRIPT_NAME</tt>, if non-empty, must start with <tt>/</tt>
@@ -215,6 +214,14 @@ module Rack
         @input = input
       end
 
+      def size
+        @input.size
+      end
+
+      def rewind
+        @input.rewind
+      end
+
       ## * +gets+ must be called without arguments and return a string,
       ##   or +nil+ on EOF.
       def gets(*args)
@@ -350,18 +357,75 @@ module Rack
     def check_content_type(status, headers)
       headers.each { |key, value|
         ## There must be a <tt>Content-Type</tt>, except when the
-        ## +Status+ is 204 or 304, in which case there must be none
+        ## +Status+ is 1xx, 204 or 304, in which case there must be none
         ## given.
         if key.downcase == "content-type"
-          assert("Content-Type header found in #{status} response, not allowed"){
-            not [204, 304].include? status.to_i
+          assert("Content-Type header found in #{status} response, not allowed") {
+            not Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
           }
           return
         end
       }
       assert("No Content-Type header found") {
-        [204, 304].include? status.to_i
+        Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
+      }
+    end
+
+    ## === The Content-Length
+    def check_content_length(status, headers, env)
+      chunked_response = false
+      headers.each { |key, value|
+        if key.downcase == 'transfer-encoding'
+          chunked_response = value.downcase != 'identity'
+        end
+      }
+
+      headers.each { |key, value|
+        if key.downcase == 'content-length'
+          ## There must be a <tt>Content-Length</tt>, except when the
+          ## +Status+ is 1xx, 204 or 304, in which case there must be none
+          ## given.
+          assert("Content-Length header found in #{status} response, not allowed") {
+            not Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
+          }
+
+          assert('Content-Length header should not be used if body is chunked') {
+            not chunked_response
+          }
+
+          bytes = 0
+          string_body = true
+
+          @body.each { |part|
+            unless part.kind_of?(String)
+              string_body = false
+              break
+            end
+
+            bytes += (part.respond_to?(:bytesize) ? part.bytesize : part.size)
+          }
+
+          if env["REQUEST_METHOD"] == "HEAD"
+            assert("Response body was given for HEAD request, but should be empty") {
+              bytes == 0
+            }
+          else
+            if string_body
+              assert("Content-Length header was #{value}, but should be #{bytes}") {
+                value == bytes.to_s
+              }
+            end
+          end
+
+          return
+        end
       }
+
+      if [ String, Array ].include?(@body.class) && !chunked_response
+        assert('No Content-Length header found') {
+          Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
+        }
+      end
     end
 
     ## === The Body

data/lib/gems/{rack-0.4.0 → rack-0.9.1}/lib/rack/lobster.rb

@@ -22,11 +22,11 @@ module Rack
         href = "?flip"
       end
 
-      [200, {"Content-Type" => "text/html"},
-       ["<title>Lobstericious!</title>",
-        "<pre>", lobster, "</pre>",
-        "<a href='#{href}'>flip!</a>"]
-      ]
+      content = ["<title>Lobstericious!</title>",
+                 "<pre>", lobster, "</pre>",
+                 "<a href='#{href}'>flip!</a>"]
+      length = content.inject(0) { |a,e| a+e.size }.to_s
+      [200, {"Content-Type" => "text/html", "Content-Length" => length}, content]
     }
 
     def call(env)
@@ -43,14 +43,14 @@ module Rack
         href = "?flip=left"
       end
 
-      Response.new.finish do |res|
-        res.write "<title>Lobstericious!</title>"
-        res.write "<pre>"
-        res.write lobster
-        res.write "</pre>"
-        res.write "<p><a href='#{href}'>flip!</a></p>"
-        res.write "<p><a href='?flip=crash'>crash!</a></p>"
-      end
+      res = Response.new
+      res.write "<title>Lobstericious!</title>"
+      res.write "<pre>"
+      res.write lobster
+      res.write "</pre>"
+      res.write "<p><a href='#{href}'>flip!</a></p>"
+      res.write "<p><a href='?flip=crash'>crash!</a></p>"
+      res.finish
     end
 
   end

data/lib/gems/rack-0.9.1/lib/rack/methodoverride.rb

@@ -0,0 +1,27 @@
+module Rack
+  class MethodOverride
+    HTTP_METHODS = %w(GET HEAD PUT POST DELETE OPTIONS)
+
+    METHOD_OVERRIDE_PARAM_KEY = "_method".freeze
+    HTTP_METHOD_OVERRIDE_HEADER = "HTTP_X_HTTP_METHOD_OVERRIDE".freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env["REQUEST_METHOD"] == "POST"
+        req = Request.new(env)
+        method = req.POST[METHOD_OVERRIDE_PARAM_KEY] ||
+          env[HTTP_METHOD_OVERRIDE_HEADER]
+        method = method.to_s.upcase
+        if HTTP_METHODS.include?(method)
+          env["rack.methodoverride.original_method"] = env["REQUEST_METHOD"]
+          env["REQUEST_METHOD"] = method
+        end
+      end
+
+      @app.call(env)
+    end
+  end
+end

data/lib/gems/rack-0.9.1/lib/rack/mime.rb

@@ -0,0 +1,204 @@
+module Rack
+  module Mime
+    # Returns String with mime type if found, otherwise use +fallback+.
+    # +ext+ should be filename extension in the '.ext' format that
+    #       File.extname(file) returns.
+    # +fallback+ may be any object
+    #
+    # Also see the documentation for MIME_TYPES
+    #
+    # Usage:
+    #     Rack::Utils.mime_type('.foo')
+    #
+    # This is a shortcut for:
+    #     Rack::Utils::MIME_TYPES.fetch('.foo', 'application/octet-stream')
+
+    def mime_type(ext, fallback='application/octet-stream')
+      MIME_TYPES.fetch(ext, fallback)
+    end
+    module_function :mime_type
+
+    # List of most common mime-types, selected various sources
+    # according to their usefulness in a webserving scope for Ruby
+    # users.
+    #
+    # To amend this list with your local mime.types list you can use:
+    #
+    #     require 'webrick/httputils'
+    #     list = WEBrick::HTTPUtils.load_mime_types('/etc/mime.types')
+    #     Rack::Utils::MIME_TYPES.merge!(list)
+    #
+    # To add the list mongrel provides, use:
+    #
+    #     require 'mongrel/handlers'
+    #     Rack::Utils::MIME_TYPES.merge!(Mongrel::DirHandler::MIME_TYPES)
+
+    MIME_TYPES = {
+      ".3gp"     => "video/3gpp",
+      ".a"       => "application/octet-stream",
+      ".ai"      => "application/postscript",
+      ".aif"     => "audio/x-aiff",
+      ".aiff"    => "audio/x-aiff",
+      ".asc"     => "application/pgp-signature",
+      ".asf"     => "video/x-ms-asf",
+      ".asm"     => "text/x-asm",
+      ".asx"     => "video/x-ms-asf",
+      ".atom"    => "application/atom+xml",
+      ".au"      => "audio/basic",
+      ".avi"     => "video/x-msvideo",
+      ".bat"     => "application/x-msdownload",
+      ".bin"     => "application/octet-stream",
+      ".bmp"     => "image/bmp",
+      ".bz2"     => "application/x-bzip2",
+      ".c"       => "text/x-c",
+      ".cab"     => "application/vnd.ms-cab-compressed",
+      ".cc"      => "text/x-c",
+      ".chm"     => "application/vnd.ms-htmlhelp",
+      ".class"   => "application/octet-stream",
+      ".com"     => "application/x-msdownload",
+      ".conf"    => "text/plain",
+      ".cpp"     => "text/x-c",
+      ".crt"     => "application/x-x509-ca-cert",
+      ".css"     => "text/css",
+      ".csv"     => "text/csv",
+      ".cxx"     => "text/x-c",
+      ".deb"     => "application/x-debian-package",
+      ".der"     => "application/x-x509-ca-cert",
+      ".diff"    => "text/x-diff",
+      ".djv"     => "image/vnd.djvu",
+      ".djvu"    => "image/vnd.djvu",
+      ".dll"     => "application/x-msdownload",
+      ".dmg"     => "application/octet-stream",
+      ".doc"     => "application/msword",
+      ".dot"     => "application/msword",
+      ".dtd"     => "application/xml-dtd",
+      ".dvi"     => "application/x-dvi",
+      ".ear"     => "application/java-archive",
+      ".eml"     => "message/rfc822",
+      ".eps"     => "application/postscript",
+      ".exe"     => "application/x-msdownload",
+      ".f"       => "text/x-fortran",
+      ".f77"     => "text/x-fortran",
+      ".f90"     => "text/x-fortran",
+      ".flv"     => "video/x-flv",
+      ".for"     => "text/x-fortran",
+      ".gem"     => "application/octet-stream",
+      ".gemspec" => "text/x-script.ruby",
+      ".gif"     => "image/gif",
+      ".gz"      => "application/x-gzip",
+      ".h"       => "text/x-c",
+      ".hh"      => "text/x-c",
+      ".htm"     => "text/html",
+      ".html"    => "text/html",
+      ".ico"     => "image/vnd.microsoft.icon",
+      ".ics"     => "text/calendar",
+      ".ifb"     => "text/calendar",
+      ".iso"     => "application/octet-stream",
+      ".jar"     => "application/java-archive",
+      ".java"    => "text/x-java-source",
+      ".jnlp"    => "application/x-java-jnlp-file",
+      ".jpeg"    => "image/jpeg",
+      ".jpg"     => "image/jpeg",
+      ".js"      => "application/javascript",
+      ".json"    => "application/json",
+      ".log"     => "text/plain",
+      ".m3u"     => "audio/x-mpegurl",
+      ".m4v"     => "video/mp4",
+      ".man"     => "text/troff",
+      ".mathml"  => "application/mathml+xml",
+      ".mbox"    => "application/mbox",
+      ".mdoc"    => "text/troff",
+      ".me"      => "text/troff",
+      ".mid"     => "audio/midi",
+      ".midi"    => "audio/midi",
+      ".mime"    => "message/rfc822",
+      ".mml"     => "application/mathml+xml",
+      ".mng"     => "video/x-mng",
+      ".mov"     => "video/quicktime",
+      ".mp3"     => "audio/mpeg",
+      ".mp4"     => "video/mp4",
+      ".mp4v"    => "video/mp4",
+      ".mpeg"    => "video/mpeg",
+      ".mpg"     => "video/mpeg",
+      ".ms"      => "text/troff",
+      ".msi"     => "application/x-msdownload",
+      ".odp"     => "application/vnd.oasis.opendocument.presentation",
+      ".ods"     => "application/vnd.oasis.opendocument.spreadsheet",
+      ".odt"     => "application/vnd.oasis.opendocument.text",
+      ".ogg"     => "application/ogg",
+      ".p"       => "text/x-pascal",
+      ".pas"     => "text/x-pascal",
+      ".pbm"     => "image/x-portable-bitmap",
+      ".pdf"     => "application/pdf",
+      ".pem"     => "application/x-x509-ca-cert",
+      ".pgm"     => "image/x-portable-graymap",
+      ".pgp"     => "application/pgp-encrypted",
+      ".pkg"     => "application/octet-stream",
+      ".pl"      => "text/x-script.perl",
+      ".pm"      => "text/x-script.perl-module",
+      ".png"     => "image/png",
+      ".pnm"     => "image/x-portable-anymap",
+      ".ppm"     => "image/x-portable-pixmap",
+      ".pps"     => "application/vnd.ms-powerpoint",
+      ".ppt"     => "application/vnd.ms-powerpoint",
+      ".ps"      => "application/postscript",
+      ".psd"     => "image/vnd.adobe.photoshop",
+      ".py"      => "text/x-script.python",
+      ".qt"      => "video/quicktime",
+      ".ra"      => "audio/x-pn-realaudio",
+      ".rake"    => "text/x-script.ruby",
+      ".ram"     => "audio/x-pn-realaudio",
+      ".rar"     => "application/x-rar-compressed",
+      ".rb"      => "text/x-script.ruby",
+      ".rdf"     => "application/rdf+xml",
+      ".roff"    => "text/troff",
+      ".rpm"     => "application/x-redhat-package-manager",
+      ".rss"     => "application/rss+xml",
+      ".rtf"     => "application/rtf",
+      ".ru"      => "text/x-script.ruby",
+      ".s"       => "text/x-asm",
+      ".sgm"     => "text/sgml",
+      ".sgml"    => "text/sgml",
+      ".sh"      => "application/x-sh",
+      ".sig"     => "application/pgp-signature",
+      ".snd"     => "audio/basic",
+      ".so"      => "application/octet-stream",
+      ".svg"     => "image/svg+xml",
+      ".svgz"    => "image/svg+xml",
+      ".swf"     => "application/x-shockwave-flash",
+      ".t"       => "text/troff",
+      ".tar"     => "application/x-tar",
+      ".tbz"     => "application/x-bzip-compressed-tar",
+      ".tcl"     => "application/x-tcl",
+      ".tex"     => "application/x-tex",
+      ".texi"    => "application/x-texinfo",
+      ".texinfo" => "application/x-texinfo",
+      ".text"    => "text/plain",
+      ".tif"     => "image/tiff",
+      ".tiff"    => "image/tiff",
+      ".torrent" => "application/x-bittorrent",
+      ".tr"      => "text/troff",
+      ".txt"     => "text/plain",
+      ".vcf"     => "text/x-vcard",
+      ".vcs"     => "text/x-vcalendar",
+      ".vrml"    => "model/vrml",
+      ".war"     => "application/java-archive",
+      ".wav"     => "audio/x-wav",
+      ".wma"     => "audio/x-ms-wma",
+      ".wmv"     => "video/x-ms-wmv",
+      ".wmx"     => "video/x-ms-wmx",
+      ".wrl"     => "model/vrml",
+      ".wsdl"    => "application/wsdl+xml",
+      ".xbm"     => "image/x-xbitmap",
+      ".xhtml"   => "application/xhtml+xml",
+      ".xls"     => "application/vnd.ms-excel",
+      ".xml"     => "application/xml",
+      ".xpm"     => "image/x-xpixmap",
+      ".xsl"     => "application/xml",
+      ".xslt"    => "application/xslt+xml",
+      ".yaml"    => "text/yaml",
+      ".yml"     => "text/yaml",
+      ".zip"     => "application/zip",
+    }
+  end
+end