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

webmachine 0.4.1 → 0.4.2

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 (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