egalite 0.0.7 → 1.0.0

data/rack/handler/evented_mongrel.rb

@@ -1,8 +0,0 @@
-require 'swiftcore/evented_mongrel'
-
-module Rack
-  module Handler
-    class EventedMongrel < Handler::Mongrel
-    end
-  end
-end

data/rack/handler/fastcgi.rb

@@ -1,89 +0,0 @@
-require 'fcgi'
-require 'socket'
-require 'rack/content_length'
-require 'rack/rewindable_input'
-
-if defined? FCGI::Stream
-  class FCGI::Stream
-    alias _rack_read_without_buffer read
-
-    def read(n, buffer=nil)
-      buf = _rack_read_without_buffer n
-      buffer.replace(buf.to_s)  if buffer
-      buf
-    end
-  end
-end
-
-module Rack
-  module Handler
-    class FastCGI
-      def self.run(app, options={})
-        file = options[:File] and STDIN.reopen(UNIXServer.new(file))
-        port = options[:Port] and STDIN.reopen(TCPServer.new(port))
-        FCGI.each { |request|
-          serve request, app
-        }
-      end
-
-      def self.serve(request, app)
-        app = Rack::ContentLength.new(app)
-
-        env = request.env
-        env.delete "HTTP_CONTENT_LENGTH"
-
-        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
-
-        rack_input = RewindableInput.new(request.in)
-
-        env.update({"rack.version" => Rack::VERSION,
-                     "rack.input" => rack_input,
-                     "rack.errors" => request.err,
-
-                     "rack.multithread" => false,
-                     "rack.multiprocess" => true,
-                     "rack.run_once" => false,
-
-                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
-                   })
-
-        env["QUERY_STRING"] ||= ""
-        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-        env["REQUEST_PATH"] ||= "/"
-        env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
-        env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
-
-        begin
-          status, headers, body = app.call(env)
-          begin
-            send_headers request.out, status, headers
-            send_body request.out, body
-          ensure
-            body.close  if body.respond_to? :close
-          end
-        ensure
-          rack_input.close
-          request.finish
-        end
-      end
-
-      def self.send_headers(out, status, headers)
-        out.print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            out.print "#{k}: #{v}\r\n"
-          }
-        }
-        out.print "\r\n"
-        out.flush
-      end
-
-      def self.send_body(out, body)
-        body.each { |part|
-          out.print part
-          out.flush
-        }
-      end
-    end
-  end
-end

data/rack/handler/lsws.rb

@@ -1,63 +0,0 @@
-require 'lsapi'
-require 'rack/content_length'
-require 'rack/rewindable_input'
-
-module Rack
-  module Handler
-    class LSWS
-      def self.run(app, options=nil)
-        while LSAPI.accept != nil
-          serve app
-        end
-      end
-      def self.serve(app)
-        app = Rack::ContentLength.new(app)
-
-        env = ENV.to_hash
-        env.delete "HTTP_CONTENT_LENGTH"
-        env["SCRIPT_NAME"] = "" if env["SCRIPT_NAME"] == "/"
-
-        rack_input = RewindableInput.new($stdin.read.to_s)
-
-        env.update(
-          "rack.version" => Rack::VERSION,
-          "rack.input" => rack_input,
-          "rack.errors" => $stderr,
-          "rack.multithread" => false,
-          "rack.multiprocess" => true,
-          "rack.run_once" => false,
-          "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
-      ensure
-        rack_input.close
-      end
-      def self.send_headers(status, headers)
-        print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            print "#{k}: #{v}\r\n"
-          }
-        }
-        print "\r\n"
-        STDOUT.flush
-      end
-      def self.send_body(body)
-        body.each { |part|
-          print part
-          STDOUT.flush
-        }
-      end
-    end
-  end
-end

data/rack/handler/mongrel.rb

