RubyGems - dispatcher - Versions diffs - 0.0.1 - Mend

dispatcher 0.0.1

Files changed (11) hide show

data/LICENSE.txt +0 -0
data/README.txt +33 -0
data/SyntaxCheck/lib/dispatcher.rb +0 -0
data/SyntaxCheck/lib/dispatcher/cgi.rb +0 -0
data/SyntaxCheck/lib/dispatcher/cli.rb +0 -0
data/TODO.txt +0 -0
data/lib/dispatch.rb +31 -0
data/lib/dispatcher.rb +306 -0
data/lib/dispatcher/cgi.rb +74 -0
data/lib/dispatcher/cli.rb +76 -0
metadata +60 -0

data/LICENSE.txt ADDED

File without changes

data/README.txt ADDED

@@ -0,0 +1,33 @@
+= Dispatcher
+The +Dispatcher+ module defines a simple and consistent interface between Ruby and most webserver
+configurations. This library provides a very restrictive set of features, and as such is generally
+not meant to be directly used by web-application authors, but instead targets implementors of
+frameworks and web-libraries.
+== Basic Usage
+The following is a very basic example of relaying a "Hello World" type response back to the
+webserver. Notice that we rely on the +autodetection+ facilities of +Dispatcher+ here, by not
+defining or configuring which webserver interface the script is to utilize.
+  require 'dispatcher'
+  Dispatcher.dispatch do |request|
+    header 'Status',       '200 OK'
+    header 'Content-Type', 'text/plain'
+    print 'Hello World'
+  end
+However, in some instances, we may wish to use a webserver that cannot be necessairly
++autodetected+, such as a standalone server like +Mongrel+.
+  require 'dispatcher/mongrel'
+  Dispatcher.dispatch(:port => 8081) do |request|
+    header 'Status',       '200 OK'
+    header 'Content-Type', 'text/plain'
+    print 'Hello World'
+  end

data/SyntaxCheck/lib/dispatcher.rb ADDED

File without changes

data/SyntaxCheck/lib/dispatcher/cgi.rb ADDED

File without changes

data/SyntaxCheck/lib/dispatcher/cli.rb ADDED

File without changes

data/TODO.txt ADDED

File without changes

data/lib/dispatch.rb ADDED

@@ -0,0 +1,31 @@
+require 'dispatcher/cgi'
+Dispatcher.dispatch do |request|
+  header 'Status', '200 NOT OK'
+  header 'Content-Type', 'text/plain'
+  print "#{request.uri}\n\n"
+  print request.inspect.gsub(' @', "\n@").gsub('={', "={\n  ").gsub('",', "\",\n ").gsub('"}', "\"\n}")
+=begin
+  print %{<?xml version="1.0" encoding="UTF-8"?>
+  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
+      "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+  <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" >
+    <head>
+      <title>Roar</title>
+    </head>
+    <body>}
+  print "<h2>#{Dispatcher.autodetect}</h2>"
+  print "<h3>Working Directory</h3>\n"
+  print Dir.getwd
+  print "<h3>Environment Variables</h3>\n"
+  print "<table style=\"font-size: 0.75em;\"><tbody>\n"
+  ENV.each do |key, value|
+    print "<tr><td style=\"text-align:right;\"><b>#{key}</b>:</td><td>#{value}</td></tr>\n"
+  end
+  print "</tbody></table>\n"
+  print %{  </body>
+  </html>}
+=end
+end

data/lib/dispatcher.rb ADDED

