colouringcode-passenger 0.1 → 0.2

data/vendor/rack-1.0.0-git/Rakefile

@@ -1,164 +0,0 @@
-# Rakefile for Rack.  -*-ruby-*-
-require 'rake/rdoctask'
-require 'rake/testtask'
-
-
-desc "Run all the tests"
-task :default => [:test]
-
-
-desc "Make an archive as .tar.gz"
-task :dist => [:chmod, :changelog, :rdoc, "SPEC", "rack.gemspec"] do
-  FileUtils.touch("RDOX")
-  sh "git archive --format=tar --prefix=#{release}/ HEAD^{tree} >#{release}.tar"
-  sh "pax -waf #{release}.tar -s ':^:#{release}/:' RDOX SPEC ChangeLog doc rack.gemspec"
-  sh "gzip -f -9 #{release}.tar"
-end
-
-desc "Make an official release"
-task :officialrelease do
-  puts "Official build for #{release}..."
-  sh "rm -rf stage"
-  sh "git clone --shared . stage"
-  sh "cd stage && rake officialrelease_really"
-  sh "mv stage/#{release}.tar.gz stage/#{release}.gem ."
-end
-
-task :officialrelease_really => [:fulltest, "RDOX", "SPEC", :dist, :gem] do
-  sh "sha1sum #{release}.tar.gz #{release}.gem"
-end
-
-
-def version
-  abort "You need to pass VERSION=... to build packages."  unless ENV["VERSION"]
-  ENV["VERSION"]
-end
-
-def release
-  "rack-#{version}"
-end
-
-def manifest
-  `git ls-files`.split("\n")
-end
-
-
-desc "Make binaries executable"
-task :chmod do
-  Dir["bin/*"].each { |binary| File.chmod(0775, binary) }
-  Dir["test/cgi/test*"].each { |binary| File.chmod(0775, binary) }
-end
-
-desc "Generate a ChangeLog"
-task :changelog do
-  File.open("ChangeLog", "w") { |out|
-    `git log -z`.split("\0").map { |chunk|
-      author = chunk[/Author: (.*)/, 1].strip
-      date = chunk[/Date: (.*)/, 1].strip
-      desc, detail = $'.strip.split("\n", 2)
-      detail ||= ""
-      detail = detail.gsub(/.*darcs-hash:.*/, '')
-      detail.rstrip!
-      out.puts "#{date}  #{author}"
-      out.puts "  * #{desc.strip}"
-      out.puts detail  unless detail.empty?
-      out.puts
-    }
-  }
-end
-
-
-desc "Generate RDox"
-task "RDOX" do
-  sh "specrb -Ilib:test -a --rdox >RDOX"
-end
-
-desc "Generate Rack Specification"
-task "SPEC" do
-  File.open("SPEC", "wb") { |file|
-    IO.foreach("lib/rack/lint.rb") { |line|
-      if line =~ /## (.*)/
-        file.puts $1
-      end
-    }
-  }
-end
-
-desc "Run all the fast tests"
-task :test do
-  sh "specrb -Ilib:test -w #{ENV['TEST'] || '-a'} #{ENV['TESTOPTS'] || '-t "^(?!Rack::Handler|Rack::Adapter|Rack::Session::Memcache|Rack::Auth::OpenID)"'}"
-end
-
-desc "Run all the tests"
-task :fulltest => [:chmod] do
-  sh "specrb -Ilib:test -w #{ENV['TEST'] || '-a'} #{ENV['TESTOPTS']}"
-end
-
-begin
-  require 'rubygems'
-rescue LoadError
-  # Too bad.
-else
-  task "rack.gemspec" do
-    spec = Gem::Specification.new do |s|
-      s.name            = "rack"
-      s.version         = version
-      s.platform        = Gem::Platform::RUBY
-      s.summary         = "a modular Ruby webserver interface"
-      
-      s.description = <<-EOF
-Rack provides minimal, modular and adaptable interface for developing
-web applications in Ruby.  By wrapping HTTP requests and responses in
-the simplest way possible, it unifies and distills the API for web
-servers, web frameworks, and software in between (the so-called
-middleware) into a single method call.
-
-Also see http://rack.rubyforge.org.
-    EOF
-
-      s.files           = manifest + %w(SPEC RDOX rack.gemspec)
-      s.bindir          = 'bin'
-      s.executables     << 'rackup'
-      s.require_path    = 'lib'
-      s.has_rdoc        = true
-      s.extra_rdoc_files = ['README', 'SPEC', 'RDOX', 'KNOWN-ISSUES']
-      s.test_files      = Dir['test/{test,spec}_*.rb']
-      
-      s.author          = 'Christian Neukirchen'
-      s.email           = 'chneukirchen@gmail.com'
-      s.homepage        = 'http://rack.rubyforge.org'
-      s.rubyforge_project = 'rack'
-      
-      s.add_development_dependency 'test-spec'
-      
-      s.add_development_dependency 'camping'
-      s.add_development_dependency 'fcgi'
-      s.add_development_dependency 'memcache-client'
-      s.add_development_dependency 'mongrel'
-      s.add_development_dependency 'ruby-openid', '~> 2.0.0'
-      s.add_development_dependency 'thin'
-    end
-
-    File.open("rack.gemspec", "w") { |f| f << spec.to_ruby }
-  end
-
-  task :gem => ["rack.gemspec", "SPEC"] do
-    FileUtils.touch("RDOX")
-    sh "gem build rack.gemspec"
-  end
-end
-
-desc "Generate RDoc documentation"
-task :rdoc do
-  sh(*%w{rdoc --line-numbers --main README 
-              --title 'Rack\ Documentation' --charset utf-8 -U -o doc} +
-              %w{README KNOWN-ISSUES SPEC RDOX} +
-              Dir["lib/**/*.rb"])
-end
-
-task :pushsite => [:rdoc] do
-  sh "cd site && git gc"
-  sh "rsync -avz doc/ chneukirchen@rack.rubyforge.org:/var/www/gforge-projects/rack/doc/"
-  sh "rsync -avz site/ chneukirchen@rack.rubyforge.org:/var/www/gforge-projects/rack/"
-  sh "cd site && git push"
-end

