webmachine 1.2.0 → 1.2.2

data/.gitignore

@@ -11,7 +11,7 @@ tmtags
 .\#*
 
 ## VIM
-*.swp
+*.sw[^f]
 
 ## PROJECT::GENERAL
 coverage

data/CHANGELOG.md

@@ -0,0 +1,218 @@
+### 1.2.2 January 8, 2014
+
+1.2.2 is a bugfix/patch release that expands functionality with some edge
+cases, and fixes a couple of bugs. Thank you to the new contributors:
+Judson Lester, John Bachir, and @bethesque!
+
+* Added Date header to responses, it's mandatory.
+* Updated RSpec options to never load DRb, since it breaks the test suite.
+* Updated FSM to respond with 404 if no route matches.
+* Added support for key-only extensions in content negotiation.
+* Improved the README file.
+* Fixed insignificance of `handle_exception` callback's return value.
+* Fixed CI setup with regards to Rubinius and JRuby.
+* Several smaller code cleanups.
+
+### 1.2.1 September 28, 2013
+
+1.2.1 is a bugfix/patch release but does introduce potentially
+breaking changes in the Reel adapter. With this release, Webmachine no
+longer explicitly supports Ruby 1.8.
+
+* Updated Reel compatibility to 0.4.
+* Updated Hatetepe compatibility to 0.5.2.
+* Cleaned up the gemspec so bundler scripts are not included.
+* Added license information to the gemspec.
+* Added a link to jruby-http-kit in the README.
+* Moved adapter_lint to lib/webmachine/spec so other libraries can
+  test adapters that are not in the Webmachine gem.
+
+### 1.2.0 September 7, 2013
+
+1.2.0 is a major feature release that adds the Events instrumentation
+framework, support for Websockets in Reel adapter and a bunch of bugfixes.
+Added Justin McPherson and Hendrik Beskow as contributors. Thank you
+for your contributions!
+
+* Websockets support in Reel adapter.
+* Added `Events` framework implementing ActiveSupport::Notifications
+  instrumentation API.
+* Linked mailing list and related library in README.
+* Fixed operator precedence in `IOEncoder#each`.
+* Fixed typo in Max-Age cookie attribute.
+* Allowed attributes to be set in a `Cookie`.
+* Fixed streaming in Rack adapter from Fiber that is expected
+  to block
+* Added a more comprehensive adapter test suite and fixed various bugs
+  in the existing adapters.
+* Webmachine::LazyRequestBody no longer double-buffers the request
+  body and cannot be rewound.
+
+### 1.1.0 January 12, 2013
+
+1.1.0 is a major feature release that adds the Reel and Hatetepe
+adapters, support for "weak" entity tags, streaming IO response
+bodies, better error handling, a shortcut for spinning up specific
+resources, and a bunch of bugfixes. Added Tony Arcieri, Sebastian
+Edwards, Russell Garner, Justin McPherson, Paweł Pacana, and Nicholas
+Young as contributors. Thank you for your contributions!
+
+* Added Reel adapter.
+* The trace resource now opens static files in binary mode to ensure
+  compatibility on Windows.
+* The trace resource uses absolute URIs for its traces.
+* Added Hatetepe adapter.
+* Added direct weak entity tag support.
+* Related libraries are linked from the README.
+* Removed some circular requires.
+* Fixed documentation for the `valid_content_headers?` callback.
+* Fixed `Headers` initialization by downcasing incoming header names.
+* Added a `Headers#fetch` method.
+* Conventionally "truthy" and "falsey" values (non-nil, non-false) can
+  now be returned from callbacks that expect a boolean return value.
+* Updated to the latest RSpec.
+* Added support for IO response bodies (minimal).
+* Moved streaming encoders to their own module for clarity.
+* Added `Resource#run` that starts up a web server with default
+  configuration options and the catch-all route to the resource.
+* The exception handling flow was improved, clarifying the
+  `handle_exception` and `finish_request` callbacks.
+* Fix incompatibilities with Rack.
+* The request URI will not be initialized with parts that are not
+  present in the HTTP request.
+* The tracing will now commit to storage after the response has been
+  traced.
+
+### 1.0.0 July 7, 2012
+
+1.0.0 is a major feature release that finally includes the visual
+debugger, some nice cookie support, and some new extension
+points. Added Peter Johanson and Armin Joellenbeck as
+contributors. Thank you for your contributions!
+
+* A cookie parsing and manipulation API was added.
+* Conneg headers now accept any amount of whitespace around commas,
+  including none.
+* `Callbacks#handle_exception` was added so that resources can handle
+  exceptions that they generate and produce more friendly responses.
+* Chunked and non-chunked response bodies in the Rack adapter were
+  fixed.
+* The WEBrick example was updated to use the new API.
+* `Dispatcher` was refactored so that you can modify how resources
+  are initialized before dispatching occurs.
+* `Route` now includes the `Translation` module so that exception
+  messages are properly rendered.
+* The visual debugger was added (more details in the README).
+* The `Content-Length` header will always be set inside Webmachine and
+  is no longer reliant on the adapter to set it.
+
+### 0.4.2 March 22, 2012
+
+0.4.2 is a bugfix release that corrects a few minor issues. Added Lars
+Gierth and Rob Gleeson as contributors. Thank you for your
+contributions!
+
+* I always intended for Webmachine-Ruby to be Apache licensed, but now
+  that is explicit.
+* When the `#process_post` callback returns an invalid value, that
+  will now be `inspect`ed in the raised exception's message.
+* Route bindings are now applied to the `Request` object before the
+  `Resource` class is instantiated. This means you can inspect them
+  inside the `#initialize` method of your resource.
+* Some `NameError` exceptions and scope problems in the Mongrel
+  adapter were resolved.
+* URL-encoded `=` characters in the query string decoded in the proper
+  order.
+
+### 0.4.1 February 8, 2012
+
+0.4.1 is a bugfix release that corrects a few minor issues. Added Sam
+Goldman as a contributor. Thank you for your contributions!
+
+* Updated README with `Webmachine::Application` examples.
+* The CGI env vars `CONTENT_LENGTH` and `CONTENT_TYPE` are now being
+  correctly converted into their Webmachine equivalents.
+* The request body given via the Rack and Mongrel adapters now
+  responds to `#to_s` and `#each` so it can be treated like a `String`
+  or `Enumerable` that yields chunks.
+
+### 0.4.0 February 5, 2012
+
+0.4.0 includes some important refactorings, isolating the idea of
+global state into an Application object with its own Dispatcher and
+configuration, and making Adapters into real classes with a consistent
+interface. It also adds some query methods on the Request object for
+the HTTP method and scheme and Route guards (matching predicates).
+Added Michael Maltese, Emmanuel Gomez, and Bernerd Schaefer as
+committers. Thank you for your contributions!
+
+* Fixed `Request#query` to handle nil values for the URI query accessor.
+* `Webmachine::Dispatcher` is a real class rather than a module with
+  state.
+* `Webmachine::Application` is a class that includes its own
+  dispatcher and configuration. The default instance is accessible via
+  `Webmachine.application`.
+* `Webmachine::Adapter` is now the superclass of all implemented
+  adapters so that they have a uniform interface.
+* The Mongrel spec is skipped on JRuby since version 1.2 (pre-release)
+  doesn't work. Direct Mongrel support may be removed in a later
+  release.
+* `Webmachine::Dispatcher::Route` now accepts guards, which may be
+  expressed as lambdas/procs or any object responding to `call`
+  preceding the `Resource` class in the route definition, or as a
+  trailing block. All guards will be passed the `Request` object when
+  matching the route and should return a truthy or falsey value
+  (without side-effects).
+
+### 0.3.0 November 9, 2011
+
+0.3.0 introduces some new features, refactorings, and now has 100%
+documentation coverage! Among the new features are minimal Rack
+compatibility, streaming responses via Fibers and a friendlier route
+definition syntax. Added Jamis Buck as a committer. Thank you for your
+contributions!
+
+* Chunked bodies are now wrapped in a way that works on webservers
+  that don't automatically produce them.
+* HTTP Basic Authentication is easy to add to resources, just include
+  `Webmachine::Resource::Authentication`.
+* Routes are a little less painful to add, you can now specify them
+  with `Webmachine.routes` which will be evaled into the `Dispatcher`.
+* The new default port is 8080.
+* Rack is minimally supported as a host server. _Don't put middleware
+  above Webmachine!_
+* Fibers can be used as streamed response bodies.
+* `Dispatcher#add_route` will now return the added `Route` instance.
+* The header-conversion code for CGI-style servers has been extracted
+  into `Webmachine::Headers`.
+* `Route#path_spec` is now public so that applications can inspect
+  existing routes, perhaps for URL generation.
+* `Request#query` now uses `CGI.unescape` so '+' characters are
+  correctly parsed.
+* YARD documentation has 100% coverage.
+
+### 0.2.0 September 11, 2011
+
+0.2.0 includes an adapter for Mongrel and a central place for
+configuration as well as numerous bugfixes. Added Ian Plosker and
+Bernd Ahlers as committers. Thank you for your contributions!
+
+* Acceptable media types are matched less strictly, which has
+  implications on both responses and PUT requests. See the
+  [discussion on the commit](https://github.com/seancribbs/webmachine-ruby/commit/3686d0d9ff77fc98aff59f89478e9c6c18844ca1).
+* Resources now receive a callback after the language has been
+  negotiated, so they can decide what to do with it.
+* Added `Webmachine::Configuration` so we can more easily support more
+  than one host server/adapter.
+* Added Mongrel adapter, supporting 1.2pre+.
+* Media type headers are more lax about whitespace following
+  semicolons.
+* Fix some problems with callable response bodies.
+* Make sure String response bodies get a Content-Length header added
+  and streaming responses get chunked encoding.
+* Numerous refactorings, including extracting `MediaType` into its own
+  top-level class.
+
+### 0.1.0 August 25, 2011
+
+This is the initial release. Most things work, but only WEBrick is supported.

data/Gemfile

@@ -8,12 +8,8 @@ gem 'bundler'
 
 group :webservers do
   gem 'mongrel',  '~> 1.2.beta', :platform => [:mri, :rbx]
-
-  if RUBY_VERSION >= '1.9'
-    gem 'reel', '~> 0.3.0', :platform => [:ruby_19, :ruby_20, :jruby]
-  end
-
-  gem 'hatetepe', '~> 0.5'
+  gem 'reel', '~> 0.4.0.pre5'
+  gem 'hatetepe', '~> 0.5.2'
 end
 
 group :guard do
@@ -38,3 +34,8 @@ end
 platforms :jruby do
   gem 'jruby-openssl'
 end
+
+platform :rbx do
+  gem 'rubysl'
+  gem 'racc'
+end

data/README.md

@@ -1,4 +1,4 @@
-# webmachine for Ruby [![travis](https://secure.travis-ci.org/seancribbs/webmachine-ruby.png)](http://travis-ci.org/seancribbs/webmachine-ruby)
+# webmachine for Ruby [![travis](https://travis-ci.org/seancribbs/webmachine-ruby.png?branch=master)](http://travis-ci.org/seancribbs/webmachine-ruby)
 
 webmachine-ruby is a port of
 [Webmachine](https://github.com/basho/webmachine), which is written in
@@ -11,97 +11,118 @@ toolkit for building HTTP-friendly applications. For example, it does
 not provide a templating engine or a persistence layer; those choices
 are up to you.
 
+## Features
+
+* Handles the hard parts of content negotiation, conditional
+  requests, and response codes for you.
+* Most callbacks can interrupt the decision flow by returning an
+  integer response code. You generally only want to do this when new
+  information comes to light, requiring a modification of the response.
+* Supports WEBrick and Mongrel (1.2pre+), and a Rack shim. Other host
+  servers are being investigated.
+* Streaming/chunked response bodies are permitted as Enumerables,
+  Procs, or Fibers!
+* Unlike the Erlang original, it does real Language negotiation.
+* Includes the visual debugger so you can look through the decision
+  graph to determine how your resources are behaving.
+
+## Documentation & Finding Help
+
+* [API documentation](http://rubydoc.info/gems/webmachine/frames/file/README.md)
+* [Mailing list](mailto:webmachine.rb@librelist.com)
+* IRC channel #webmachine on freenode
+
 ## A Note about Rack
 
-Webmachine has a Rack adapter -- thanks to Jamis Buck -- but when
-using it, we recommend you ensure that NO middleware is used.  The
-behaviors that are encapsulated in Webmachine could be broken by
-middlewares that sit above it, and there is no way to detect them at
-runtime. _Caveat implementor_. That said, Webmachine should behave properly
-when given a clear stack.
+In order to be compatible with popular deployment stacks,
+Webmachine has a [Rack](https://github.com/rack/rack) adapter (thanks to Jamis Buck).
+**n.b.:** We recommend that NO middleware is used. The
+behaviors that are encapsulated in Webmachine assume that no modifications
+are done to requests or response outside of Webmachine.
 
-## Getting Started
+## A Note about MRI 1.9
 
-Webmachine is very young, but it's still easy to construct an
-application for it!
+The [Reel](https://github.com/celluloid/reel) and [Hatetepe](https://github.com/lgierth/hatetepe)
+adapters might crash with a `SystemStackError` on MRI 1.9 due to its
+limited fiber stack size. If your application is affected by this, the
+only known solution is to switch to JRuby, Rubinius or MRI 2.0.
 
-```ruby
-require 'webmachine'
-# Require any of the files that contain your resources here
-require 'my_resource'
 
-# Create an application which encompasses routes and configruation
-MyApp = Webmachine::Application.new do |app|
-  app.routes do
-    # Point all URIs at the MyResource class
-    add ['*'], MyResource
-  end
-end
+## Getting Started
 
-# Start the server, binds to port 8080 using WEBrick
-MyApp.run
-```
+[GiddyUp](https://github.com/basho/giddyup) is an actively
+developed webmachine-ruby app that is in production. You
+can look there for an example of how to write and structure a
+webmachine-ruby app (although it is hacky in places).
+
+Below we go through some examples of how to do basic things
+with webmachine-ruby.
 
-Your resource will look something like this:
+The first example defines a simple resource that doesn't demo the
+true power of Webmachine but perhaps gives a feel for how a
+Webmachine resource might look. `Webmachine::Resource.run` is available
+to provide for quick prototyping and development. In a real application
+you will want to configure what path a resource is served from.
+See the __Router__ section in the README for more details on how to
+do that.
+
+There are many other HTTP features exposed to a resource through
+{Webmachine::Resource::Callbacks}. A callback can alter the outcome
+of the decision tree Webmachine implements, and the decision tree
+is what makes Webmachine unique and powerful.
 
 ```ruby
+require 'webmachine'
 class MyResource < Webmachine::Resource
   def to_html
     "<html><body>Hello, world!</body></html>"
   end
 end
+
+# Start a web server to serve requests via localhost
+MyResource.run
 ```
 
-Run the first file and your application is up. That's all there is to
-it! If you want to customize your resource more, look at the available
-callbacks in lib/webmachine/resource/callbacks.rb. For example, you
-might want to enable "gzip" compression on your resource, for which
-you can simply add an `encodings_provided` callback method:
+### Router
 
-```ruby
-class MyResource < Webmachine::Resource
-  def encodings_provided
-    {"gzip" => :encode_gzip, "identity" => :encode_identity}
-  end
+The router is used to map a resource to a given path. To map the class `MyResource` to
+the path `/myresource` you would write something along the lines of:
 
-  def to_html
-    "<html><body>Hello, world!</body></html>"
-  end
+```ruby
+Webmachine.application.routes do
+  add ['myresource'], MyResource
 end
-```
 
-There are many other HTTP features exposed to your resource through
-{Webmachine::Resource::Callbacks}. Give them a try!
+# Start a web server to serve requests via localhost
+Webmachine.application.run
+```
 
 ### Application/Configurator
 
-There's a configurator that allows you to set the ip address and port
-bindings as well as a different webserver adapter.  You can also add
-your routes in a block (as shown above). Both of these call return the
-`Webmachine::Application` instance, so you could chain them if you
-like. If you don't want to create your own separate application
-object, `Webmachine.application` will return a global one.
+There's a configurator that allows you to set what IP address and port
+a web server should bind to as well as what web server should serve a
+webmachine resource.
+
+A call to `Webmachine::Application#configure` returns a `Webmachine::Application` instance,
+so you could chain other method calls if you like. If you don't want to create your own separate
+application object `Webmachine.application` will return a global one.
 
 ```ruby
 require 'webmachine'
 require 'my_resource'
 
-Webmachine.application.routes do
-  add ['*'], MyResource
-end
-
 Webmachine.application.configure do |config|
   config.ip = '127.0.0.1'
   config.port = 3000
   config.adapter = :Mongrel
 end
 
-# Start the server.
+# Start a web server to serve requests via localhost
 Webmachine.application.run
 ```
 
 Webmachine includes adapters for [Webrick][webrick], [Mongrel][mongrel],
-[Reel][reel], and [Hatetepe]. Additionally, the [Rack][rack] adapter lets it
+[Reel][reel], and [Hatetepe][hatetepe]. Additionally, the [Rack][rack] adapter lets it
 run on any webserver that provides a Rack interface. It also lets it run on
 [Shotgun][shotgun] ([example][shotgun_example]).
 
@@ -151,37 +172,9 @@ can use to lookup the trace. It might look something like this:
 ![preview calls at decision](http://seancribbs-skitch.s3.amazonaws.com/Webmachine_Trace_2156885920-20120625-100153.png)
 
 Refer to
-[examples/debugger.rb](/seancribbs/webmachine-ruby/blob/master/examples/debugger.rb)
+[examples/debugger.rb](/examples/debugger.rb)
 for an example of how to enable the debugger.
 
-## Features
-
-* Handles the hard parts of content negotiation, conditional
-  requests, and response codes for you.
-* Most callbacks can interrupt the decision flow by returning an
-  integer response code. You generally only want to do this when new
-  information comes to light, requiring a modification of the response.
-* Supports WEBrick and Mongrel (1.2pre+), and a Rack shim. Other host
-  servers are being investigated.
-* Streaming/chunked response bodies are permitted as Enumerables,
-  Procs, or Fibers!
-* Unlike the Erlang original, it does real Language negotiation.
-* Includes the visual debugger so you can look through the decision
-  graph to determine how your resources are behaving.
-
-## Caveats
-
-* The [Reel](https://github.com/celluloid/reel) adapter might fail with a
-  `SystemStackError` on MRI (< 2.0) due to its limited fiber stack size.
-  The only known solution is to switch to JRuby, Rubinius or MRI 2.0.
-
-
-## Documentation & Finding Help
-
-* [API documentation](http://rubydoc.info/gems/webmachine/frames/file/README.md)
-* [Mailing list](mailto:webmachine.rb@librelist.com)
-* IRC channel #webmachine on freenode
-
 ## Related libraries
 
 * [irwebmachine](https://github.com/robgleeson/irwebmachine) - IRB/Pry debugging of Webmachine applications
@@ -189,6 +182,7 @@ for an example of how to enable the debugger.
 * [webmachine-linking](https://github.com/petejohanson/webmachine-linking) - Helpers for linking between Resources, and Web Linking
 * [webmachine-sprockets](https://github.com/lgierth/webmachine-sprockets) - Integration with Sprockets assets packaging system
 * [webmachine-actionview](https://github.com/rgarner/webmachine-actionview) - Integration of some Rails-style view conventions into Webmachine
+* [jruby-http-kit](https://github.com/nLight/jruby-http-kit) - Includes an adapter for the Clojure-based Ring library/server
 
 ## LICENSE
 
@@ -196,194 +190,3 @@ webmachine-ruby is licensed under the
 [Apache v2.0 license](http://www.apache.org/licenses/LICENSE-2.0). See
 LICENSE for details.
 
-## Changelog
-
-### 1.2.0
-
-1.2.0 is a major feature release that adds the Events instrumentation
-framework, support for Websockets in Reel adapter and a bunch of bugfixes.
-Added Justin McPherson and Hendrik Beskow as contributors. Thank you
-for your contributions!
-
-* Websockets support in Reel adapter.
-* Added `Events` framework implementing ActiveSupport::Notifications
-  instrumentation API.
-* Linked mailing list and related library in README.
-* Fixed operator precedence in `IOEncoder#each`.
-* Fixed typo in Max-Age cookie attribute.
-* Allowed attributes to be set in a `Cookie`.
-* Fixed streaming in Rack adapter from Fiber that is expected
-  to block
-* Added a more comprehensive adapter test suite and fixed various bugs
-  in the existing adapters.
-* Webmachine::LazyRequestBody no longer double-buffers the request
-  body and cannot be rewound.
-
-### 1.1.0 January 12, 2013
-
-1.1.0 is a major feature release that adds the Reel and Hatetepe
-adapters, support for "weak" entity tags, streaming IO response
-bodies, better error handling, a shortcut for spinning up specific
-resources, and a bunch of bugfixes. Added Tony Arcieri, Sebastian
-Edwards, Russell Garner, Justin McPherson, Paweł Pacana, and Nicholas
-Young as contributors. Thank you for your contributions!
-
-* Added Reel adapter.
-* The trace resource now opens static files in binary mode to ensure
-  compatibility on Windows.
-* The trace resource uses absolute URIs for its traces.
-* Added Hatetepe adapter.
-* Added direct weak entity tag support.
-* Related libraries are linked from the README.
-* Removed some circular requires.
-* Fixed documentation for the `valid_content_headers?` callback.
-* Fixed `Headers` initialization by downcasing incoming header names.
-* Added a `Headers#fetch` method.
-* Conventionally "truthy" and "falsey" values (non-nil, non-false) can
-  now be returned from callbacks that expect a boolean return value.
-* Updated to the latest RSpec.
-* Added support for IO response bodies (minimal).
-* Moved streaming encoders to their own module for clarity.
-* Added `Resource#run` that starts up a web server with default
-  configuration options and the catch-all route to the resource.
-* The exception handling flow was improved, clarifying the
-  `handle_exception` and `finish_request` callbacks.
-* Fix incompatibilities with Rack.
-* The request URI will not be initialized with parts that are not
-  present in the HTTP request.
-* The tracing will now commit to storage after the response has been
-  traced.
-
-### 1.0.0 July 7, 2012
-
-1.0.0 is a major feature release that finally includes the visual
-debugger, some nice cookie support, and some new extension
-points. Added Peter Johanson and Armin Joellenbeck as
-contributors. Thank you for your contributions!
-
-* A cookie parsing and manipulation API was added.
-* Conneg headers now accept any amount of whitespace around commas,
-  including none.
-* `Callbacks#handle_exception` was added so that resources can handle
-  exceptions that they generate and produce more friendly responses.
-* Chunked and non-chunked response bodies in the Rack adapter were
-  fixed.
-* The WEBrick example was updated to use the new API.
-* `Dispatcher` was refactored so that you can modify how resources
-  are initialized before dispatching occurs.
-* `Route` now includes the `Translation` module so that exception
-  messages are properly rendered.
-* The visual debugger was added (more details in the README).
-* The `Content-Length` header will always be set inside Webmachine and
-  is no longer reliant on the adapter to set it.
-
-### 0.4.2 March 22, 2012
-
-0.4.2 is a bugfix release that corrects a few minor issues. Added Lars
-Gierth and Rob Gleeson as contributors. Thank you for your
-contributions!
-
-* I always intended for Webmachine-Ruby to be Apache licensed, but now
-  that is explicit.
-* When the `#process_post` callback returns an invalid value, that
-  will now be `inspect`ed in the raised exception's message.
-* Route bindings are now applied to the `Request` object before the
-  `Resource` class is instantiated. This means you can inspect them
-  inside the `#initialize` method of your resource.
-* Some `NameError` exceptions and scope problems in the Mongrel
-  adapter were resolved.
-* URL-encoded `=` characters in the query string decoded in the proper
-  order.
-
-### 0.4.1 February 8, 2012
-
-0.4.1 is a bugfix release that corrects a few minor issues. Added Sam
-Goldman as a contributor. Thank you for your contributions!
-
-* Updated README with `Webmachine::Application` examples.
-* The CGI env vars `CONTENT_LENGTH` and `CONTENT_TYPE` are now being
-  correctly converted into their Webmachine equivalents.
-* The request body given via the Rack and Mongrel adapters now
-  responds to `#to_s` and `#each` so it can be treated like a `String`
-  or `Enumerable` that yields chunks.
-
-### 0.4.0 February 5, 2012
-
-0.4.0 includes some important refactorings, isolating the idea of
-global state into an Application object with its own Dispatcher and
-configuration, and making Adapters into real classes with a consistent
-interface. It also adds some query methods on the Request object for
-the HTTP method and scheme and Route guards (matching predicates).
-Added Michael Maltese, Emmanuel Gomez, and Bernerd Schaefer as
-committers. Thank you for your contributions!
-
-* Fixed `Request#query` to handle nil values for the URI query accessor.
-* `Webmachine::Dispatcher` is a real class rather than a module with
-  state.
-* `Webmachine::Application` is a class that includes its own
-  dispatcher and configuration. The default instance is accessible via
-  `Webmachine.application`.
-* `Webmachine::Adapter` is now the superclass of all implemented
-  adapters so that they have a uniform interface.
-* The Mongrel spec is skipped on JRuby since version 1.2 (pre-release)
-  doesn't work. Direct Mongrel support may be removed in a later
-  release.
-* `Webmachine::Dispatcher::Route` now accepts guards, which may be
-  expressed as lambdas/procs or any object responding to `call`
-  preceding the `Resource` class in the route definition, or as a
-  trailing block. All guards will be passed the `Request` object when
-  matching the route and should return a truthy or falsey value
-  (without side-effects).
-
-### 0.3.0 November 9, 2011
-
-0.3.0 introduces some new features, refactorings, and now has 100%
-documentation coverage! Among the new features are minimal Rack
-compatibility, streaming responses via Fibers and a friendlier route
-definition syntax. Added Jamis Buck as a committer. Thank you for your
-contributions!
-
-* Chunked bodies are now wrapped in a way that works on webservers
-  that don't automatically produce them.
-* HTTP Basic Authentication is easy to add to resources, just include
-  `Webmachine::Resource::Authentication`.
-* Routes are a little less painful to add, you can now specify them
-  with `Webmachine.routes` which will be evaled into the `Dispatcher`.
-* The new default port is 8080.
-* Rack is minimally supported as a host server. _Don't put middleware
-  above Webmachine!_
-* Fibers can be used as streamed response bodies.
-* `Dispatcher#add_route` will now return the added `Route` instance.
-* The header-conversion code for CGI-style servers has been extracted
-  into `Webmachine::Headers`.
-* `Route#path_spec` is now public so that applications can inspect
-  existing routes, perhaps for URL generation.
-* `Request#query` now uses `CGI.unescape` so '+' characters are
-  correctly parsed.
-* YARD documentation has 100% coverage.
-
-### 0.2.0 September 11, 2011
-
-0.2.0 includes an adapter for Mongrel and a central place for
-configuration as well as numerous bugfixes. Added Ian Plosker and
-Bernd Ahlers as committers. Thank you for your contributions!
-
-* Acceptable media types are matched less strictly, which has
-  implications on both responses and PUT requests. See the
-  [discussion on the commit](https://github.com/seancribbs/webmachine-ruby/commit/3686d0d9ff77fc98aff59f89478e9c6c18844ca1).
-* Resources now receive a callback after the language has been
-  negotiated, so they can decide what to do with it.
-* Added `Webmachine::Configuration` so we can more easily support more
-  than one host server/adapter.
-* Added Mongrel adapter, supporting 1.2pre+.
-* Media type headers are more lax about whitespace following
-  semicolons.
-* Fix some problems with callable response bodies.
-* Make sure String response bodies get a Content-Length header added
-  and streaming responses get chunked encoding.
-* Numerous refactorings, including extracting `MediaType` into its own
-  top-level class.
-
-### 0.1.0 August 25, 2011
-
-This is the initial release. Most things work, but only WEBrick is supported.

data/lib/webmachine/adapters/reel.rb

@@ -4,17 +4,19 @@ require 'webmachine/headers'
 require 'webmachine/request'
 require 'webmachine/response'
 require 'webmachine/dispatcher'
-require 'webmachine/adapters/lazy_request_body'
 require 'set'
 
 module Webmachine
   module Adapters
     class Reel < Adapter
+      # Used to override default Reel server options (useful in testing)
+      DEFAULT_OPTIONS = {}
+      
       def run
-        @options = {
+        @options = DEFAULT_OPTIONS.merge({
           :port => configuration.port,
           :host => configuration.ip
-        }.merge(configuration.adapter_options)
+        }).merge(configuration.adapter_options)
 
         if extra_verbs = configuration.adapter_options[:extra_verbs]
           @extra_verbs = Set.new(extra_verbs.map(&:to_s).map(&:upcase))
@@ -34,11 +36,11 @@ module Webmachine
       end
 
       def process(connection)
-        while request = connection.request
+        connection.each_request do |request|
           # Users of the adapter can configure a custom WebSocket handler
-          if request.is_a? ::Reel::WebSocket
+          if request.websocket?
             if handler = @options[:websocket_handler]
-              handler.call(request)
+              handler.call(request.websocket)
             else
               # Pretend we don't know anything about the WebSocket protocol
               # FIXME: This isn't strictly what RFC 6455 would have us do
@@ -61,8 +63,7 @@ module Webmachine
           end
 
           wm_headers  = Webmachine::Headers[request.headers.dup]
-          wm_request  = Webmachine::Request.new(method, uri, wm_headers,
-                                                LazyRequestBody.new(request))
+          wm_request  = Webmachine::Request.new(method, uri, wm_headers, request.body)
           wm_response = Webmachine::Response.new
           @dispatcher.dispatch(wm_request, wm_response)
 

data/lib/webmachine/decision/flow.rb

@@ -14,7 +14,7 @@ module Webmachine
     #
     # This module is included into {FSM}, which drives the processing
     # of the chart.
-    # @see http://webmachine.basho.com/images/http-headers-status-v3.png
+    # @see https://raw.github.com/wiki/basho/webmachine/images/http-headers-status-v3.png
     module Flow
       # Version of the flow diagram
       VERSION = 3

data/lib/webmachine/decision/fsm.rb

@@ -49,8 +49,8 @@ module Webmachine
         Webmachine.render_error(400, request, response, :message => e.message)
         400
       rescue Exception => e
-        code = resource.handle_exception(e)
-        (100...600).include?(code) ? (code) : (500)
+        resource.handle_exception(e)
+        500
       end
 
       def respond(code, headers={})
@@ -70,6 +70,7 @@ module Webmachine
         end
 
         ensure_content_length
+        ensure_date_header
       end
 
       # When tracing is disabled, this does nothing.

data/lib/webmachine/decision/helpers.rb

@@ -1,4 +1,5 @@
 require 'stringio'
+require 'time'
 require 'webmachine/streaming'
 require 'webmachine/media_type'
 require 'webmachine/quoted_string'
@@ -102,6 +103,13 @@ module Webmachine
         end
       end
 
+      # Ensures that responses have an appropriate Date header
+      def ensure_date_header
+        if (200..499).include?(response.code)
+          response.headers['Date'] ||= Time.now.httpdate
+        end
+      end
+
       # Sets the Content-Length header on the response
       def set_content_length
         if response.body.respond_to?(:bytesize)

data/lib/webmachine/dispatcher.rb

@@ -1,6 +1,7 @@
 require 'forwardable'
 require 'webmachine/decision'
 require 'webmachine/dispatcher/route'
+require 'webmachine/dispatcher/not_found_resource'
 
 module Webmachine
   # Handles dispatching incoming requests to the proper registered
@@ -39,16 +40,12 @@ module Webmachine
     # @param [Request] request the request object
     # @param [Response] response the response object
     def dispatch(request, response)
-      if resource = find_resource(request, response)
-        Webmachine::Events.instrument('wm.dispatch') do |payload|
-          Webmachine::Decision::FSM.new(resource, request, response).run
-
-          payload[:resource] = resource.class.name
-          payload[:request] = request.dup
-          payload[:code] = response.code
-        end
-      else
-        Webmachine.render_error(404, request, response)
+      resource = find_resource(request, response)
+      Webmachine::Events.instrument('wm.dispatch') do |payload|
+        Webmachine::Decision::FSM.new(resource, request, response).run
+        payload[:resource] = resource.class.name
+        payload[:request] = request.dup
+        payload[:code] = response.code
       end
     end
 
@@ -64,6 +61,8 @@ module Webmachine
     def find_resource(request, response)
       if route = find_route(request)
         prepare_resource(route, request, response)
+      else
+        NotFoundResource.new(request, response)
       end
     end
 

data/lib/webmachine/dispatcher/not_found_resource.rb

@@ -0,0 +1,5 @@
+class Webmachine::Dispatcher::NotFoundResource < Webmachine::Resource
+  def resource_exists?
+    false
+  end
+end

data/lib/webmachine/media_type.rb

@@ -8,7 +8,7 @@ module Webmachine
     MEDIA_TYPE_REGEX = /^\s*([^;\s]+)\s*((?:;\s*\S+\s*)*)\s*$/
 
     # Matches sub-type parameters
-    PARAMS_REGEX = /;\s*([^=]+)=([^;=\s]+)/
+    PARAMS_REGEX = /;\s*([^=]+)(=([^;=\s]*))?/
 
     # Creates a new MediaType by parsing an alternate representation.
     # @param [MediaType, String, Array<String,Hash>] obj the raw type
@@ -21,7 +21,7 @@ module Webmachine
         obj
       when MEDIA_TYPE_REGEX
         type, raw_params = $1, $2
-        params = Hash[raw_params.scan(PARAMS_REGEX)]
+        params = Hash[raw_params.scan(PARAMS_REGEX).map { |m| [m[0], m[2].to_s] }]
         new(type, params)
       else
         unless Array === obj && String === obj[0] && Hash === obj[1]

data/{spec/support → lib/webmachine/spec}/adapter_lint.rb

@@ -1,4 +1,4 @@
-require "support/test_resource"
+require "webmachine/spec/test_resource"
 require "net/http"
 
 shared_examples_for :adapter_lint do

data/lib/webmachine/version.rb

@@ -1,6 +1,6 @@
 module Webmachine
   # Library version
-  VERSION = "1.2.0"
+  VERSION = "1.2.2"
 
   # String for use in "Server" HTTP response header, which includes
   # the {VERSION}.

data/spec/webmachine/adapters/hatetepe_spec.rb

@@ -58,7 +58,3 @@ examples = proc do
     enum.to_enum.to_a.join
   end
 end
-
-if RUBY_VERSION >= "1.9"
-  describe Webmachine::Adapters::Hatetepe, &examples
-end

data/spec/webmachine/adapters/mongrel_spec.rb

@@ -1,5 +1,5 @@
 require "spec_helper"
-require "support/adapter_lint"
+require "webmachine/spec/adapter_lint"
 
 begin
   describe Webmachine::Adapters::Mongrel do

data/spec/webmachine/adapters/rack_spec.rb

@@ -1,7 +1,7 @@
 require 'webmachine/adapter'
 require 'webmachine/adapters/rack'
 require 'spec_helper'
-require 'support/adapter_lint'
+require 'webmachine/spec/adapter_lint'
 
 describe Webmachine::Adapters::Rack do
   it_should_behave_like :adapter_lint do

data/spec/webmachine/adapters/reel_spec.rb

@@ -1,75 +1,72 @@
 require 'spec_helper'
-require 'support/adapter_lint'
+require 'webmachine/spec/adapter_lint'
+describe Webmachine::Adapters::Reel do
+  it_should_behave_like :adapter_lint
 
-if RUBY_VERSION >= "1.9"
-  describe Webmachine::Adapters::Reel do
-    it_should_behave_like :adapter_lint
+  let(:configuration) { Webmachine::Configuration.default }
+  let(:dispatcher) { Webmachine::Dispatcher.new }
+  let(:adapter) do
+    described_class.new(configuration, dispatcher)
+  end
 
-    let(:configuration) { Webmachine::Configuration.default }
-    let(:dispatcher) { Webmachine::Dispatcher.new }
-    let(:adapter) do
-      described_class.new(configuration, dispatcher)
+  context 'websockets' do
+    let(:example_host)    { "www.example.com" }
+    let(:example_path)    { "/example"}
+    let(:example_url)     { "ws://#{example_host}#{example_path}" }
+    let :handshake_headers do
+      {
+        "Host"                   => example_host,
+        "Upgrade"                => "websocket",
+        "Connection"             => "Upgrade",
+        "Sec-WebSocket-Key"      => "dGhlIHNhbXBsZSBub25jZQ==",
+        "Origin"                 => "http://example.com",
+        "Sec-WebSocket-Protocol" => "chat, superchat",
+        "Sec-WebSocket-Version"  => "13"
+      }
     end
+    let(:client_message) { "Hi server!" }
+    let(:server_message) { "Hi client!" }
 
-    context 'websockets' do
-      let(:example_host)    { "www.example.com" }
-      let(:example_path)    { "/example"}
-      let(:example_url)     { "ws://#{example_host}#{example_path}" }
-      let :handshake_headers do
-        {
-          "Host"                   => example_host,
-          "Upgrade"                => "websocket",
-          "Connection"             => "Upgrade",
-          "Sec-WebSocket-Key"      => "dGhlIHNhbXBsZSBub25jZQ==",
-          "Origin"                 => "http://example.com",
-          "Sec-WebSocket-Protocol" => "chat, superchat",
-          "Sec-WebSocket-Version"  => "13"
-        }
+    it 'supports websockets' do
+      configuration.adapter_options[:websocket_handler] = proc do |socket|
+        socket.read.should eq client_message
+        socket << server_message
       end
-      let(:client_message) { "Hi server!" }
-      let(:server_message) { "Hi client!" }
-
-      it 'supports websockets' do
-        configuration.adapter_options[:websocket_handler] = proc do |socket|
-          socket.read.should eq client_message
-          socket << server_message
-        end
 
-        reel_server(adapter) do |client|
-          client << WebSocket::ClientHandshake.new(:get, example_url, handshake_headers).to_data
+      reel_server(adapter) do |client|
+        client << WebSocket::ClientHandshake.new(:get, example_url, handshake_headers).to_data
 
-          # Discard handshake response
-          # FIXME: hax
-          client.readpartial(4096)
+        # Discard handshake response
+        # FIXME: hax
+        client.readpartial(4096)
 
-          client << WebSocket::Message.new(client_message).to_data
-          parser = WebSocket::Parser.new
-          parser.append client.readpartial(4096) until message = parser.next_message
+        client << WebSocket::Message.new(client_message).to_data
+        parser = WebSocket::Parser.new
+        parser.append client.readpartial(4096) until message = parser.next_message
 
-          message.should eq server_message
-        end
+        message.should eq server_message
       end
     end
+  end
 
-    def reel_server(adptr = adapter)
-      thread = Thread.new { adptr.run }
-      begin
-        timeout(5) do
+  def reel_server(adptr = adapter)
+    thread = Thread.new { adptr.run }
+    begin
+      timeout(5) do
+        begin
+          sock = TCPSocket.new(adptr.configuration.ip, adptr.configuration.port)
           begin
-            sock = TCPSocket.new(adptr.configuration.ip, adptr.configuration.port)
-            begin
-              yield(sock)
-            ensure
-              sock.close
-            end
-          rescue Errno::ECONNREFUSED
-            Thread.pass
-            retry
+            yield(sock)
+          ensure
+            sock.close
           end
+        rescue Errno::ECONNREFUSED
+          Thread.pass
+          retry
         end
-      ensure
-        adptr.shutdown
       end
+    ensure
+      adptr.shutdown
     end
   end
 end

data/spec/webmachine/adapters/webrick_spec.rb

@@ -1,5 +1,5 @@
 require "spec_helper"
-require "support/adapter_lint"
+require "webmachine/spec/adapter_lint"
 
 describe Webmachine::Adapters::WEBrick do
   it_should_behave_like :adapter_lint do

data/spec/webmachine/decision/flow_spec.rb

@@ -11,6 +11,15 @@ describe Webmachine::Decision::Flow do
   let(:default_resource) { resource_with }
   let(:missing_resource) { missing_resource_with }
 
+  # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.18:
+  # Origin servers MUST include a Date header field in all responses
+  # ... [except 1xx or 5xx]
+  after(:each) do
+    unless response.code < 200 || response.code >= 500
+      response.headers.should have_key('Date')
+    end
+  end
+
   def resource_with(&block)
     klass = Class.new(Webmachine::Resource) do
       def to_html; "test resource"; end
@@ -944,7 +953,7 @@ describe Webmachine::Decision::Flow do
           true
         end
         def delete_completed?; true; end
-        def allowed_methods; %{GET HEAD PUT POST DELETE}; end
+        def allowed_methods; %W{GET HEAD PUT POST DELETE}; end
         def resource_exists?; @exist; end
         def allow_missing_post?; true; end
         def content_types_accepted; [[request.content_type, :accept_all]]; end
@@ -1067,7 +1076,6 @@ describe Webmachine::Decision::Flow do
         resource_with do
           def handle_exception(e)
             response.body = "error"
-            501
           end
 
           def to_html
@@ -1081,12 +1089,10 @@ describe Webmachine::Decision::Flow do
         response.body.should == "error"
       end
 
-      it "uses the return value as a response code." do
+      it "sets the response code to 500" do
         subject.run
-        response.code.should == 501
+        response.code.should == 500
       end
     end
   end
-
-
 end

data/spec/webmachine/dispatcher_spec.rb

@@ -69,4 +69,11 @@ describe Webmachine::Dispatcher do
     fsm.should_receive(:run)
     dispatcher.dispatch(request, response)
   end
+
+  it "should respond with valid resource missing response for request to non-existing route" do
+    dispatcher.dispatch(request, response)
+    response.code.should     eq(404)
+    response.body.should_not be_empty
+    response.headers.should  have_key('Content-Length')
+  end
 end

data/spec/webmachine/media_type_spec.rb

@@ -47,6 +47,13 @@ describe Webmachine::MediaType do
       type.params.should ==  {"boundary" => "----------------------------2c46a7bec2b9", "charset" => "UTF-8"}
     end
 
+    it "should parse a type/params pair where type has single-token params" do
+      type = described_class.parse(["text/html;q=1;rdfa", {"charset" => "UTF-8"}])
+      type.should be_kind_of(described_class)
+      type.type.should == "text/html"
+      type.params.should == {"q" => "1", "rdfa" => "", "charset" => "UTF-8"}
+    end
+
     it "should raise an error when given an invalid type/params pair" do
       expect {
         described_class.parse([false, "blah"])

data/webmachine.gemspec

@@ -13,6 +13,7 @@ Gem::Specification.new do |gem|
   gem.homepage = "http://github.com/seancribbs/webmachine-ruby"
   gem.authors = ["Sean Cribbs"]
   gem.email = ["sean@basho.com"]
+  gem.license = "Apache 2.0"
 
   gem.add_runtime_dependency(%q<i18n>, [">= 0.4.0"])
   gem.add_runtime_dependency(%q<multi_json>)
@@ -25,6 +26,4 @@ Gem::Specification.new do |gem|
   ignores = File.read(".gitignore").split(/\r?\n/).reject{ |f| f =~ /^(#.+|\s*)$/ }.map {|f| Dir[f] }.flatten
   gem.files = (Dir['**/*','.gitignore'] - ignores).reject {|f| !File.file?(f) }
   gem.test_files = (Dir['spec/**/*','features/**/*','.gitignore'] - ignores).reject {|f| !File.file?(f) }
-  gem.executables   = Dir['bin/*'].map { |f| File.basename(f) }
-  gem.require_paths = ['lib']
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: webmachine
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-07 00:00:00.000000000 Z
+date: 2014-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -129,25 +129,7 @@ description: ! ' webmachine is a toolkit for building HTTP applications in a dec
   its opinionated nature about HTTP. '
 email:
 - sean@basho.com
-executables:
-- autospec
-- coderay
-- gpgen
-- guard
-- hatetepe
-- htmldiff
-- ldiff
-- mongrel_rails
-- pry
-- rackup
-- rake
-- redcarpet
-- reel
-- rspec
-- thor
-- yard
-- yardoc
-- yri
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -169,6 +151,7 @@ files:
 - bin/yard
 - bin/yardoc
 - bin/yri
+- CHANGELOG.md
 - doc/_index.html
 - doc/class_list.html
 - doc/css/common.css
@@ -270,6 +253,7 @@ files:
 - lib/webmachine/decision/fsm.rb
 - lib/webmachine/decision/helpers.rb
 - lib/webmachine/decision.rb
+- lib/webmachine/dispatcher/not_found_resource.rb
 - lib/webmachine/dispatcher/route.rb
 - lib/webmachine/dispatcher.rb
 - lib/webmachine/errors.rb
@@ -289,6 +273,8 @@ files:
 - lib/webmachine/resource/tracing.rb
 - lib/webmachine/resource.rb
 - lib/webmachine/response.rb
+- lib/webmachine/spec/adapter_lint.rb
+- lib/webmachine/spec/test_resource.rb
 - lib/webmachine/streaming/callable_encoder.rb
 - lib/webmachine/streaming/encoder.rb
 - lib/webmachine/streaming/enumerable_encoder.rb
@@ -313,8 +299,6 @@ files:
 - Rakefile
 - README.md
 - spec/spec_helper.rb
-- spec/support/adapter_lint.rb
-- spec/support/test_resource.rb
 - spec/webmachine/adapter_spec.rb
 - spec/webmachine/adapters/hatetepe_spec.rb
 - spec/webmachine/adapters/mongrel_spec.rb
@@ -347,7 +331,8 @@ files:
 - webmachine.gemspec
 - .gitignore
 homepage: http://github.com/seancribbs/webmachine-ruby
-licenses: []
+licenses:
+- Apache 2.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -372,8 +357,6 @@ specification_version: 3
 summary: webmachine is a toolkit for building HTTP applications,
 test_files:
 - spec/spec_helper.rb
-- spec/support/adapter_lint.rb
-- spec/support/test_resource.rb
 - spec/webmachine/adapter_spec.rb
 - spec/webmachine/adapters/hatetepe_spec.rb
 - spec/webmachine/adapters/mongrel_spec.rb