RubyGems - webmachine - Versions diffs - 0.4.1 → 0.4.2 - Mend

webmachine 0.4.1 → 0.4.2

Files changed (907) hide show

data/pkg/webmachine-0.4.0/doc/top-level-namespace.html DELETED Viewed

@@ -1,103 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<title>
-  Top Level Namespace
-    &mdash; Documentation by YARD 0.7.3
-</title>
-  <link rel="stylesheet" href="css/style.css" type="text/css" media="screen" charset="utf-8" />
-  <link rel="stylesheet" href="css/common.css" type="text/css" media="screen" charset="utf-8" />
-<script type="text/javascript" charset="utf-8">
-  relpath = '';
-  if (relpath != '') relpath += '/';
-</script>
-  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
-  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
-  </head>
-  <body>
-    <script type="text/javascript" charset="utf-8">
-      if (window.top.frames.main) document.body.className = 'frames';
-    </script>
-    <div id="header">
-      <div id="menu">
-    <a href="_index.html">Index</a> &raquo;
-    <span class="title">Top Level Namespace</span>
-  <div class="noframes"><span class="title">(</span><a href="." target="_top">no frames</a><span class="title">)</span></div>
-</div>
-      <div id="search">
-    <a id="class_list_link" href="#">Class List</a>
-    <a id="method_list_link" href="#">Method List</a>
-    <a id="file_list_link" href="#">File List</a>
-</div>
-      <div class="clear"></div>
-    </div>
-    <iframe id="search_frame"></iframe>
-    <div id="content"><h1>Top Level Namespace
-</h1>
-<dl class="box">
-</dl>
-<div class="clear"></div>
-<h2>Defined Under Namespace</h2>
-<p class="children">
-      <strong class="modules">Modules:</strong> <span class='object_link'><a href="Webmachine.html" title="Webmachine (module)">Webmachine</a></span>
-</p>
-</div>
-    <div id="footer">
-  Generated on Wed Jan  4 08:47:41 2012 by
-  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.7.3 (ruby-1.9.3).
-</div>
-  </body>
-</html>

data/pkg/webmachine-0.4.0/examples/application.rb DELETED Viewed

@@ -1,35 +0,0 @@
-require 'webmachine'
-class RouteDebugResource < Webmachine::Resource
-  def to_html
-    <<-HTML
-      <html>
-        <head><title>Test from Webmachine</title></head>
-        <body>
-          <h5>request.disp_path</h5>
-          <pre>#{request.disp_path}</pre>
-          <h5>request.path_info</h5>
-          <pre>#{request.path_info}</pre>
-          <h5>request.path_tokens</h5>
-          <pre>#{request.path_tokens}</pre>
-        </body>
-      </html>
-    HTML
-  end
-end
-MyApp = Webmachine::Application.new do |app|
-  # Configure your app like this:
-  app.configure do |config|
-    config.port = 8888
-    config.adapter = :WEBrick
-  end
-  # And add routes like this:
-  app.add_route ['fizz', :buzz, '*'], RouteDebugResource
-  # OR add routes this way:
-  app.routes do
-    add [:test, :foo, '*'], RouteDebugResource
-  end
-end
-MyApp.run

data/pkg/webmachine-0.4.0/examples/webrick.rb DELETED Viewed

@@ -1,19 +0,0 @@
-require 'webmachine'
-class HelloResource < Webmachine::Resource
-  def last_modified
-    File.mtime(__FILE__)
-  end
-  def encodings_provided
-    { "gzip" => :encode_gzip, "identity" => :encode_identity }
-  end
-  def to_html
-    "<html><head><title>Hello from Webmachine</title></head><body>Hello, world!</body></html>"
-  end
-end
-Webmachine::Dispatcher.add_route([], HelloResource)
-Webmachine.run

data/pkg/webmachine-0.4.0/lib/webmachine/adapter.rb DELETED Viewed

@@ -1,36 +0,0 @@
-module Webmachine
-  # The abstract class for definining a Webmachine adapter.
-  #
-  # @abstract Subclass and override {#run} to implement a custom adapter.
-  class Adapter
-    # @return [Webmachine::Configuration] the application's configuration.
-    attr_reader :configuration
-    # @return [Webmachine::Dispatcher] the application's dispatcher.
-    attr_reader :dispatcher
-    # @param [Webmachine::Configuration] configuration the application's
-    # configuration.
-    # @param [Webmachine::Dispatcher] dispatcher the application's dispatcher.
-    def initialize(configuration, dispatcher)
-      @configuration = configuration
-      @dispatcher    = dispatcher
-    end
-    # Create a new adapter and run it.
-    def self.run(configuration, dispatcher)
-      new(configuration, dispatcher).run
-    end
-    # Start the adapter.
-    #
-    # @abstract Subclass and override {#run} to implement a custom adapter.
-    # @raise [NotImplementedError]
-    def run
-      raise NotImplementedError
-    end
-  end
-end