data/vendor/rack-1.0.0-git/lib/rack.rb

@@ -1,90 +0,0 @@
-# Copyright (C) 2007, 2008, 2009 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.
-
-path = File.expand_path(File.dirname(__FILE__))
-$:.unshift(path) unless $:.include?(path)
-
-
-# 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 = [1,0]
-
-  # 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
-    "1.0"
-  end
-
-  autoload :Builder, "rack/builder"
-  autoload :Cascade, "rack/cascade"
-  autoload :Chunked, "rack/chunked"
-  autoload :CommonLogger, "rack/commonlogger"
-  autoload :ConditionalGet, "rack/conditionalget"
-  autoload :ContentLength, "rack/content_length"
-  autoload :ContentType, "rack/content_type"
-  autoload :File, "rack/file"
-  autoload :Deflater, "rack/deflater"
-  autoload :Directory, "rack/directory"
-  autoload :ForwardRequest, "rack/recursive"
-  autoload :Handler, "rack/handler"
-  autoload :Head, "rack/head"
-  autoload :Lint, "rack/lint"
-  autoload :Lock, "rack/lock"
-  autoload :MethodOverride, "rack/methodoverride"
-  autoload :Mime, "rack/mime"
-  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/vendor/rack-1.0.0-git/lib/rack/adapter/camping.rb

@@ -1,22 +0,0 @@
-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.to_s]]
-      end
-    end
-  end
-end

data/vendor/rack-1.0.0-git/lib/rack/auth/abstract/handler.rb

@@ -1,37 +0,0 @@
-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, realm=nil, &authenticator)
-        @app, @realm, @authenticator = app, realm, authenticator
-      end
-
-
-      private
-
-      def unauthorized(www_authenticate = challenge)
-        return [ 401,
-          { 'Content-Type' => 'text/plain',
-            'Content-Length' => '0',
-            'WWW-Authenticate' => www_authenticate.to_s },
-          []
-        ]
-      end
-
-      def bad_request
-        return [ 400,
-          { 'Content-Type' => 'text/plain',
-            'Content-Length' => '0' },
-          []
-        ]
-      end
-
-    end
-  end
-end

data/vendor/rack-1.0.0-git/lib/rack/auth/abstract/request.rb

@@ -1,37 +0,0 @@
-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

data/vendor/rack-1.0.0-git/lib/rack/auth/basic.rb

