sinatra 0.2.1 → 0.2.2

data/vendor/rack/lib/rack/auth/digest/request.rb

@@ -0,0 +1,40 @@
+require 'rack/auth/abstract/request'
+require 'rack/auth/digest/params'
+require 'rack/auth/digest/nonce'
+
+module Rack
+  module Auth
+    module Digest
+      class Request < Auth::AbstractRequest
+
+        def method
+          @env['REQUEST_METHOD']
+        end
+
+        def digest?
+          :digest == scheme
+        end
+
+        def correct_uri?
+          @env['PATH_INFO'] == uri
+        end
+
+        def nonce
+          @nonce ||= Nonce.parse(params['nonce'])
+        end
+
+        def params
+          @params ||= Params.parse(parts.last)
+        end
+
+        def method_missing(sym)
+          if params.has_key? key = sym.to_s
+            return params[key]
+          end
+          super
+        end
+
+      end
+    end
+  end
+end

data/vendor/rack/lib/rack/auth/openid.rb

@@ -0,0 +1,116 @@
+# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
+
+gem_require 'ruby-openid', '~> 1.0.0' if defined? Gem
+require 'rack/auth/abstract/handler'
+require 'openid'
+
+module Rack
+  module Auth
+    # Rack::Auth::OpenID provides a simple method for permitting openid
+    # based logins. It requires the ruby-openid lib from janrain to operate,
+    # as well as some method of session management of a Hash type.
+    #
+    # After a transaction, the response status object is stored in the
+    # environment at rack.auth.openid.status, which can be used in the
+    # followup block or in a wrapping application to accomplish
+    # additional data maniipulation.
+    #
+    # NOTE: Due to the amount of data that ruby-openid stores in the session,
+    # Rack::Session::Cookie may fault.
+    #
+    # A hash of data is stored in the session hash at the key of :openid.
+    # The fully canonicalized identity url is stored within at 'identity'.
+    # Extension data from 'openid.sreg.nickname' would be stored as
+    # { 'nickname' => value }.
+    #
+    # NOTE: To my knowledge there is no collision at this point from storage
+    # of this manner, if there is please let me know so I may adjust this app
+    # to cope.
+    # NOTE: This rack application is only compatible with the 1.x.x versions
+    # of the ruby-openid library. If rubygems is loaded at require time of
+    # this app, the specification will be made. If it is not then the 'openid'
+    # library will be required, and will fail if it is not compatible.
+    class OpenID < AbstractHandler
+      # Required for ruby-openid
+      OIDStore = ::OpenID::MemoryStore.new
+
+      # A Hash of options is taken as it's single initializing
+      # argument. String keys are taken to be openid protocol
+      # extension namespaces.
+      #
+      #   For example: 'sreg' => { 'required' => # 'nickname' }
+      #
+      # Other keys are taken as options for Rack::Auth::OpenID, normally Symbols.
+      # Only :return is required. :trust is highly recommended to be set.
+      #
+      # * :return defines the url to return to after the client authenticates
+      #   with the openid service provider. Should point to where this app is
+      #   mounted. (ex: 'http://mysite.com/openid')
+      # * :trust defines the url identifying the site they are actually logging
+      #   into. (ex: 'http://mysite.com/')
+      # * :session_key defines the key to the session hash in the env.
+      #   (by default it uses 'rack.session')
+      def initialize(options={})
+        raise ArgumentError, 'No return url provided.'  unless options[:return]
+        warn  'No trust url provided.'  unless options[:trust]
+        options[:trust] ||= options[:return]
+
+        @options  = {
+          :session_key => 'rack.session'
+        }.merge(options)
+      end
+
+      def call(env)
+        request = Rack::Request.new env
+        return no_session unless session = request.env[@options[:session_key]]
+        resp = if request.GET['openid.mode']
+                 finish session, request.GET, env
+               elsif request.GET['openid_url']
+                 check session, request.GET['openid_url'], env
+               else
+                 bad_request
+               end
+      end
+
+      def check(session, oid_url, env)
+        consumer = ::OpenID::Consumer.new session, OIDStore
+        oid = consumer.begin oid_url
+        return auth_fail unless oid.status == ::OpenID::SUCCESS
+        @options.each do |ns,s|
+          next unless ns.is_a? String
+          s.each {|k,v| oid.add_extension_arg(ns, k, v) }
+        end
+        r_url = @options.fetch :return do |k| request.url end
+        t_url = @options.fetch :trust
+        env['rack.auth.openid.status'] = oid
+        return 303, {'Location'=>oid.redirect_url( t_url, r_url )}, []
+      end
+
+      def finish(session, params, env)
+        consumer = ::OpenID::Consumer.new session, OIDStore
+        oid = consumer.complete params
+        return bad_login unless oid.status == ::OpenID::SUCCESS
+        session[:openid] = {'identity' => oid.identity_url}
+        @options.each do |ns,s|
+          next unless ns.is_a? String
+          oid.extension_response(ns).each{|k,v| session[k]=v }
+        end
+        env['rack.auth.openid.status'] = oid
+        return 303, {'Location'=>@options[:trust]}, []
+      end
+
+      def no_session
+        @options.
+          fetch :no_session, [500,{'Content-Type'=>'text/plain'},'No session available.']
+      end
+      def auth_fail
+        @options.
+          fetch :auth_fail, [500, {'Content-Type'=>'text/plain'},'Foreign server failure.']
+      end
+      def bad_login
+        @options.
+          fetch :bad_login, [401, {'Content-Type'=>'text/plain'},'Identification has failed.']
+      end
+    end
+  end
+end

data/vendor/rack/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/vendor/rack/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/vendor/rack/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/vendor/rack/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/vendor/rack/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