data/pkg/webmachine-0.4.0/lib/webmachine/adapters/mongrel.rb DELETED Viewed

@@ -1,86 +0,0 @@
-require 'mongrel'
-require 'webmachine/version'
-require 'webmachine/headers'
-require 'webmachine/request'
-require 'webmachine/response'
-require 'webmachine/dispatcher'
-require 'webmachine/chunked_body'
-module Webmachine
-  module Adapters
-    # Connects Webmachine to Mongrel.
-    class Mongrel < Adapter
-      # Starts the Mongrel adapter
-      def run
-        options = {
-          :port => configuration.port,
-          :host => configuration.ip
-        }.merge(configuration.adapter_options)
-        config = ::Mongrel::Configurator.new(options) do
-          listener do
-            uri '/', :handler => Webmachine::Adapters::Mongrel::Handler.new(dispatcher)
-          end
-          trap("INT") { stop }
-          run
-        end
-        config.join
-      end
-      # A Mongrel handler for Webmachine
-      class Handler < ::Mongrel::HttpHandler
-        def initialize(dispatcher)
-          @dispatcher = dispatcher
-          super
-        end
-        # Processes an individual request from Mongrel through Webmachine.
-        def process(wreq, wres)
-          header = Webmachine::Headers.from_cgi(wreq.params)
-          request = Webmachine::Request.new(wreq.params["REQUEST_METHOD"],
-                                            URI.parse(wreq.params["REQUEST_URI"]),
-                                            header,
-                                            wreq.body || StringIO.new(''))
-          response = Webmachine::Response.new
-          @dispatcher.dispatch(request, response)
-          begin
-            wres.status = response.code.to_i
-            wres.send_status(nil)
-            response.headers.each { |k, vs|
-              vs.split("\n").each { |v|
-                wres.header[k] = v
-              }
-            }
-            wres.header['Server'] = [Webmachine::SERVER_STRING, "Mongrel/#{::Mongrel::Const::MONGREL_VERSION}"].join(" ")
-            wres.send_header
-            case response.body
-            when String
-              wres.write response.body
-              wres.socket.flush
-            when Enumerable
-              Webmachine::ChunkedBody.new(response.body).each { |part|
-                wres.write part
-                wres.socket.flush
-              }
-            else
-              if response.body.respond_to?(:call)
-                Webmachine::ChunkedBody.new(Array(response.body.call)).each { |part|
-                  wres.write part
-                  wres.socket.flush
-                }
-              end
-            end
-          ensure
-            response.body.close if response.body.respond_to? :close
-          end
-        end
-      end # class Handler
-    end # module Mongrel
-  end # module Adapters
-end # module Webmachine

data/pkg/webmachine-0.4.0/lib/webmachine/adapters/rack.rb DELETED Viewed

@@ -1,69 +0,0 @@
-require 'rack'
-require 'webmachine/version'
-require 'webmachine/headers'
-require 'webmachine/request'
-require 'webmachine/response'
-require 'webmachine/dispatcher'
-module Webmachine
-  module Adapters
-    # A minimal "shim" adapter to allow Webmachine to interface with Rack. The
-    # intention here is to allow Webmachine to run under Rack-compatible
-    # web-servers, like unicorn and pow, and is not intended to allow Webmachine
-    # to be "plugged in" to an existing Rack app as middleware.
-    #
-    # To use this adapter, create a config.ru file and populate it like so:
-    #
-    #     require 'webmachine/adapters/rack'
-    #
-    #     # put your own Webmachine resources in another file:
-    #     require 'my/resources'
-    #
-    #     run MyApplication.adapter
-    #
-    # Servers like pow and unicorn will read config.ru by default and it should
-    # all "just work".
-    #
-    # And for development or testing your application can be run with Rack's
-    # builtin Server identically to the Mongrel and WEBrick adapters with:
-    #
-    #     MyApplication.run
-    #
-    class Rack < Adapter
-      # Start the Rack adapter
-      def run
-        options = {
-          :app => self,
-          :Port => configuration.port,
-          :Host => configuration.ip
-        }.merge(configuration.adapter_options)
-        ::Rack::Server.start(options)
-      end
-      # Handles a Rack-based request.
-      # @param [Hash] env the Rack environment
-      def call(env)
-        headers = Webmachine::Headers.from_cgi(env)
-        rack_req = ::Rack::Request.new env
-        request = Webmachine::Request.new(rack_req.request_method,
-                                          URI.parse(rack_req.url),
-                                          headers,
-                                          rack_req.body)
-        response = Webmachine::Response.new
-        @dispatcher.dispatch(request, response)
-        response.headers['Server'] = [Webmachine::SERVER_STRING, "Rack/#{::Rack.version}"].join(" ")
-        body = response.body.respond_to?(:call) ? response.body.call : response.body
-        body = body.is_a?(String) ? [ body ] : body
-        [response.code.to_i, response.headers, body || []]
-      end
-    end # class Rack
-  end # module Adapters
-end # module Webmachine