@@ -1,90 +0,0 @@
-require 'mongrel'
-require 'stringio'
-require 'rack/content_length'
-require 'rack/chunked'
-
-module Rack
-  module Handler
-    class Mongrel < ::Mongrel::HttpHandler
-      def self.run(app, options={})
-        server = ::Mongrel::HttpServer.new(
-          options[:Host]           || '0.0.0.0',
-          options[:Port]           || 8080,
-          options[:num_processors] || 950,
-          options[:throttle]       || 0,
-          options[:timeout]        || 60)
-        # Acts like Rack::URLMap, utilizing Mongrel's own path finding methods.
-        # Use is similar to #run, replacing the app argument with a hash of
-        # { path=>app, ... } or an instance of Rack::URLMap.
-        if options[:map]
-          if app.is_a? Hash
-            app.each do |path, appl|
-              path = '/'+path unless path[0] == ?/
-              server.register(path, Rack::Handler::Mongrel.new(appl))
-            end
-          elsif app.is_a? URLMap
-            app.instance_variable_get(:@mapping).each do |(host, path, appl)|
-             next if !host.nil? && !options[:Host].nil? && options[:Host] != host
-             path = '/'+path unless path[0] == ?/
-             server.register(path, Rack::Handler::Mongrel.new(appl))
-            end
-          else
-            raise ArgumentError, "first argument should be a Hash or URLMap"
-          end
-        else
-          server.register('/', Rack::Handler::Mongrel.new(app))
-        end
-        yield server  if block_given?
-        server.run.join
-      end
-
-      def initialize(app)
-        @app = Rack::Chunked.new(Rack::ContentLength.new(app))
-      end
-
-      def process(request, response)
-        env = {}.replace(request.params)
-        env.delete "HTTP_CONTENT_TYPE"
-        env.delete "HTTP_CONTENT_LENGTH"
-
-        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
-
-        rack_input = request.body || StringIO.new('')
-        rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
-
-        env.update({"rack.version" => Rack::VERSION,
-                     "rack.input" => rack_input,
-                     "rack.errors" => $stderr,
-
-                     "rack.multithread" => true,
-                     "rack.multiprocess" => false, # ???
-                     "rack.run_once" => false,
-
-                     "rack.url_scheme" => "http",
-                   })
-        env["QUERY_STRING"] ||= ""
-
-        status, headers, body = @app.call(env)
-
-        begin
-          response.status = status.to_i
-          response.send_status(nil)
-
-          headers.each { |k, vs|
-            vs.split("\n").each { |v|
-              response.header[k] = v
-            }
-          }
-          response.send_header
-
-          body.each { |part|
-            response.write part
-            response.socket.flush
-          }
-        ensure
-          body.close  if body.respond_to? :close
-        end
-      end
-    end
-  end
-end

data/rack/handler/scgi.rb

@@ -1,59 +0,0 @@
-require 'scgi'
-require 'stringio'
-require 'rack/content_length'
-require 'rack/chunked'
-
-module Rack
-  module Handler
-    class SCGI < ::SCGI::Processor
-      attr_accessor :app
-
-      def self.run(app, options=nil)
-        new(options.merge(:app=>app,
-                          :host=>options[:Host],
-                          :port=>options[:Port],
-                          :socket=>options[:Socket])).listen
-      end
-
-      def initialize(settings = {})
-        @app = Rack::Chunked.new(Rack::ContentLength.new(settings[:app]))
-        super(settings)
-      end
-
-      def process_request(request, input_body, socket)
-        env = {}.replace(request)
-        env.delete "HTTP_CONTENT_TYPE"
-        env.delete "HTTP_CONTENT_LENGTH"
-        env["REQUEST_PATH"], env["QUERY_STRING"] = env["REQUEST_URI"].split('?', 2)
-        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-        env["PATH_INFO"] = env["REQUEST_PATH"]
-        env["QUERY_STRING"] ||= ""
-        env["SCRIPT_NAME"] = ""
-
-        rack_input = StringIO.new(input_body)
-        rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
-
-        env.update({"rack.version" => Rack::VERSION,
-                     "rack.input" => rack_input,
-                     "rack.errors" => $stderr,
-                     "rack.multithread" => true,
-                     "rack.multiprocess" => true,
-                     "rack.run_once" => false,
-
-                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
-                   })
-        status, headers, body = app.call(env)
-        begin
-          socket.write("Status: #{status}\r\n")
-          headers.each do |k, vs|
-            vs.split("\n").each { |v| socket.write("#{k}: #{v}\r\n")}
-          end
-          socket.write("\r\n")
-          body.each {|s| socket.write(s)}
-        ensure
-          body.close if body.respond_to? :close
-        end
-      end
-    end
-  end
-end

data/rack/handler/swiftiplied_mongrel.rb

@@ -1,8 +0,0 @@
-require 'swiftcore/swiftiplied_mongrel'
-
-module Rack
-  module Handler
-    class SwiftipliedMongrel < Handler::Mongrel
-    end
-  end
-end

data/rack/handler/thin.rb

@@ -1,18 +0,0 @@
-require "thin"
-require "rack/content_length"
-require "rack/chunked"
-
-module Rack
-  module Handler
-    class Thin
-      def self.run(app, options={})
-        app = Rack::Chunked.new(Rack::ContentLength.new(app))
-        server = ::Thin::Server.new(options[:Host] || '0.0.0.0',
-                                    options[:Port] || 8080,
-                                    app)
-        yield server if block_given?
-        server.start
-      end
-    end
-  end
-end

data/rack/handler/webrick.rb