@@ -0,0 +1,306 @@
+module Dispatcher
+  CR   = 13.chr
+  LF   = 10.chr
+  CRLF = CR + LF
+  # Dispatches the specified responder block, given the passed parameters.
+  #
+  # If a subclass of Dispatcher is passed, it will be used as the dispatcher interface. Otherwise,
+  # the last-defined interface will be used. Failing that, the functian will appempt to autodetect
+  # an appropriate interface.
+  #
+  # Additionally, any number of named parameters (:param => value) may be passed, and will be
+  # considered configuration values for the given dispatcher interface.
+  def self::dispatch(*params, &responder)
+    dispatcher = self.default_dispatcher
+    config     = Hash.new
+    params.each do |param|
+      dispatcher = param if param.kind_of? CoreDispatcher
+      config     = param if param.kind_of? Hash
+    end
+    # Autodetect if don't have a valid dispatcher
+    dispatcher = self.autodetect if not dispatcher
+    # create our Dispatcher, and start listening for requests
+    dispatcher = dispatcher.new(responder, config)
+    dispatcher.listen
+  end
+  # Attempts to autodetects an appropriate dispatcher interface depending on the current
+  # configuration. If an appropriate interface is found, it will be loaded, and the appropriate
+  # Dispatcher subclass will be returned. (CoreDispatcher by default)
+  def self.autodetect
+    # Check for CGI
+    if ENV.has_key? 'GATEWAY_INTERFACE' and ENV['GATEWAY_INTERFACE'][0,4].upcase == 'CGI/'
+      require 'dispatcher/cgi'
+      return CGIDispatcher
+    # Check for CLI
+    elsif ENV.has_key? 'PROMPT'
+      require 'dispatcher/cli'
+      return CLIDispatcher
+    # By default, we turn to the CoreDispatcher
+    else
+      return CoreDispatcher
+    end
+  end
+  # A core Dispatcher interface.
+  #
+  # This is intended as a 'virtual' class that all other dispatcher interfaces inherit from.
+  class CoreDispatcher
+    # Creates a new
+    def initialize(responder, *config)
+      @responder = responder
+      @config    = config
+    end
+    # Start listening for incoming requests.
+    def listen
+      err  = 'You are attempting to use the default Dispatcher interface. '
+      err += 'Most likely the library was unable to autodetect an appropriate interface. '
+      err += 'Try specifying one manually via a require \'request/<interface>\'.'
+      raise TypeError, err, caller
+    end
+    # Super-simple handler.
+    #
+    # Just outputs any STDOUT content. Buffering should be done at the Responder level.
+    def handle(request)
+      response = Response.new(@responder)
+      response.render(request)
+    end
+    # Set the default_dispatcher to the last class that inherits CoreDispatcher.
+    def self.inherited(subclass)
+      Dispatcher.default_dispatcher = subclass
+    end
+  end
+  # A HTTP request.
+  class Request
+    # Any HTTP headers passed along with the request
+    attr_accessor :headers
+    # The body of the request, if given.
+    attr_accessor :body
+    # A full set of CGI environment values
+    attr_accessor :values
+    # Every environment variable passed from the server
+    attr_accessor :env
+    # Generates a new request.
+    #
+    # Any values passed will be set to the appropriate attributes.
+    def initialize(*vals)
+      @headers = HTTPHeaderHash.new
+      @env     = Hash.new
+      @values  = Hash.new
+      vals.each do |key, value|
+        instance_variable_set(key, value)
+      end
+    end
+    # The current request method.
+    def method
+      @values['REQUEST_METHOD']
+    end
+    # The requested path
+    def path
+      @values['PATH_INFO']
+    end
+    # The fully qualified URI of the request
+    def uri
+      # protocol
+      result = 'http'
+      if @values['HTTPS'] == 'on'
+        result += 's'
+      end
+      # server/port
+      result += "://#{@values['HTTP_HOST']}"
+      # path
+      result += @values['PATH_INFO']
+      # query
+      if @values['QUERY_STRING'] != ''
+        result += "?#{@values['QUERY_STRING']}"
+      end
+      return result
+    end
+    alias_method :url, :uri
+  end
+  # A response object embodies a single HTTP response to the Dispatcher.
+  class Response
+    attr_reader :body, :headers
+    attr_accessor :body_start
+    # Defines a new response
+    #
+    # The responder is a Proc object, that when run, output the HTTP response, via $stdout and any
+    # helper functions defined in this class, such as header().
+    #
+    # If buffered is true, the responder method will be completely processed before any output is
+    # rendered or returned.
+    def initialize(responder, buffered = false)
+      @headers = HTTPHeaderHash.new
+      @body    = ''
+      @body_start = false
+      @buffered   = buffered
+      (class <<self; self; end).send(:define_method, :responder, responder)
+    end
+    # Sets a header for the response.
+    #
+    # If the response is currently unbuffered, the header will be rendered once $stdout is written
+    # to, otherwise it will be rendered at the end of buffering (or the end of the responder).
+    #
+    # Please note that if a header is sent after content is already rendered, an IOError will be
+    # thrown.
+    def header(field, value)
+      if @body_start
+        raise IOError, 'Attempt to output headers after the response body has started.', caller
+      end
+      @headers[field] = value
+    end
+    # Buffers a block's output to $stdout.
+    #
+    # The method will return the buffered output if passback is true.
+    def buffer(passback = false)
+      old_out = $stdout
+      $stdout = $stdout.clone
+      class <<$stdout
+        attr_accessor :buffer
+        def write(value)
+          @buffer << value
+        end
+      end
+      $stdout.buffer = ''
+      yield
+      result = $stdout.buffer
+      $stdout = old_out
+      if passback
+        return result
+      else
+        # if this is the first render of the body, we need to print out any headers
+        if not @body_start
+          @body_start = true
+          @headers.each do |field, value|
+            print field + ': ' + value + CRLF
+          end
+          print CRLF
+        end
+        print result
+      end
+    end
+    # Renders the request
+    #
+    # If the response was designated as a buffered response at creation, the headers and body may
+    # be retrieved from the object (no output will be rendered by this method).
+    #
+    # If the response is not buffered, the body and header attributes must be ignored.
+    def render(request)
+      if @buffered
+        @body = buffer(true) do
+          responder(request)
+        end
+      else
+        # intercept the first chunk of output so we can detect header usage
+        old_out = $stdout
+        $stdout = $stdout.clone
+        class <<$stdout
+          attr_accessor :response
+          def write(val)
+            if not @ignore and not @response.body_start
+              @response.body_start = true
+              @response.headers.each do |field, value|
+                print field + ': ' + value + CRLF
+              end
+              print CRLF
+            end
+            super(val)
+          end
+        end
+        $stdout.response = self
+        responder(request)
+        print ''
+        $stdout = old_out
+      end
+    end
+  end
+  # Defines a Hash of HTTP headers.
+  #
+  # Keys are case-insensitive, and converted to 'pretty' keys
+  # e.g. 'CoNtEnT-TYPE' would be 'Content-Type'
+  #
+  # This class <b>does not</b> parse for valid HTTP header fields, so you may recieve
+  # errors from your webserver if a malformed header is passed.
+  class HTTPHeaderHash < Hash
+    def initialize(*values)
+      values.each do |field, value|
+        self[field] = value
+      end
+    end
+    # Converts the given key string into a 'pretty' HTTP header field
+    def self.pretty_field(field)
+      chunks = field.gsub('_', '-').split('-')
+      chunks.collect! do |val|
+        val.capitalize
+      end
+      return chunks.join('-')
+    end
+    # Sets the key to value.
+    def []=(field, value)
+      super(HTTPHeaderHash.pretty_field(field.to_s), value.to_s)
+    end
+    # Returns the value stored for key.
+    def [](field)
+      super(HTTPHeaderHash.pretty_field(field.to_s))
+    end
+  end
+  # Typically, this returns the last-defined subclass of CoreDispatcher.
+  def self.default_dispatcher
+    @default_dispatcher
+  end
+  # This is automatically set when a class inherits from CoreDispatcher.
+  def self.default_dispatcher=(dispatcher)
+    @default_dispatcher = dispatcher
+  end
+end

