RubyGems - dispatcher - Versions diffs - 0.0.1 - Mend

dispatcher 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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: []