mack 0.8.1 → 0.8.2

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

@@ -0,0 +1,130 @@
+
+class Hash
+
+  # call-seq:
+  #    getopt( key, default = nil, :as => class )
+  #
+  # Returns the value associated with the _key_. If the has does not contain
+  # the _key_, then the _default_ value is returned.
+  #
+  # Optionally, the value can be converted into to an instance of the given
+  # _class_. The supported classes are:
+  #
+  #     Integer
+  #     Float
+  #     Array
+  #     String
+  #     Symbol
+  #
+  # If the value is +nil+, then no converstion will be performed.
+  #
+  def getopt( *args )
+    opts = args.last.instance_of?(Hash) ? args.pop : {}
+    key, default = args
+
+    val = if has_key?(key);                self[key]
+          elsif has_key?(key.to_s);        self[key.to_s]
+          elsif has_key?(key.to_s.intern); self[key.to_s.intern]
+          else default end
+
+    return if val.nil?
+    return val unless opts.has_key?(:as)
+
+    case opts[:as].name.intern
+    when :Integer; Integer(val)
+    when :Float;   Float(val)
+    when :Array;   Array(val)
+    when :String;  String(val)
+    when :Symbol;  String(val).intern
+    else val end
+  end
+end
+
+class String
+
+  # call-seq:
+  #    reduce( width, ellipses = '...' )    #=> string
+  #
+  # Reduce the size of the current string to the given _width_ by removing
+  # characters from the middle of the string and replacing them with
+  # _ellipses_. If the _width_ is greater than the length of the string, the
+  # string is returned unchanged. If the _width_ is less than the length of
+  # the _ellipses_, then the _ellipses_ are returned.
+  #
+  def reduce( width, ellipses = '...')
+    raise ArgumentError, "width cannot be negative: #{width}" if width < 0
+
+    return self if length <= width
+
+    remove = length - width + ellipses.length
+    return ellipses.dup if remove >= length
+
+    left_end = (length + 1 - remove) / 2
+    right_start = left_end + remove
+
+    left = self[0,left_end]
+    right = self[right_start,length-right_start]
+
+    left << ellipses << right
+  end
+end
+
+class Module
+
+  # call-seq:
+  #    logger_name    #=> string
+  #
+  # Returns a predictable logger name for the current module or class. If
+  # used within an anonymous class, the first non-anonymous class name will
+  # be used as the logger name. If used within a meta-class, the name of the
+  # actual class will be used as the logger name. If used within an
+  # anonymous module, the string 'anonymous' will be returned.
+  #
+  def logger_name
+    return name unless name.empty?
+
+    # check if this is a metaclass (or eigenclass)
+    if ancestors.include? Class
+      inspect =~ %r/#<Class:([^#>]+)>/
+      return $1
+    end
+
+    # see if we have a superclass
+    if respond_to? :superclass
+      return superclass.logger_name
+    end
+
+    # we are an anonymous module
+    ::Logging.log_internal(-2) {
+      'cannot return a predictable, unique name for anonymous modules'
+    }
+    return 'anonymous'
+  end
+end
+
+class ReentrantMutex < Mutex
+
+  def initialize
+    super
+    @locker = nil
+  end
+
+  alias :original_synchronize :synchronize
+
+  def synchronize
+    if @locker == Thread.current
+      yield
+    else
+      original_synchronize {
+        begin
+          @locker = Thread.current
+          yield
+        ensure
+          @locker = nil
+        end
+      }
+    end
+  end
+end  # class ReentrantMutex
+
+# EOF

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

@@ -0,0 +1,172 @@
+#!/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.rb