data/pkg/webmachine-0.4.0/lib/webmachine/adapters/webrick.rb DELETED Viewed

@@ -1,89 +0,0 @@
-require 'webrick'
-require 'webmachine/version'
-require 'webmachine/headers'
-require 'webmachine/request'
-require 'webmachine/response'
-require 'webmachine/dispatcher'
-module Webmachine
-  module Adapters
-    # Connects Webmachine to WEBrick.
-    class WEBrick < Adapter
-      # Starts the WEBrick adapter
-      def run
-        options = {
-          :Port => configuration.port,
-          :BindAddress => configuration.ip
-        }.merge(configuration.adapter_options)
-        server = Webmachine::Adapters::WEBrick::Server.new(dispatcher, options)
-        trap("INT"){ server.shutdown }
-        Thread.new { server.start }.join
-      end
-      # WEBRick::HTTPServer that is run by the WEBrick adapter.
-      class Server < ::WEBrick::HTTPServer
-        def initialize(dispatcher, options)
-          @dispatcher = dispatcher
-          super(options)
-        end
-        # Handles a request
-        def service(wreq, wres)
-          header = Webmachine::Headers.new
-          wreq.each {|k,v| header[k] = v }
-          request = Webmachine::Request.new(wreq.request_method,
-                                            wreq.request_uri,
-                                            header,
-                                            RequestBody.new(wreq))
-          response = Webmachine::Response.new
-          @dispatcher.dispatch(request, response)
-          wres.status = response.code.to_i
-          response.headers.each { |k,v| wres[k] = v }
-          wres['Server'] = [Webmachine::SERVER_STRING, wres.config[:ServerSoftware]].join(" ")
-          case response.body
-          when String
-            wres.body << response.body
-          when Enumerable
-            wres.chunked = true
-            response.body.each {|part| wres.body << part }
-          else
-            if response.body.respond_to?(:call)
-              wres.chunked = true
-              wres.body << response.body.call
-            end
-          end
-        end
-      end # class Server
-      # Wraps the WEBrick request body so that it can be passed to
-      # {Request} while still lazily evaluating the body.
-      class RequestBody
-        def initialize(request)
-          @request = request
-        end
-        # Converts the body to a String so you can work with the entire
-        # thing.
-        def to_s
-          @value ? @value.join : @request.body
-        end
-        # Iterates over the body in chunks. If the body has previously
-        # been read, this method can be called again and get the same
-        # sequence of chunks.
-        # @yield [chunk]
-        # @yieldparam [String] chunk a chunk of the request body
-        def each
-          if @value
-            @value.each {|chunk| yield chunk }
-          else
-            @value = []
-            @request.body {|chunk| @value << chunk; yield chunk }
-          end
-        end
-      end # class RequestBody
-    end # module WEBrick
-  end # module Adapters
-end # module Webmachine

data/pkg/webmachine-0.4.0/lib/webmachine/adapters.rb DELETED Viewed

@@ -1,9 +0,0 @@
-require 'webmachine/adapters/webrick'
-module Webmachine
-  # Contains classes and modules that connect Webmachine to Ruby
-  # application servers.
-  module Adapters
-    autoload :Mongrel, 'webmachine/adapters/mongrel'
-  end
-end

data/pkg/webmachine-0.4.0/lib/webmachine/application.rb DELETED Viewed