data/lib/dispatcher/cgi.rb ADDED

@@ -0,0 +1,74 @@
+require 'dispatcher'
+module Dispatcher
+  # CGI Dispatcher
+  #
+  # Manages dispatching to CGI interfaces.
+  class CGIDispatcher < CoreDispatcher
+    # Immediately processes the request for the values given in ENV.
+    def listen
+      # set up our request
+      request = generate_request
+      # and handle it
+      handle(request)
+    end
+    # Generates a reques object from the current values of ENV
+    def generate_request
+      request = Request.new
+      # Copy information out of the environment
+      ENV.each do |key, value|
+        request.env[key] = value
+        if key[0,5].upcase == 'HTTP_'
+          request.headers[key[5, key.length - 5]] = value
+        end
+      end
+      # Set up the CGI value Hash
+      request.values = build_cgi_environment(request.env)
+      return request
+    end
+    #:nodoc:
+    # List of environment values used in the CGI environment.
+    # We use Hash keys to avoid O(n^2) type behavior.
+    CGI_VARS = {
+      'AUTH_TYPE' => true,
+      'CONTENT_LENGTH' => true,
+      'CONTENT_TYPE' => true,
+      'GATEWAY_INTERFACE' => true,
+      'HTTPS' => true, # non-spec
+      'PATH_INFO' => true,
+      'PATH_TRANSLATED' => true,
+      'QUERY_STRING' => true,
+      'REMOTE_ADDR' => true,
+      'REMOTE_HOST' => true,
+      'REMOTE_IDENT' => true,
+      'REMOTE_USER' => true,
+      'REQUEST_METHOD' => true,
+      'SCRIPT_NAME' => true,
+      'SERVER_NAME' => true,
+      'SERVER_PORT' => true,
+      'SERVER_PROTOCOL' => true,
+      'SERVER_SOFTWARE' => true,
+    }
+    # Generates a hash of a CGI environment from values in the given hash.
+    def build_cgi_environment(env)
+      cgi_env = Hash.new
+      env.each do |key, value|
+        if key[0,5].upcase == 'HTTP_' or CGI_VARS[key.upcase]
+          cgi_env[key] = value
+        end
+      end
+      return cgi_env
+    end
+  end
+end

