mack 0.8.2 → 0.8.3

data/lib/gems/logging-0.9.4/data/simple_logging.rb

@@ -1,13 +0,0 @@
-
-Logging.configure {
-
-  logger(:root) {
-    level      :info
-    appenders  'stdout'
-  }
-
-  appender('stdout') {
-    type 'Stdout'
-  }
-
-}  # logging configuration

data/lib/gems/rack-0.4.0/bin/rackup

@@ -1,172 +0,0 @@
-#!/usr/bin/env ruby
-# -*- ruby -*-
-
-require 'optparse'
-
-automatic = false
-server = nil
-env = "development"
-daemonize = false
-pid = nil
-options = {:Port => 9292, :Host => "0.0.0.0", :AccessLog => []}
-
-opts = OptionParser.new("", 24, '  ') { |opts|
-  opts.banner = "Usage: rackup [ruby options] [rack options] [rackup config]"
-
-  opts.separator ""
-  opts.separator "Ruby options:"
-
-  lineno = 1
-  opts.on("-e", "--eval LINE", "evaluate a LINE of code") { |line|
-    eval line, TOPLEVEL_BINDING, "-e", lineno
-    lineno += 1
-  }
-
-  opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") {
-    $DEBUG = true
-  }
-  opts.on("-w", "--warn", "turn warnings on for your script") {
-    $-w = true
-  }
-
-  opts.on("-I", "--include PATH",
-          "specify $LOAD_PATH (may be used more than once)") { |path|
-    $LOAD_PATH.unshift(*path.split(":"))
-  }
-
-  opts.on("-r", "--require LIBRARY",
-          "require the library, before executing your script") { |library|
-    require library
-  }
-
-  opts.separator ""
-  opts.separator "Rack options:"
-  opts.on("-s", "--server SERVER", "serve using SERVER (webrick/mongrel)") { |s|
-    server = s
-  }
-
-  opts.on("-o", "--host HOST", "listen on HOST (default: 0.0.0.0)") { |host|
-    options[:Host] = host
-  }
-
-  opts.on("-p", "--port PORT", "use PORT (default: 9292)") { |port|
-    options[:Port] = port
-  }
-
-  opts.on("-E", "--env ENVIRONMENT", "use ENVIRONMENT for defaults (default: development)") { |e|
-    env = e
-  }
-
-  opts.on("-D", "--daemonize", "run daemonized in the background") { |d|
-    daemonize = d ? true : false
-  }
-
-  opts.on("-P", "--pid FILE", "file to store PID (default: rack.pid)") { |f|
-    pid = File.expand_path(f)
-  }
-
-  opts.separator ""
-  opts.separator "Common options:"
-
-  opts.on_tail("-h", "--help", "Show this message") do
-    puts opts
-    exit
-  end
-
-  opts.on_tail("--version", "Show version") do
-    require 'rack'
-    puts "Rack #{Rack.version}"
-    exit
-  end
-
-  opts.parse! ARGV
-}
-
-require 'pp'  if $DEBUG
-
-config = ARGV[0] || "config.ru"
-if !File.exist? config
-  abort "configuration #{config} not found"
-end
-
-if config =~ /\.ru$/
-  cfgfile = File.read(config)
-  if cfgfile[/^#\\(.*)/]
-    opts.parse! $1.split(/\s+/)
-  end
-  require 'rack'
-  inner_app = eval "Rack::Builder.new {( " + cfgfile + "\n )}.to_app",
-                   nil, config
-else
-  require 'rack'
-  require config
-  inner_app = Object.const_get(File.basename(config, '.rb').capitalize)
-end
-
-unless server = Rack::Handler.get(server)
-  # Guess.
-  if ENV.include?("PHP_FCGI_CHILDREN")
-    server = Rack::Handler::FastCGI
-
-    # We already speak FastCGI
-    options.delete :File
-    options.delete :Port
-  elsif ENV.include?("REQUEST_METHOD")
-    server = Rack::Handler::CGI
-  else
-    begin
-      server = Rack::Handler::Mongrel
-    rescue LoadError => e
-      server = Rack::Handler::WEBrick
-    end
-  end
-end
-
-p server  if $DEBUG
-
-case env
-when "development"
-  app = Rack::Builder.new {
-    use Rack::CommonLogger, STDERR  unless server.name =~ /CGI/
-    use Rack::ShowExceptions
-    use Rack::Lint
-    run inner_app
-  }.to_app
-
-when "deployment"
-  app = Rack::Builder.new {
-    use Rack::CommonLogger, STDERR  unless server.name =~ /CGI/
-    run inner_app
-  }.to_app
-
-when "none"
-  app = inner_app
-
-end
-
-if $DEBUG
-  pp app
-  pp inner_app
-end
-
-if daemonize
-  if RUBY_VERSION < "1.9"
-    exit if fork
-    Process.setsid
-    exit if fork
-    Dir.chdir "/"
-    File.umask 0000
-    STDIN.reopen "/dev/null"
-    STDOUT.reopen "/dev/null", "a"
-    STDERR.reopen "/dev/null", "a"
-  else
-    Process.daemon
-  end
-
-  if pid
-    File.open(pid, 'w'){ |f| f.write("#{Process.pid}") }
-    at_exit { File.delete(pid) if File.exist?(pid) }
-  end
-end
-
-server.run app, options

data/lib/gems/rack-0.4.0/lib/rack/deflater.rb

@@ -1,63 +0,0 @@
-require "zlib"
-require "stringio"
-
-module Rack
-
-class Deflater
-  def initialize(app)
-    @app = app
-  end
-
-  def call(env)
-    status, headers, body = @app.call(env)
-
-    request = Request.new(env)
-
-    encoding = Utils.select_best_encoding(%w(gzip deflate identity), request.accept_encoding)
-
-    case encoding
-    when "gzip"
-      mtime = headers["Last-Modified"] || Time.now
-      [status, headers.merge("Content-Encoding" => "gzip"), self.class.gzip(body, mtime)]
-    when "deflate"
-      [status, headers.merge("Content-Encoding" => "deflate"), self.class.deflate(body)]
-    when "identity"
-      [status, headers, body]
-    when nil
-      message = "An acceptable encoding for the requested resource #{request.fullpath} could not be found."
-      [406, {"Content-Type" => "text/plain"}, message]
-    end
-  end
-
-  def self.gzip(body, mtime)
-    io = StringIO.new
-    gzip = Zlib::GzipWriter.new(io)
-    gzip.mtime = mtime
-
-    # TODO: Add streaming
-    body.each { |part| gzip << part }
-
-    gzip.close
-    return io.string
-  end
-
-  DEFLATE_ARGS = [
-    Zlib::DEFAULT_COMPRESSION,
-    # drop the zlib header which causes both Safari and IE to choke
-   -Zlib::MAX_WBITS,
-    Zlib::DEF_MEM_LEVEL,
-    Zlib::DEFAULT_STRATEGY
-  ]
-
-  # Loosely based on Mongrel's Deflate handler
-  def self.deflate(body)
-    deflater = Zlib::Deflate.new(*DEFLATE_ARGS)
-
-    # TODO: Add streaming
-    body.each { |part| deflater << part }
-
-    return deflater.finish
-  end
-end
-
-end

data/lib/gems/rack-0.4.0/lib/rack/directory.rb

@@ -1,158 +0,0 @@
-require 'time'
-
-module Rack
-  # Rack::Directory serves entries below the +root+ given, according to the
-  # path info of the Rack request. If a directory is found, the file's contents
-  # will be presented in an html based index. If a file is found, the env will
-  # be passed to the specified +app+.
-  #
-  # If +app+ is not specified, a Rack::File of the same +root+ will be used.
-
-  class Directory
-    DIR_FILE = "<tr><td class='name'><a href='%s'>%s</a></td><td class='size'>%s</td><td class='type'>%s</td><td class='mtime'>%s</td></tr>"
-    DIR_PAGE = <<-PAGE
-<html><head>
-  <title>%s</title>
-  <style type='text/css'>
-table { width:100%%; }
-.name { text-align:left; }
-.size, .mtime { text-align:right; }
-  </style>
-</head><body>
-<h1>%s</h1>
-<hr />
-<table>
-  <tr>
-    <th class='name'>Name</th>
-    <th class='size'>Size</th>
-    <th class='type'>Type</th>
-    <th class='mtime'>Last Modified</th>
-  </tr>
-%s
-</table>
-<hr />
-</body></html>
-    PAGE
-
-    attr_reader :files
-    attr_accessor :root, :path
-
-    def initialize(root, app=nil)
-      @root = root
-      @app = app
-      unless defined? @app
-        @app = Rack::File.new(@root)
-      end
-    end
-
-    def call(env)
-      dup._call(env)
-    end
-
-    F = ::File
-
-    def _call(env)
-      if env["PATH_INFO"].include? ".."
-        body = "Forbidden\n"
-        size = body.respond_to?(:bytesize) ? body.bytesize : body.size
-        return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]]
-      end
-
-      @path = F.join(@root, Utils.unescape(env['PATH_INFO']))
-
-      if F.exist?(@path) and F.readable?(@path)
-        if F.file?(@path)
-          return @app.call(env)
-        elsif F.directory?(@path)
-          @files = [['../','Parent Directory','','','']]
-          sName, pInfo = env.values_at('SCRIPT_NAME', 'PATH_INFO')
-          Dir.entries(@path).sort.each do |file|
-            next if file[0] == ?.
-            fl    = F.join(@path, file)
-            sz    = F.size(fl)
-            url   = F.join(sName, pInfo, file)
-            type  = F.directory?(fl) ? 'directory' :
-              MIME_TYPES.fetch(F.extname(file)[1..-1],'unknown')
-            size  = (type!='directory' ? (sz<10240 ? "#{sz}B" : "#{sz/1024}KB") : '-')
-            mtime = F.mtime(fl).httpdate
-            @files << [ url, file, size, type, mtime ]
-          end
-          return [ 200, {'Content-Type'=>'text/html'}, self ]
-        end
-      end
-
-      body = "Entity not found: #{env["PATH_INFO"]}\n"
-      size = body.respond_to?(:bytesize) ? body.bytesize : body.size
-      return [404, {"Content-Type" => "text/plain", "Content-Length" => size.to_s}, [body]]
-    end
-
-    def each
-      show_path = @path.sub(/^#{@root}/,'')
-      files = @files.map{|f| DIR_FILE % f }*"\n"
-      page  = DIR_PAGE % [ show_path, show_path , files ]
-      page.each_line{|l| yield l }
-    end
-
-    def each_entry
-      @files.each{|e| yield e }
-    end
-
-    # 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",
-    }
-  end
-end

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

@@ -1,116 +0,0 @@
-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? ".."
-        body = "Forbidden\n"
-        size = body.respond_to?(:bytesize) ? body.bytesize : body.size
-        return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]]
-      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).httpdate,
-           "Content-Type"   => MIME_TYPES[ext] || "text/plain",
-           "Content-Length" => F.size(@path).to_s
-         }, self]
-      else
-        body = "File not found: #{env["PATH_INFO"]}\n"
-        size = body.respond_to?(:bytesize) ? body.bytesize : body.size
-        [404, {"Content-Type" => "text/plain", "Content-Length" => size.to_s}, [body]]
-      end
-    end
-
-    def each
-      F.open(@path, "rb") { |file|
-        while part = file.read(8192)
-          yield part
-        end
-      }
-    end
-
-    # :stopdoc:
-    # From WEBrick with some additions.
-    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",
-      "mp3"   => "audio/mpeg",
-      "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