@@ -1,108 +0,0 @@
-require 'forwardable'
-require 'webmachine/configuration'
-require 'webmachine/dispatcher'
-module Webmachine
-  # How to get your Webmachine app running:
-  #
-  #   MyApp = Webmachine::Application.new do |app|
-  #     app.routes do
-  #       add ['*'], AssetResource
-  #     end
-  #
-  #     app.configure do |config|
-  #       config.port = 8888
-  #     end
-  #   end
-  #
-  #   MyApp.run
-  #
-  class Application
-    extend Forwardable
-    def_delegators :dispatcher, :add_route
-    # @return [Configuration] the current configuration
-    attr_accessor :configuration
-    # @return [Dispatcher] the current dispatcher
-    attr_reader :dispatcher
-    # Create an Application instance
-    #
-    # An instance of application contains Adapter configuration and
-    # a Dispatcher instance which can be configured with Routes.
-    #
-    # @param [Webmachine::Configuration] configuration
-    #   a Webmachine::Configuration
-    #
-    # @yield [app]
-    #   a block in which to configure this Application
-    # @yieldparam [Application]
-    #   the Application instance being initialized
-    def initialize(configuration = Configuration.default)
-      @configuration = configuration
-      @dispatcher    = Dispatcher.new
-      yield self if block_given?
-    end
-    # Starts this Application serving requests
-    def run
-      adapter.run
-    end
-    # @return an instance of the configured web-server adapter
-    # @see Adapters
-    def adapter
-      @adapter ||= adapter_class.new(configuration, dispatcher)
-    end
-    # @return an instance of the configured web-server adapter
-    # @see Adapters
-    def adapter_class
-      Adapters.const_get(configuration.adapter)
-    end
-    # Evaluates the passed block in the context of {Webmachine::Dispatcher}
-    # for use in adding a number of routes at once.
-    #
-    # @return [Application, Array<Route>]
-    #   self if configuring, or an Array of Routes otherwise
-    #
-    # @see Webmachine::Dispatcher#add_route
-    def routes(&block)
-      if block_given?
-        dispatcher.instance_eval(&block)
-        self
-      else
-        dispatcher.routes
-      end
-    end
-    # Configure the web server adapter via the passed block
-    #
-    # Returns the receiver so you can chain it with Application#run
-    #
-    # @yield [config]
-    #   a block in which to set configuration values
-    # @yieldparam [Configuration]
-    #   config the Configuration instance
-    #
-    # @return [Application] self
-    def configure
-      yield configuration if block_given?
-      self
-    end
-    # @return [Configuration] the current configuration
-    def configuration
-      @configuration ||= Configuration.default
-    end
-  end
-  # @return [Application] the default global Application
-  def self.application
-    @application ||= Application.new
-  end
-end

data/pkg/webmachine-0.4.0/lib/webmachine/chunked_body.rb DELETED Viewed

@@ -1,43 +0,0 @@
-module Webmachine
-  # {ChunkedBody} is used to wrap an {Enumerable} object (like an enumerable
-  # {Response#body}) so it yields proper chunks for chunked transfer encoding.
-  #
-  #     case response.body
-  #     when String
-  #       socket.write(response.body)
-  #     when Enumerable
-  #       Webmachine::ChunkedBody.new(response.body).each do |chunk|
-  #         socket.write(chunk)
-  #       end
-  #     end
-  #
-  # This is needed for Ruby webservers which don't do the chunking themselves.
-  class ChunkedBody
-    # Delimiter for chunked encoding
-    CRLF = "\r\n"
-    # Final chunk in any chunked-encoding response
-    FINAL_CHUNK = "0#{CRLF}#{CRLF}"
-    # Creates a new {ChunkedBody} from the given {Enumerable}.
-    # @param [Enumerable] body the enumerable response body
-    # @return [ChunkedBody] the wrapped response body
-    def initialize(body)
-      @body = body
-    end
-    # Calls the given block once for each chunk, passing that chunk as a
-    # parameter.
-    # Returns an {Enumerator} if no block is given.
-    def each
-      return self.to_enum unless block_given?
-      @body.each do |chunk|
-        size = chunk.bytesize
-        next if size == 0
-        yield([size.to_s(16), CRLF, chunk, CRLF].join)
-      end
-      yield(FINAL_CHUNK)
-    end
-  end # class ChunkedBody
-end # module Webmachine

data/pkg/webmachine-0.4.0/lib/webmachine/configuration.rb DELETED Viewed

@@ -1,40 +0,0 @@
-module Webmachine
-  # A simple configuration container for items that are used across
-  # multiple web server adapters. Typically set using
-  # {Webmachine::configure}. If not set by your application, the
-  # defaults will be filled in when {Webmachine::run} is called.
-  # @attr [String] ip the interface to bind to, defaults to "0.0.0.0"
-  #    (all interfaces)
-  # @attr [Fixnum] port the port to bind to, defaults to 8080
-  # @attr [Symbol] adapter the adapter to use, defaults to :WEBrick
-  # @attr [Hash] adapter_options adapter-specific options, defaults to {}
-  Configuration = Struct.new(:ip, :port, :adapter, :adapter_options)
-  # @return [Configuration] the default configuration
-  def Configuration.default
-    new("0.0.0.0", 8080, :WEBrick, {})
-  end
-  # Yields the current configuration to the passed block.
-  # @yield [config] a block that will modify the configuration
-  # @yieldparam [Configuration] config the adapter configuration
-  # @return self
-  # @see Application#configure
-  def self.configure(&block)
-    application.configure(&block)
-    self
-  end
-  # @return [Configuration] the current configuration
-  # @see Application#configuration
-  def self.configuration
-    application.configuration
-  end
-  # Sets the current configuration
-  # @param [Configuration] configuration the new config
-  # @see Application#configuration=
-  def self.configuration=(configuration)
-    application.configuration = configuration
-  end
-end # Webmachine