@@ -1,58 +0,0 @@
-require 'rack/auth/abstract/handler'
-require 'rack/auth/abstract/request'
-
-module Rack
-  module Auth
-    # Rack::Auth::Basic implements HTTP Basic Authentication, as per RFC 2617.
-    #
-    # Initialize with the Rack application that you want protecting,
-    # and a block that checks if a username and password pair are valid.
-    #
-    # See also: <tt>example/protectedlobster.rb</tt>
-
-    class Basic < AbstractHandler
-
-      def call(env)
-        auth = Basic::Request.new(env)
-
-        return unauthorized unless auth.provided?
-
-        return bad_request unless auth.basic?
-
-        if valid?(auth)
-          env['REMOTE_USER'] = auth.username
-
-          return @app.call(env)
-        end
-
-        unauthorized
-      end
-
-
-      private
-
-      def challenge
-        'Basic realm="%s"' % realm
-      end
-
-      def valid?(auth)
-        @authenticator.call(*auth.credentials)
-      end
-
-      class Request < Auth::AbstractRequest
-        def basic?
-          :basic == scheme
-        end
-
-        def credentials
-          @credentials ||= params.unpack("m*").first.split(/:/, 2)
-        end
-
-        def username
-          credentials.first
-        end
-      end
-
-    end
-  end
-end

data/vendor/rack-1.0.0-git/lib/rack/auth/digest/md5.rb

@@ -1,124 +0,0 @@
-require 'rack/auth/abstract/handler'
-require 'rack/auth/digest/request'
-require 'rack/auth/digest/params'
-require 'rack/auth/digest/nonce'
-require 'digest/md5'
-
-module Rack
-  module Auth
-    module Digest
-      # Rack::Auth::Digest::MD5 implements the MD5 algorithm version of
-      # HTTP Digest Authentication, as per RFC 2617.
-      #
-      # Initialize with the [Rack] application that you want protecting,
-      # and a block that looks up a plaintext password for a given username.
-      #
-      # +opaque+ needs to be set to a constant base64/hexadecimal string.
-      #
-      class MD5 < AbstractHandler
-
-        attr_accessor :opaque
-
-        attr_writer :passwords_hashed
-
-        def initialize(*args)
-          super
-          @passwords_hashed = nil
-        end
-
-        def passwords_hashed?
-          !!@passwords_hashed
-        end
-
-        def call(env)
-          auth = Request.new(env)
-
-          unless auth.provided?
-            return unauthorized
-          end
-
-          if !auth.digest? || !auth.correct_uri? || !valid_qop?(auth)
-            return bad_request
-          end
-
-          if valid?(auth)
-            if auth.nonce.stale?
-              return unauthorized(challenge(:stale => true))
-            else
-              env['REMOTE_USER'] = auth.username
-
-              return @app.call(env)
-            end
-          end
-
-          unauthorized
-        end
-
-
-        private
-
-        QOP = 'auth'.freeze
-
-        def params(hash = {})
-          Params.new do |params|
-            params['realm'] = realm
-            params['nonce'] = Nonce.new.to_s
-            params['opaque'] = H(opaque)
-            params['qop'] = QOP
-
-            hash.each { |k, v| params[k] = v }
-          end
-        end
-
-        def challenge(hash = {})
-          "Digest #{params(hash)}"
-        end
-
-        def valid?(auth)
-          valid_opaque?(auth) && valid_nonce?(auth) && valid_digest?(auth)
-        end
-
-        def valid_qop?(auth)
-          QOP == auth.qop
-        end
-
-        def valid_opaque?(auth)
-          H(opaque) == auth.opaque
-        end
-
-        def valid_nonce?(auth)
-          auth.nonce.valid?
-        end
-
-        def valid_digest?(auth)
-          digest(auth, @authenticator.call(auth.username)) == auth.response
-        end
-
-        def md5(data)
-          ::Digest::MD5.hexdigest(data)
-        end
-
-        alias :H :md5
-
-        def KD(secret, data)
-          H([secret, data] * ':')
-        end
-
-        def A1(auth, password)
-          [ auth.username, auth.realm, password ] * ':'
-        end
-
-        def A2(auth)
-          [ auth.method, auth.uri ] * ':'
-        end
-
-        def digest(auth, password)
-          password_hash = passwords_hashed? ? password : H(A1(auth, password))
-
-          KD(password_hash, [ auth.nonce, auth.nc, auth.cnonce, QOP, H(A2(auth)) ] * ':')
-        end
-
-      end
-    end
-  end
-end