data/lib/dispatcher/cli.rb ADDED

@@ -0,0 +1,76 @@
+require 'dispatcher'
+require 'getoptlong'
+require 'uri'
+module Dispatcher
+  # Command line Dispatcher interface.
+  #
+  # The CLI interface allows for easy command line debugging of Responders.
+  #
+  # Usage: script.rb [URI] [switches]
+  class CLIDispatcher < CoreDispatcher
+    OPTS = GetoptLong.new(
+      ['--help', '-h', GetoptLong::NO_ARGUMENT],
+      ['--clean', '-c', GetoptLong::NO_ARGUMENT]
+    )
+    # Sets up the request, and handles the response.
+    def listen
+      # read the options into a Hash
+      options = Hash.new
+      OPTS.quiet = true # shut it up
+      begin
+        OPTS.each do |opt, value|
+          options[opt] = value
+        end
+      # catch invalid option exceptions
+      rescue GetoptLong::InvalidOption => err
+        puts err.to_s + '  (-h will show valid options)'
+      end
+      # help?
+      if options.has_key? '--help'
+        display_help
+      # otherwise we're going to handle a request
+      else
+        # set up our request
+        request = Request.new
+        # and handle it
+        if options.has_key? '--clean'
+          handle_cleaned(request)
+        else
+          handle(request)
+        end
+      end
+    end
+    # Displays a nicely formatted copy of the response
+    def handle_cleaned(request)
+      response = Response.new(@responder, true)
+      response.render(request)
+      body = response.body
+      # strip tags
+      body.gsub!(/<\/?[^>]*>/, "")
+      print body
+    end
+    # Displays the command line help and usage details
+    def display_help
+      print %{
+Usage: #{File.basename($0)} [URI] [options]
+  Options:
+    -c/--clean   Cleans up any HTML output for easy screen reading
+    -h/--help    Help. You're looking at it
+  Further Information:
+    http://dispatcher.rubyforge.org
+}
+    end
+  end
+end

metadata ADDED

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+rubygems_version: 0.9.0
+specification_version: 1
+name: dispatcher
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+date: 2006-10-08 00:00:00 -05:00
+summary: A lightweight HTTP dispatch interface between Ruby and most webserver configurations.
+require_paths:
+- lib
+email: imacleod@gmail.com
+homepage: http://dispatcher.rubyforge.org/
+rubyforge_project: dispatcher
+description: Dispatcher provides a simple and consistent interface between Ruby and most webserver configurations. It is typically used in conjunction with a request-building system, such as the Responder gem.
+autorequire: dispatcher
+default_executable:
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 0.0.0
+  version:
+platform: ruby
+signing_key:
+cert_chain:
+post_install_message:
+authors:
+- Ian MacLeod
+files:
+- lib/dispatch.rb
+- lib/dispatcher.rb
+- lib/dispatcher/cgi.rb
+- lib/dispatcher/cli.rb
+- SyntaxCheck/lib/dispatcher.rb
+- SyntaxCheck/lib/dispatcher/cgi.rb
+- SyntaxCheck/lib/dispatcher/cli.rb
+- LICENSE.txt
+- README.txt
+- TODO.txt
+test_files: []
+rdoc_options:
+- --title
+- Dispatcher
+- --main
+- README.txt
+extra_rdoc_files:
+- LICENSE.txt
+- README.txt
+- TODO.txt
+executables: []
+extensions: []
+requirements: []
+dependencies: []