@@ -1,73 +0,0 @@
-require 'webrick'
-require 'stringio'
-require 'rack/content_length'
-
-module Rack
-  module Handler
-    class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
-      def self.run(app, options={})
-        options[:BindAddress] = options.delete(:Host) if options[:Host]
-        @server = ::WEBrick::HTTPServer.new(options)
-        @server.mount "/", Rack::Handler::WEBrick, app
-        yield @server  if block_given?
-        @server.start
-      end
-
-      def self.shutdown
-        @server.shutdown
-        @server = nil
-      end
-
-      def initialize(server, app)
-        super server
-        @app = Rack::ContentLength.new(app)
-      end
-
-      def service(req, res)
-        env = req.meta_vars
-        env.delete_if { |k, v| v.nil? }
-
-        rack_input = StringIO.new(req.body.to_s)
-        rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
-
-        env.update({"rack.version" => Rack::VERSION,
-                     "rack.input" => rack_input,
-                     "rack.errors" => $stderr,
-
-                     "rack.multithread" => true,
-                     "rack.multiprocess" => false,
-                     "rack.run_once" => false,
-
-                     "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
-                   })
-
-        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-        env["QUERY_STRING"] ||= ""
-        env["REQUEST_PATH"] ||= "/"
-        unless env["PATH_INFO"] == ""
-          path, n = req.request_uri.path, env["SCRIPT_NAME"].length
-          env["PATH_INFO"] = path[n, path.length-n]
-        end
-
-        status, headers, body = @app.call(env)
-        begin
-          res.status = status.to_i
-          headers.each { |k, vs|
-            if k.downcase == "set-cookie"
-              res.cookies.concat vs.split("\n")
-            else
-              vs.split("\n").each { |v|
-                res[k] = v
-              }
-            end
-          }
-          body.each { |part|
-            res.body << part
-          }
-        ensure
-          body.close  if body.respond_to? :close
-        end
-      end
-    end
-  end
-end

data/rack/handler.rb

@@ -1,88 +0,0 @@
-module Rack
-  # *Handlers* connect web servers with Rack.
-  #
-  # Rack includes Handlers for Mongrel, WEBrick, FastCGI, CGI, SCGI
-  # and LiteSpeed.
-  #
-  # Handlers usually are activated by calling <tt>MyHandler.run(myapp)</tt>.
-  # A second optional hash can be passed to include server-specific
-  # configuration.
-  module Handler
-    def self.get(server)
-      return unless server
-      server = server.to_s
-
-      if klass = @handlers[server]
-        obj = Object
-        klass.split("::").each { |x| obj = obj.const_get(x) }
-        obj
-      else
-        try_require('rack/handler', server)
-        const_get(server)
-      end
-    end
-
-    def self.default(options = {})
-      # Guess.
-      if ENV.include?("PHP_FCGI_CHILDREN")
-        # We already speak FastCGI
-        options.delete :File
-        options.delete :Port
-
-        Rack::Handler::FastCGI
-      elsif ENV.include?("REQUEST_METHOD")
-        Rack::Handler::CGI
-      else
-        begin
-          Rack::Handler::Mongrel
-        rescue LoadError => e
-          Rack::Handler::WEBrick
-        end
-      end
-    end
-
-    # Transforms server-name constants to their canonical form as filenames,
-    # then tries to require them but silences the LoadError if not found
-    #
-    # Naming convention:
-    #
-    #   Foo # => 'foo'
-    #   FooBar # => 'foo_bar.rb'
-    #   FooBAR # => 'foobar.rb'
-    #   FOObar # => 'foobar.rb'
-    #   FOOBAR # => 'foobar.rb'
-    #   FooBarBaz # => 'foo_bar_baz.rb'
-    def self.try_require(prefix, const_name)
-      file = const_name.gsub(/^[A-Z]+/) { |pre| pre.downcase }.
-        gsub(/[A-Z]+[^A-Z]/, '_\&').downcase
-
-      require(::File.join(prefix, file))
-    rescue LoadError
-    end
-
-    def self.register(server, klass)
-      @handlers ||= {}
-      @handlers[server] = klass
-    end
-
-    autoload :CGI, "rack/handler/cgi"
-    autoload :FastCGI, "rack/handler/fastcgi"
-    autoload :Mongrel, "rack/handler/mongrel"
-    autoload :EventedMongrel, "rack/handler/evented_mongrel"
-    autoload :SwiftipliedMongrel, "rack/handler/swiftiplied_mongrel"
-    autoload :WEBrick, "rack/handler/webrick"
-    autoload :LSWS, "rack/handler/lsws"
-    autoload :SCGI, "rack/handler/scgi"
-    autoload :Thin, "rack/handler/thin"
-
-    register 'cgi', 'Rack::Handler::CGI'
-    register 'fastcgi', 'Rack::Handler::FastCGI'
-    register 'mongrel', 'Rack::Handler::Mongrel'
-    register 'emongrel', 'Rack::Handler::EventedMongrel'
-    register 'smongrel', 'Rack::Handler::SwiftipliedMongrel'
-    register 'webrick', 'Rack::Handler::WEBrick'
-    register 'lsws', 'Rack::Handler::LSWS'
-    register 'scgi', 'Rack::Handler::SCGI'
-    register 'thin', 'Rack::Handler::Thin'
-  end
-end

data/rack/head.rb

@@ -1,19 +0,0 @@
-module Rack
-
-class Head
-  def initialize(app)
-    @app = app
-  end
-
-  def call(env)
-    status, headers, body = @app.call(env)
-
-    if env["REQUEST_METHOD"] == "HEAD"
-      [status, headers, []]
-    else
-      [status, headers, body]
-    end
-  end
-end
-
-end