search_biomodel 1.0.0 → 1.0.1

data/search_biomodel/ruby/1.8/gems/rack-1.3.0/lib/rack/auth/digest/md5.rb

@@ -1,129 +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(app, realm=nil, opaque=nil, &authenticator)
-          @passwords_hashed = nil
-          if opaque.nil? and realm.respond_to? :values_at
-            realm, opaque, @passwords_hashed = realm.values_at :realm, :opaque, :passwords_hashed 
-          end
-          super(app, realm, &authenticator)
-          @opaque = opaque
-        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)
-          pw = @authenticator.call(auth.username)
-          pw && digest(auth, pw) == 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

data/search_biomodel/ruby/1.8/gems/rack-1.3.0/lib/rack/auth/digest/nonce.rb

@@ -1,51 +0,0 @@
-require 'digest/md5'
-
-module Rack
-  module Auth
-    module Digest
-      # Rack::Auth::Digest::Nonce is the default nonce generator for the
-      # Rack::Auth::Digest::MD5 authentication handler.
-      #
-      # +private_key+ needs to set to a constant string.
-      #
-      # +time_limit+ can be optionally set to an integer (number of seconds),
-      # to limit the validity of the generated nonces.
-
-      class Nonce
-
-        class << self
-          attr_accessor :private_key, :time_limit
-        end
-
-        def self.parse(string)
-          new(*string.unpack("m*").first.split(' ', 2))
-        end
-
-        def initialize(timestamp = Time.now, given_digest = nil)
-          @timestamp, @given_digest = timestamp.to_i, given_digest
-        end
-
-        def to_s
-          [([ @timestamp, digest ] * ' ')].pack("m*").strip
-        end
-
-        def digest
-          ::Digest::MD5.hexdigest([ @timestamp, self.class.private_key ] * ':')
-        end
-
-        def valid?
-          digest == @given_digest
-        end
-
-        def stale?
-          !self.class.time_limit.nil? && (@timestamp - Time.now.to_i) < self.class.time_limit
-        end
-
-        def fresh?
-          !stale?
-        end
-
-      end
-    end
-  end
-end

data/search_biomodel/ruby/1.8/gems/rack-1.3.0/lib/rack/auth/digest/params.rb

