RubyGems - challah - Versions diffs - 0.9.0 → 0.9.1.beta - Mend

challah 0.9.0 → 0.9.1.beta

Files changed (1764) hide show

data/vendor/bundle/gems/rack-1.4.1/lib/rack/server.rb DELETED Viewed

@@ -1,323 +0,0 @@
-require 'optparse'
-module Rack
-  class Server
-    class Options
-      def parse!(args)
-        options = {}
-        opt_parser = OptionParser.new("", 24, '  ') do |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)") {
-            options[:debug] = true
-          }
-          opts.on("-w", "--warn", "turn warnings on for your script") {
-            options[:warn] = true
-          }
-          opts.on("-I", "--include PATH",
-                  "specify $LOAD_PATH (may be used more than once)") { |path|
-            options[:include] = path.split(":")
-          }
-          opts.on("-r", "--require LIBRARY",
-                  "require the library, before executing your script") { |library|
-            options[:require] = library
-          }
-          opts.separator ""
-          opts.separator "Rack options:"
-          opts.on("-s", "--server SERVER", "serve using SERVER (webrick/mongrel)") { |s|
-            options[: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("-O", "--option NAME[=VALUE]", "pass VALUE to the server as option NAME. If no VALUE, sets it to true. Run '#{$0} -s SERVER -h' to get a list of options for SERVER") { |name|
-            name, value = name.split('=', 2)
-            value = true if value.nil?
-            options[name.to_sym] = value
-          }
-          opts.on("-E", "--env ENVIRONMENT", "use ENVIRONMENT for defaults (default: development)") { |e|
-            options[:environment] = e
-          }
-          opts.on("-D", "--daemonize", "run daemonized in the background") { |d|
-            options[:daemonize] = d ? true : false
-          }
-          opts.on("-P", "--pid FILE", "file to store PID (default: rack.pid)") { |f|
-            options[:pid] = ::File.expand_path(f)
-          }
-          opts.separator ""
-          opts.separator "Common options:"
-          opts.on_tail("-h", "-?", "--help", "Show this message") do
-            puts opts
-            puts handler_opts(options)
-            exit
-          end
-          opts.on_tail("--version", "Show version") do
-            puts "Rack #{Rack.version} (Release: #{Rack.release})"
-            exit
-          end
-        end
-        begin
-          opt_parser.parse! args
-        rescue OptionParser::InvalidOption => e
-          warn e.message
-          abort opt_parser.to_s
-        end
-        options[:config] = args.last if args.last
-        options
-      end
-      def handler_opts(options)
-        begin
-          info = []
-          server = Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
-          if server && server.respond_to?(:valid_options)
-            info << ""
-            info << "Server-specific options for #{server.name}:"
-            has_options = false
-            server.valid_options.each do |name, description|
-              next if name.to_s.match(/^(Host|Port)[^a-zA-Z]/) # ignore handler's host and port options, we do our own.
-              info << "  -O %-21s %s" % [name, description]
-              has_options = true
-            end
-            return "" if !has_options
-          end
-          info.join("\n")
-        rescue NameError
-          return "Warning: Could not find handler specified (#{options[:server] || 'default'}) to determine handler-specific options"
-        end
-      end
-    end
-    # Start a new rack server (like running rackup). This will parse ARGV and
-    # provide standard ARGV rackup options, defaulting to load 'config.ru'.
-    #
-    # Providing an options hash will prevent ARGV parsing and will not include
-    # any default options.
-    #
-    # This method can be used to very easily launch a CGI application, for
-    # example:
-    #
-    #  Rack::Server.start(
-    #    :app => lambda do |e|
-    #      [200, {'Content-Type' => 'text/html'}, ['hello world']]
-    #    end,
-    #    :server => 'cgi'
-    #  )
-    #
-    # Further options available here are documented on Rack::Server#initialize
-    def self.start(options = nil)
-      new(options).start
-    end
-    attr_writer :options
-    # Options may include:
-    # * :app
-    #     a rack application to run (overrides :config)
-    # * :config
-    #     a rackup configuration file path to load (.ru)
-    # * :environment
-    #     this selects the middleware that will be wrapped around
-    #     your application. Default options available are:
-    #       - development: CommonLogger, ShowExceptions, and Lint
-    #       - deployment: CommonLogger
-    #       - none: no extra middleware
-    #     note: when the server is a cgi server, CommonLogger is not included.
-    # * :server
-    #     choose a specific Rack::Handler, e.g. cgi, fcgi, webrick
-    # * :daemonize
-    #     if true, the server will daemonize itself (fork, detach, etc)
-    # * :pid
-    #     path to write a pid file after daemonize
-    # * :Host
-    #     the host address to bind to (used by supporting Rack::Handler)
-    # * :Port
-    #     the port to bind to (used by supporting Rack::Handler)
-    # * :AccessLog
-    #     webrick acess log options (or supporting Rack::Handler)
-    # * :debug
-    #     turn on debug output ($DEBUG = true)
-    # * :warn
-    #     turn on warnings ($-w = true)
-    # * :include
-    #     add given paths to $LOAD_PATH
-    # * :require
-    #     require the given libraries
-    def initialize(options = nil)
-      @options = options
-      @app = options[:app] if options && options[:app]
-    end
-    def options
-      @options ||= parse_options(ARGV)
-    end
-    def default_options
-      {
-        :environment => ENV['RACK_ENV'] || "development",
-        :pid         => nil,
-        :Port        => 9292,
-        :Host        => "0.0.0.0",
-        :AccessLog   => [],
-        :config      => "config.ru"
-      }
-    end
-    def app
-      @app ||= begin
-        if !::File.exist? options[:config]
-          abort "configuration #{options[:config]} not found"
-        end
-        app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
-        self.options.merge! options
-        app
-      end
-    end
-    def self.logging_middleware
-      lambda { |server|
-        server.server.name =~ /CGI/ ? nil : [Rack::CommonLogger, $stderr]
-      }
-    end
-    def self.middleware
-      @middleware ||= begin
-        m = Hash.new {|h,k| h[k] = []}
-        m["deployment"].concat [
-          [Rack::ContentLength],
-          [Rack::Chunked],
-          logging_middleware
-        ]
-        m["development"].concat m["deployment"] + [[Rack::ShowExceptions], [Rack::Lint]]
-        m
-      end
-    end
-    def middleware
-      self.class.middleware
-    end
-    def start &blk
-      if options[:warn]
-        $-w = true
-      end
-      if includes = options[:include]
-        $LOAD_PATH.unshift(*includes)
-      end
-      if library = options[:require]
-        require library
-      end
-      if options[:debug]
-        $DEBUG = true
-        require 'pp'
-        p options[:server]
-        pp wrapped_app
-        pp app
-      end
-      # Touch the wrapped app, so that the config.ru is loaded before
-      # daemonization (i.e. before chdir, etc).
-      wrapped_app
-      daemonize_app if options[:daemonize]
-      write_pid if options[:pid]
-      trap(:INT) do
-        if server.respond_to?(:shutdown)
-          server.shutdown
-        else
-          exit
-        end
-      end
-      server.run wrapped_app, options, &blk
-    end
-    def server
-      @_server ||= Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
-    end
-    private
-      def parse_options(args)
-        options = default_options
-        # Don't evaluate CGI ISINDEX parameters.
-        # http://hoohoo.ncsa.uiuc.edu/cgi/cl.html
-        args.clear if ENV.include?("REQUEST_METHOD")
-        options.merge! opt_parser.parse!(args)
-        options[:config] = ::File.expand_path(options[:config])
-        ENV["RACK_ENV"] = options[:environment]
-        options
-      end
-      def opt_parser
-        Options.new
-      end
-      def build_app(app)
-        middleware[options[:environment]].reverse_each do |middleware|
-          middleware = middleware.call(self) if middleware.respond_to?(:call)
-          next unless middleware
-          klass = middleware.shift
-          app = klass.new(app, *middleware)
-        end
-        app
-      end
-      def wrapped_app
-        @wrapped_app ||= build_app app
-      end
-      def daemonize_app
-        if RUBY_VERSION < "1.9"
-          exit if fork
-          Process.setsid
-          exit if fork
-          Dir.chdir "/"
-          STDIN.reopen "/dev/null"
-          STDOUT.reopen "/dev/null", "a"
-          STDERR.reopen "/dev/null", "a"
-        else
-          Process.daemon
-        end
-      end
-      def write_pid
-        ::File.open(options[:pid], 'w'){ |f| f.write("#{Process.pid}") }
-        at_exit { ::File.delete(options[:pid]) if ::File.exist?(options[:pid]) }
-      end
-  end
-end

data/vendor/bundle/gems/rack-1.4.1/lib/rack/session/abstract/id.rb DELETED Viewed

@@ -1,372 +0,0 @@
-# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
-# bugrep: Andreas Zehnder
-require 'time'
-require 'rack/request'
-require 'rack/response'
-begin
-  require 'securerandom'
-rescue LoadError
-  # We just won't get securerandom
-end
-module Rack
-  module Session
-    module Abstract
-      ENV_SESSION_KEY = 'rack.session'.freeze
-      ENV_SESSION_OPTIONS_KEY = 'rack.session.options'.freeze
-      # Thin wrapper around Hash that allows us to lazily load session id into session_options.
-      class OptionsHash < Hash #:nodoc:
-        def initialize(by, env, default_options)
-          @by = by
-          @env = env
-          @session_id_loaded = false
-          merge!(default_options)
-        end
-        def [](key)
-          load_session_id! if key == :id && session_id_not_loaded?
-          super
-        end
-      private
-        def session_id_not_loaded?
-          !(@session_id_loaded || key?(:id))
-        end
-        def load_session_id!
-          self[:id] = @by.send(:extract_session_id, @env)
-          @session_id_loaded = true
-        end
-      end
-      # SessionHash is responsible to lazily load the session from store.
-      class SessionHash < Hash
-        def initialize(by, env)
-          super()
-          @by = by
-          @env = env
-          @loaded = false
-        end
-        def [](key)
-          load_for_read!
-          super(key.to_s)
-        end
-        def has_key?(key)
-          load_for_read!
-          super(key.to_s)
-        end
-        alias :key? :has_key?
-        alias :include? :has_key?
-        def []=(key, value)
-          load_for_write!
-          super(key.to_s, value)
-        end
-        def clear
-          load_for_write!
-          super
-        end
-        def to_hash
-          load_for_read!
-          h = {}.replace(self)
-          h.delete_if { |k,v| v.nil? }
-          h
-        end
-        def update(hash)
-          load_for_write!
-          super(stringify_keys(hash))
-        end
-        def delete(key)
-          load_for_write!
-          super(key.to_s)
-        end
-        def inspect
-          if loaded?
-            super
-          else
-            "#<#{self.class}:0x#{self.object_id.to_s(16)} not yet loaded>"
-          end
-        end
-        def exists?
-          return @exists if instance_variable_defined?(:@exists)
-          @exists = @by.send(:session_exists?, @env)
-        end
-        def loaded?
-          @loaded
-        end
-        def empty?
-          load_for_read!
-          super
-        end
-      private
-        def load_for_read!
-          load! if !loaded? && exists?
-        end
-        def load_for_write!
-          load! unless loaded?
-        end
-        def load!
-          id, session = @by.send(:load_session, @env)
-          @env[ENV_SESSION_OPTIONS_KEY][:id] = id
-          replace(stringify_keys(session))
-          @loaded = true
-        end
-        def stringify_keys(other)
-          hash = {}
-          other.each do |key, value|
-            hash[key.to_s] = value
-          end
-          hash
-        end
-      end
-      # ID sets up a basic framework for implementing an id based sessioning
-      # service. Cookies sent to the client for maintaining sessions will only
-      # contain an id reference. Only #get_session and #set_session are
-      # required to be overwritten.
-      #
-      # All parameters are optional.
-      # * :key determines the name of the cookie, by default it is
-      #   'rack.session'
-      # * :path, :domain, :expire_after, :secure, and :httponly set the related
-      #   cookie options as by Rack::Response#add_cookie
-      # * :skip will not a set a cookie in the response nor update the session state
-      # * :defer will not set a cookie in the response but still update the session
-      #   state if it is used with a backend
-      # * :renew (implementation dependent) will prompt the generation of a new
-      #   session id, and migration of data to be referenced at the new id. If
-      #   :defer is set, it will be overridden and the cookie will be set.
-      # * :sidbits sets the number of bits in length that a generated session
-      #   id will be.
-      #
-      # These options can be set on a per request basis, at the location of
-      # env['rack.session.options']. Additionally the id of the session can be
-      # found within the options hash at the key :id. It is highly not
-      # recommended to change its value.
-      #
-      # Is Rack::Utils::Context compatible.
-      #
-      # Not included by default; you must require 'rack/session/abstract/id'
-      # to use.
-      class ID
-        DEFAULT_OPTIONS = {
-          :key =>           'rack.session',
-          :path =>          '/',
-          :domain =>        nil,
-          :expire_after =>  nil,
-          :secure =>        false,
-          :httponly =>      true,
-          :defer =>         false,
-          :renew =>         false,
-          :sidbits =>       128,
-          :cookie_only =>   true,
-          :secure_random => (::SecureRandom rescue false)
-        }
-        attr_reader :key, :default_options
-        def initialize(app, options={})
-          @app = app
-          @default_options = self.class::DEFAULT_OPTIONS.merge(options)
-          @key = @default_options.delete(:key)
-          @cookie_only = @default_options.delete(:cookie_only)
-          initialize_sid
-        end
-        def call(env)
-          context(env)
-        end
-        def context(env, app=@app)
-          prepare_session(env)
-          status, headers, body = app.call(env)
-          commit_session(env, status, headers, body)
-        end
-        private
-        def initialize_sid
-          @sidbits = @default_options[:sidbits]
-          @sid_secure = @default_options[:secure_random]
-          @sid_length = @sidbits / 4
-        end
-        # Generate a new session id using Ruby #rand.  The size of the
-        # session id is controlled by the :sidbits option.
-        # Monkey patch this to use custom methods for session id generation.
-        def generate_sid(secure = @sid_secure)
-          if secure
-            SecureRandom.hex(@sid_length)
-          else
-            "%0#{@sid_length}x" % Kernel.rand(2**@sidbits - 1)
-          end
-        rescue NotImplementedError
-          generate_sid(false)
-        end
-        # Sets the lazy session at 'rack.session' and places options and session
-        # metadata into 'rack.session.options'.
-        def prepare_session(env)
-          session_was                  = env[ENV_SESSION_KEY]
-          env[ENV_SESSION_KEY]         = SessionHash.new(self, env)
-          env[ENV_SESSION_OPTIONS_KEY] = OptionsHash.new(self, env, @default_options)
-          env[ENV_SESSION_KEY].merge! session_was if session_was
-        end
-        # Extracts the session id from provided cookies and passes it and the
-        # environment to #get_session.
-        def load_session(env)
-          sid = current_session_id(env)
-          sid, session = get_session(env, sid)
-          [sid, session || {}]
-        end
-        # Extract session id from request object.
-        def extract_session_id(env)
-          request = Rack::Request.new(env)
-          sid = request.cookies[@key]
-          sid ||= request.params[@key] unless @cookie_only
-          sid
-        end
-        # Returns the current session id from the OptionsHash.
-        def current_session_id(env)
-          env[ENV_SESSION_OPTIONS_KEY][:id]
-        end
-        # Check if the session exists or not.
-        def session_exists?(env)
-          value = current_session_id(env)
-          value && !value.empty?
-        end
-        # Session should be commited if it was loaded, any of specific options like :renew, :drop
-        # or :expire_after was given and the security permissions match. Skips if skip is given.
-        def commit_session?(env, session, options)
-          if options[:skip]
-            false
-          else
-            has_session = loaded_session?(session) || forced_session_update?(session, options)
-            has_session && security_matches?(env, options)
-          end
-        end
-        def loaded_session?(session)
-          !session.is_a?(SessionHash) || session.loaded?
-        end
-        def forced_session_update?(session, options)
-          force_options?(options) && session && !session.empty?
-        end
-        def force_options?(options)
-          options.values_at(:renew, :drop, :defer, :expire_after).any?
-        end
-        def security_matches?(env, options)
-          return true unless options[:secure]
-          request = Rack::Request.new(env)
-          request.ssl?
-        end
-        # Acquires the session from the environment and the session id from
-        # the session options and passes them to #set_session. If successful
-        # and the :defer option is not true, a cookie will be added to the
-        # response with the session's id.
-        def commit_session(env, status, headers, body)
-          session = env['rack.session']
-          options = env['rack.session.options']
-          if options[:drop] || options[:renew]
-            session_id = destroy_session(env, options[:id] || generate_sid, options)
-            return [status, headers, body] unless session_id
-          end
-          return [status, headers, body] unless commit_session?(env, session, options)
-          session.send(:load!) unless loaded_session?(session)
-          session = session.to_hash
-          session_id ||= options[:id] || generate_sid
-          if not data = set_session(env, session_id, session, options)
-            env["rack.errors"].puts("Warning! #{self.class.name} failed to save session. Content dropped.")
-          elsif options[:defer] and not options[:renew]
-            env["rack.errors"].puts("Defering cookie for #{session_id}") if $VERBOSE
-          else
-            cookie = Hash.new
-            cookie[:value] = data
-            cookie[:expires] = Time.now + options[:expire_after] if options[:expire_after]
-            set_cookie(env, headers, cookie.merge!(options))
-          end
-          [status, headers, body]
-        end
-        # Sets the cookie back to the client with session id. We skip the cookie
-        # setting if the value didn't change (sid is the same) or expires was given.
-        def set_cookie(env, headers, cookie)
-          request = Rack::Request.new(env)
-          if request.cookies[@key] != cookie[:value] || cookie[:expires]
-            Utils.set_cookie_header!(headers, @key, cookie)
-          end
-        end
-        # All thread safety and session retrival proceedures should occur here.
-        # Should return [session_id, session].
-        # If nil is provided as the session id, generation of a new valid id
-        # should occur within.
-        def get_session(env, sid)
-          raise '#get_session not implemented.'
-        end
-        # All thread safety and session storage proceedures should occur here.
-        # Should return true or false dependant on whether or not the session
-        # was saved or not.
-        def set_session(env, sid, session, options)
-          raise '#set_session not implemented.'
-        end
-        # All thread safety and session destroy proceedures should occur here.
-        # Should return a new session id or nil if options[:drop]
-        def destroy_session(env, sid, options)
-          raise '#destroy_session not implemented'
-        end
-      end
-    end
-  end
-end