@@ -0,0 +1,81 @@
+# Copyright (C) 2007, 2008 Christian Neukirchen <purl.org/net/chneukirchen>
+#
+# Rack is freely distributable under the terms of an MIT-style license.
+# See COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+$: << File.expand_path(File.dirname(__FILE__))
+
+
+# The Rack main module, serving as a namespace for all core Rack
+# modules and classes.
+#
+# All modules meant for use in your application are <tt>autoload</tt>ed here,
+# so it should be enough just to <tt>require rack.rb</tt> in your code.
+
+module Rack
+  # The Rack protocol version number implemented.
+  VERSION = [0,1]
+
+  # Return the Rack protocol version as a dotted string.
+  def self.version
+    VERSION.join(".")
+  end
+
+  # Return the Rack release as a dotted string.
+  def self.release
+    "0.4"
+  end
+
+  autoload :Builder, "rack/builder"
+  autoload :Cascade, "rack/cascade"
+  autoload :CommonLogger, "rack/commonlogger"
+  autoload :File, "rack/file"
+  autoload :Deflater, "rack/deflater"
+  autoload :Directory, "rack/directory"
+  autoload :ForwardRequest, "rack/recursive"
+  autoload :Handler, "rack/handler"
+  autoload :Lint, "rack/lint"
+  autoload :Recursive, "rack/recursive"
+  autoload :Reloader, "rack/reloader"
+  autoload :ShowExceptions, "rack/showexceptions"
+  autoload :ShowStatus, "rack/showstatus"
+  autoload :Static, "rack/static"
+  autoload :URLMap, "rack/urlmap"
+  autoload :Utils, "rack/utils"
+
+  autoload :MockRequest, "rack/mock"
+  autoload :MockResponse, "rack/mock"
+
+  autoload :Request, "rack/request"
+  autoload :Response, "rack/response"
+
+  module Auth
+    autoload :Basic, "rack/auth/basic"
+    autoload :AbstractRequest, "rack/auth/abstract/request"
+    autoload :AbstractHandler, "rack/auth/abstract/handler"
+    autoload :OpenID, "rack/auth/openid"
+    module Digest
+      autoload :MD5, "rack/auth/digest/md5"
+      autoload :Nonce, "rack/auth/digest/nonce"
+      autoload :Params, "rack/auth/digest/params"
+      autoload :Request, "rack/auth/digest/request"
+    end
+  end
+
+  module Session
+    autoload :Cookie, "rack/session/cookie"
+    autoload :Pool, "rack/session/pool"
+    autoload :Memcache, "rack/session/memcache"
+  end
+
+  # *Adapters* connect Rack with third party web frameworks.
+  #
+  # Rack includes an adapter for Camping, see README for other
+  # frameworks supporting Rack in their code bases.
+  #
+  # Refer to the submodules for framework-specific calling details.
+
+  module Adapter
+    autoload :Camping, "rack/adapter/camping"
+  end
+end

data/lib/gems/rack-0.4.0/lib/rack/adapter/camping.rb

@@ -0,0 +1,22 @@
+module Rack
+  module Adapter
+    class Camping
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env["PATH_INFO"] ||= ""
+        env["SCRIPT_NAME"] ||= ""
+        controller = @app.run(env['rack.input'], env)
+        h = controller.headers
+        h.each_pair do |k,v|
+          if v.kind_of? URI
+            h[k] = v.to_s
+          end
+        end
+        [controller.status, controller.headers, controller.body]
+      end
+    end
+  end
+end

data/lib/gems/rack-0.4.0/lib/rack/auth/abstract/handler.rb

@@ -0,0 +1,28 @@
+module Rack
+  module Auth
+    # Rack::Auth::AbstractHandler implements common authentication functionality.
+    #
+    # +realm+ should be set for all handlers.
+
+    class AbstractHandler
+
+      attr_accessor :realm
+
+      def initialize(app, &authenticator)
+        @app, @authenticator = app, authenticator
+      end
+
+
+      private
+
+      def unauthorized(www_authenticate = challenge)
+        return [ 401, { 'WWW-Authenticate' => www_authenticate.to_s }, [] ]
+      end
+
+      def bad_request
+        [ 400, {}, [] ]
+      end
+
+    end
+  end
+end

data/lib/gems/rack-0.4.0/lib/rack/auth/abstract/request.rb

@@ -0,0 +1,37 @@
+module Rack
+  module Auth
+    class AbstractRequest
+
+      def initialize(env)
+        @env = env
+      end
+
+      def provided?
+        !authorization_key.nil?
+      end
+
+      def parts
+        @parts ||= @env[authorization_key].split(' ', 2)
+      end
+
+      def scheme
+        @scheme ||= parts.first.downcase.to_sym
+      end
+
+      def params
+        @params ||= parts.last
+      end
+
+
+      private
+
+      AUTHORIZATION_KEYS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION']
+
+      def authorization_key
+        @authorization_key ||= AUTHORIZATION_KEYS.detect { |key| @env.has_key?(key) }
+      end
+
+    end
+
+  end
+end