@@ -1,53 +0,0 @@
-module Rack
-  module Auth
-    module Digest
-      class Params < Hash
-
-        def self.parse(str)
-          Params[*split_header_value(str).map do |param|
-            k, v = param.split('=', 2)
-            [k, dequote(v)]
-          end.flatten]
-        end
-
-        def self.dequote(str) # From WEBrick::HTTPUtils
-          ret = (/\A"(.*)"\Z/ =~ str) ? $1 : str.dup
-          ret.gsub!(/\\(.)/, "\\1")
-          ret
-        end
-
-        def self.split_header_value(str)
-          str.scan( /(\w+\=(?:"[^\"]+"|[^,]+))/n ).collect{ |v| v[0] }
-        end
-
-        def initialize
-          super()
-
-          yield self if block_given?
-        end
-
-        def [](k)
-          super k.to_s
-        end
-
-        def []=(k, v)
-          super k.to_s, v.to_s
-        end
-
-        UNQUOTED = ['nc', 'stale']
-
-        def to_s
-          map do |k, v|
-            "#{k}=" + (UNQUOTED.include?(k) ? v.to_s : quote(v))
-          end.join(', ')
-        end
-
-        def quote(str) # From WEBrick::HTTPUtils
-          '"' << str.gsub(/[\\\"]/o, "\\\1") << '"'
-        end
-
-      end
-    end
-  end
-end
-

data/search_biomodel/ruby/1.8/gems/rack-1.3.0/lib/rack/auth/digest/request.rb

@@ -1,40 +0,0 @@
-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['rack.methodoverride.original_method'] || @env['REQUEST_METHOD']
-        end
-
-        def digest?
-          :digest == scheme
-        end
-
-        def correct_uri?
-          request.fullpath == 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/search_biomodel/ruby/1.8/gems/rack-1.3.0/lib/rack/backports/uri/common.rb

@@ -1,64 +0,0 @@
-# :stopdoc:
-
-# Stolen from ruby core's uri/common.rb, with modifications to support 1.8.x
-#
-# https://github.com/ruby/ruby/blob/trunk/lib/uri/common.rb
-#
-#
-
-module URI
-  TBLENCWWWCOMP_ = {} # :nodoc:
-  TBLDECWWWCOMP_ = {} # :nodoc:
-
-  # Encode given +str+ to URL-encoded form data.
-  #
-  # This method doesn't convert *, -, ., 0-9, A-Z, _, a-z, but does convert SP
-  # (ASCII space) to + and converts others to %XX.
-  #
-  # This is an implementation of
-  # http://www.w3.org/TR/html5/forms.html#url-encoded-form-data
-  #
-  # See URI.decode_www_form_component, URI.encode_www_form
-  def self.encode_www_form_component(str)
-    if TBLENCWWWCOMP_.empty?
-      tbl = {}
-      256.times do |i|
-        tbl[i.chr] = '%%%02X' % i
-      end
-      tbl[' '] = '+'
-      begin
-        TBLENCWWWCOMP_.replace(tbl)
-        TBLENCWWWCOMP_.freeze
-      rescue
-      end
-    end
-    str = str.to_s
-    str.gsub(/[^*\-.0-9A-Z_a-z]/) {|m| TBLENCWWWCOMP_[m]}
-  end
-
-  # Decode given +str+ of URL-encoded form data.
-  #
-  # This decods + to SP.
-  #
-  # See URI.encode_www_form_component, URI.decode_www_form
-  def self.decode_www_form_component(str, enc=nil)
-    if TBLDECWWWCOMP_.empty?
-      tbl = {}
-      256.times do |i|
-        h, l = i>>4, i&15
-        tbl['%%%X%X' % [h, l]] = i.chr
-        tbl['%%%x%X' % [h, l]] = i.chr
-        tbl['%%%X%x' % [h, l]] = i.chr
-        tbl['%%%x%x' % [h, l]] = i.chr
-      end
-      tbl['+'] = ' '
-      begin
-        TBLDECWWWCOMP_.replace(tbl)
-        TBLDECWWWCOMP_.freeze
-      rescue
-      end
-    end
-    raise ArgumentError, "invalid %-encoding (#{str})" unless /\A(?:%[0-9a-fA-F]{2}|[^%]+)*\z/ =~ str
-    str.gsub(/\+|%[0-9a-fA-F]{2}/) {|m| TBLDECWWWCOMP_[m]}
-  end
-end

data/search_biomodel/ruby/1.8/gems/rack-1.3.0/lib/rack/builder.rb

@@ -1,137 +0,0 @@
-module Rack
-  # Rack::Builder implements a small DSL to iteratively construct Rack
-  # applications.
-  #
-  # Example:
-  #
-  #  require 'rack/lobster'
-  #  app = Rack::Builder.new do
-  #    use Rack::CommonLogger
-  #    use Rack::ShowExceptions
-  #    map "/lobster" do
-  #      use Rack::Lint
-  #      run Rack::Lobster.new
-  #    end
-  #  end
-  #
-  #  run app
-  #
-  # Or
-  #
-  #  app = Rack::Builder.app do
-  #    use Rack::CommonLogger
-  #    lambda { |env| [200, {'Content-Type' => 'text/plain'}, 'OK'] }
-  #  end
-  #
-  #  run app
-  #
-  # +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 self.parse_file(config, opts = Server::Options.new)
-      options = {}
-      if config =~ /\.ru$/
-        cfgfile = ::File.read(config)
-        if cfgfile[/^#\\(.*)/] && opts
-          options = opts.parse! $1.split(/\s+/)
-        end
-        cfgfile.sub!(/^__END__\n.*/, '')
-        app = eval "Rack::Builder.new {\n" + cfgfile + "\n}.to_app",
-          TOPLEVEL_BINDING, config
-      else
-        require config
-        app = Object.const_get(::File.basename(config, '.rb').capitalize)
-      end
-      return app, options
-    end
-
-    def initialize(&block)
-      @ins = []
-      instance_eval(&block) if block_given?
-    end
-
-    def self.app(&block)
-      self.new(&block).to_app
-    end
-
-    # Specifies a middleware to use in a stack.
-    #
-    #   class Middleware
-    #     def initialize(app)
-    #       @app = app
-    #     end
-    #
-    #     def call(env)
-    #       env["rack.some_header"] = "setting an example"
-    #       @app.call(env)
-    #     end
-    #   end
-    #
-    #   use Middleware
-    #   run lambda { |env| [200, { "Content-Type => "text/plain" }, ["OK"]] }
-    #
-    # All requests through to this application will first be processed by the middleware class.
-    # The +call+ method in this example sets an additional environment key which then can be
-    # referenced in the application if required.
-    def use(middleware, *args, &block)
-      @ins << lambda { |app| middleware.new(app, *args, &block) }
-    end
-
-    # Takes an argument that is an object that responds to #call and returns a Rack response.
-    # The simplest form of this is a lambda object:
-    #
-    #   run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }
-    #
-    # However this could also be a class:
-    #
-    #   class Heartbeat
-    #     def self.call(env)
-    #      [200, { "Content-Type" => "text/plain" }, ["OK"]]
-    #    end
-    #   end
-    #
-    #   run Heartbeat
-    def run(app)
-      @ins << app #lambda { |nothing| app }
-    end
-
-    # Creates a route within the application.
-    #
-    #   Rack::Builder.app do
-    #     map '/' do
-    #       run Heartbeat
-    #     end
-    #   end
-    #
-    # The +use+ method can also be used here to specify middleware to run under a specific path:
-    #
-    #   Rack::Builder.app do
-    #     map '/' do
-    #       use Middleware
-    #       run Heartbeat
-    #     end
-    #   end
-    #
-    # This example includes a piece of middleware which will run before requests hit +Heartbeat+. 
-    #
-    def map(path, &block)
-      if @ins.last.kind_of? Hash
-        @ins.last[path] = self.class.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/search_biomodel/ruby/1.8/gems/rack-1.3.0/lib/rack/cascade.rb

@@ -1,41 +0,0 @@
-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
-    NotFound = [404, {}, []]
-
-    attr_reader :apps
-
-    def initialize(apps, catch=404)
-      @apps = []; @has_app = {}
-      apps.each { |app| add app }
-
-      @catch = {}
-      [*catch].each { |status| @catch[status] = true }
-    end
-
-    def call(env)
-      result = NotFound
-
-      @apps.each do |app|
-        result = app.call(env)
-        break unless @catch.include?(result[0].to_i)
-      end
-
-      result
-    end
-
-    def add app
-      @has_app[app] = true
-      @apps << app
-    end
-
-    def include? app
-      @has_app.include? app
-    end
-
-    alias_method :<<, :add
-  end
-end

data/search_biomodel/ruby/1.8/gems/rack-1.3.0/lib/rack/chunked.rb

@@ -1,56 +0,0 @@
-require 'rack/utils'
-
-module Rack
-
-  # Middleware that applies chunked transfer encoding to response bodies
-  # when the response does not include a Content-Length header.
-  class Chunked
-    include Rack::Utils
-
-    # A body wrapper that emits chunked responses
-    class Body
-      TERM = "\r\n"
-      TAIL = "0#{TERM}#{TERM}"
-
-      include Rack::Utils
-
-      def initialize(body)
-        @body = body
-      end
-
-      def each
-        term = TERM
-        @body.each do |chunk|
-          size = bytesize(chunk)
-          next if size == 0
-          yield [size.to_s(16), term, chunk, term].join
-        end
-        yield TAIL
-      end
-
-      def close
-        @body.close if @body.respond_to?(:close)
-      end
-    end
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      headers = HeaderHash.new(headers)
-
-      if env['HTTP_VERSION'] == 'HTTP/1.0' ||
-         STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
-         headers['Content-Length'] ||
-         headers['Transfer-Encoding']
-        [status, headers, body]
-      else
-        headers.delete('Content-Length')
-        headers['Transfer-Encoding'] = 'chunked'
-        [status, headers, Body.new(body)]
-      end
-    end
-  end
-end

data/search_biomodel/ruby/1.8/gems/rack-1.3.0/lib/rack/commonlogger.rb

@@ -1,49 +0,0 @@
-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
-    # 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} %
-    FORMAT = %{%s - %s [%s] "%s %s%s %s" %d %s %0.4f\n}
-
-    def initialize(app, logger=nil)
-      @app = app
-      @logger = logger
-    end
-
-    def call(env)
-      began_at = Time.now
-      status, header, body = @app.call(env)
-      header = Utils::HeaderHash.new(header)
-      log(env, status, header, began_at)
-      [status, header, body]
-    end
-
-    private
-
-    def log(env, status, header, began_at)
-      now = Time.now
-      length = extract_content_length(header)
-
-      logger = @logger || env['rack.errors']
-      logger.write FORMAT % [
-        env['HTTP_X_FORWARDED_FOR'] || 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,
-        now - began_at ]
-    end
-
-    def extract_content_length(headers)
-      value = headers['Content-Length'] or return '-'
-      value.to_s == '0' ? '-' : value
-    end
-  end
-end

data/search_biomodel/ruby/1.8/gems/rack-1.3.0/lib/rack/conditionalget.rb

@@ -1,66 +0,0 @@
-require 'rack/utils'
-
-module Rack
-
-  # Middleware that enables conditional GET using If-None-Match and
-  # If-Modified-Since. The application should set either or both of the
-  # Last-Modified or Etag response headers according to RFC 2616. When
-  # either of the conditions is met, the response body is set to be zero
-  # length and the response status is set to 304 Not Modified.
-  #
-  # Applications that defer response body generation until the body's each
-  # message is received will avoid response body generation completely when
-  # a conditional GET matches.
-  #
-  # Adapted from Michael Klishin's Merb implementation:
-  # http://github.com/wycats/merb-core/tree/master/lib/merb-core/rack/middleware/conditional_get.rb
-  class ConditionalGet
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      case env['REQUEST_METHOD']
-      when "GET", "HEAD"
-        status, headers, body = @app.call(env)
-        headers = Utils::HeaderHash.new(headers)
-        if status == 200 && fresh?(env, headers)
-          status = 304
-          headers.delete('Content-Type')
-          headers.delete('Content-Length')
-          body = []
-        end
-        [status, headers, body]
-      else
-        @app.call(env)
-      end
-    end
-
-  private
-
-    def fresh?(env, headers)
-      modified_since = env['HTTP_IF_MODIFIED_SINCE']
-      none_match     = env['HTTP_IF_NONE_MATCH']
-
-      return false unless modified_since || none_match
-
-      success = true
-      success &&= modified_since?(to_rfc2822(modified_since), headers) if modified_since
-      success &&= etag_matches?(none_match, headers) if none_match
-      success
-    end
-
-    def etag_matches?(none_match, headers)
-      etag = headers['ETag'] and etag == none_match
-    end
-
-    def modified_since?(modified_since, headers)
-      last_modified = to_rfc2822(headers['Last-Modified']) and
-        modified_since >= last_modified
-    end
-
-    def to_rfc2822(since)
-      Time.rfc2822(since) rescue nil
-    end
-  end
-end

data/search_biomodel/ruby/1.8/gems/rack-1.3.0/lib/rack/config.rb

@@ -1,15 +0,0 @@
-module Rack
-  # Rack::Config modifies the environment using the block given during
-  # initialization.
-  class Config
-    def initialize(app, &block)
-      @app = app
-      @block = block
-    end
-
-    def call(env)
-      @block.call(env)
-      @app.call(env)
-    end
-  end
-end