webmachine 1.0.0 → 1.1.0

data/Gemfile

@@ -6,6 +6,15 @@ gemspec
 
 gem 'bundler'
 
+group :webservers do
+  gem 'mongrel',  '~> 1.2.beta', :platform => [:mri, :rbx]
+  if RUBY_VERSION >= '1.9'
+    gem 'reel',   '>= 0.1.0', :platform => [:ruby_19, :jruby]
+    gem 'nio4r'
+  end
+  gem 'hatetepe', '~> 0.5'
+end
+
 group :guard do
   gem 'guard-rspec'
   case RbConfig::CONFIG['host_os']

data/README.md

@@ -100,6 +100,19 @@ end
 Webmachine.application.run
 ```
 
+Webmachine includes adapters for [Webrick][webrick], [Mongrel][mongrel],
+[Reel][reel], and [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]).
+
+[webrick]: http://rubydoc.info/stdlib/webrick
+[mongrel]: https://github.com/evan/mongrel
+[reel]: https://github.com/celluloid/reel
+[hatetepe]: https://github.com/lgierth/hatetepe
+[rack]: https://github.com/rack/rack
+[shotgun]: https://github.com/rtomayko/shotgun
+[shotgun_example]: https://gist.github.com/4389220
+
 ### Visual debugger
 
 It can be hard to understand all of the decisions that Webmachine
@@ -156,9 +169,24 @@ for an example of how to enable the debugger.
 * Includes the visual debugger so you can look through the decision
   graph to determine how your resources are behaving.
 
-## Problems/TODOs
+## 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
 
-* Command-line tools, and general polish.
+* [API documentation](http://rubydoc.info/gems/webmachine/frames/file/README.md)
+* IRC channel #webmachine on freenode
+
+## Related libraries
+
+* [irwebmachine](https://github.com/robgleeson/irwebmachine) - IRB/Pry debugging of Webmachine applications
+* [webmachine-test](https://github.com/bernd/webmachine-test) - Helpers for testing Webmachine applications
+- [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
 
 ## LICENSE
 
@@ -168,6 +196,41 @@ LICENSE for details.
 
 ## Changelog
 
+### 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

data/lib/webmachine.rb

@@ -3,6 +3,7 @@ require 'webmachine/cookie'
 require 'webmachine/headers'
 require 'webmachine/request'
 require 'webmachine/response'
+require 'webmachine/etags'
 require 'webmachine/errors'
 require 'webmachine/decision'
 require 'webmachine/streaming'

data/lib/webmachine/adapters.rb

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

data/lib/webmachine/adapters/hatetepe.rb

@@ -0,0 +1,104 @@
+require 'hatetepe/server'
+
+unless Hatetepe::VERSION >= '0.5.0'
+  raise LoadError, 'webmachine only supports hatetepe >= 0.5.0'
+end
+
+require 'webmachine/version'
+require 'webmachine/headers'
+require 'webmachine/request'
+require 'webmachine/response'
+require 'webmachine/dispatcher'
+require 'webmachine/chunked_body'
+
+module Webmachine
+  module Adapters
+    class Hatetepe < Adapter
+      def options
+        {
+          :host => configuration.ip,
+          :port => configuration.port,
+          :app  => [
+            ::Hatetepe::Server::Pipeline,
+            ::Hatetepe::Server::KeepAlive,
+            method(:call)
+          ]
+        }
+      end
+
+      def run
+        EM.epoll
+        EM.synchrony do
+          ::Hatetepe::Server.start(options)
+          trap("INT") { EM.stop }
+        end
+      end
+
+      def call(request, &respond)
+        response = Webmachine::Response.new
+        dispatcher.dispatch(convert_request(request), response)
+
+        respond.call(convert_response(response))
+      end
+
+      private
+
+      def convert_request(request)
+        args = [
+          request.verb,
+          build_request_uri(request),
+          Webmachine::Headers[request.headers.dup],
+          Body.new(request.body)
+        ]
+        Webmachine::Request.new(*args)
+      end
+
+      def convert_response(response)
+        response.headers["Server"] = [
+          Webmachine::SERVER_STRING,
+          "hatetepe/#{::Hatetepe::VERSION}"
+        ].join(" ")
+
+        args = [
+          response.code.to_i,
+          response.headers,
+          convert_body(response.body)
+        ]
+        ::Hatetepe::Response.new(*args)
+      end
+
+      def convert_body(body)
+        if body.respond_to?(:call)
+          [ body.call ]
+        elsif body.respond_to?(:to_s)
+          [ body.to_s ]
+        else
+          body
+        end
+      end
+
+      def build_request_uri(request)
+        uri = URI.parse(request.uri)
+        uri.scheme = "http"
+
+        host     = request.headers.fetch("Host", "").split(":")
+        uri.host = host[0]      || configuration.ip
+        uri.port = host[1].to_i || configuration.port
+
+        URI.parse(uri.to_s)
+      end
+
+      class Body < Struct.new(:body)
+        def each(&block)
+          body.rewind
+          body.each(&block)
+        end
+
+        def to_s
+          body.rewind
+          body.read.to_s
+        end
+      end
+    end
+  end
+end

data/lib/webmachine/adapters/lazy_request_body.rb

@@ -0,0 +1,32 @@
+
+module Webmachine
+  module Adapters
+    # Wraps a request body so that it can be passed to
+    # {Request} while still lazily evaluating the body.
+    class LazyRequestBody
+      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 Adapters
+end # module Webmachine

data/lib/webmachine/adapters/rack.rb

@@ -74,7 +74,8 @@ module Webmachine
                       end
                     end
 
-        [rack_status, rack_headers, rack_body]
+        rack_res = ::Rack::Response.new(rack_body, rack_status, rack_headers)
+        rack_res.finish
       end
 
       # Wraps the Rack input so it can be treated like a String or

data/lib/webmachine/adapters/reel.rb

@@ -0,0 +1,45 @@
+require 'reel'
+require 'webmachine/version'
+require 'webmachine/headers'
+require 'webmachine/request'
+require 'webmachine/response'
+require 'webmachine/dispatcher'
+require 'webmachine/chunked_body'
+
+module Webmachine
+  module Adapters
+    class Reel < Adapter
+      def run
+        options = {
+          :port => configuration.port,
+          :host => configuration.ip
+        }.merge(configuration.adapter_options)
+        server = ::Reel::Server.supervise(options[:host], options[:port], &method(:process))
+        trap("INT"){ server.terminate; exit 0 }
+        sleep
+      end
+
+      def process(connection)
+        while wreq = connection.request
+          header = Webmachine::Headers[wreq.headers.dup]
+          host_parts = header.fetch('Host').split(':')
+          path_parts = wreq.url.split('?')
+          requri = URI::HTTP.build({}.tap do |h|
+            h[:host] = host_parts.first
+            h[:port] = host_parts.last.to_i if host_parts.length == 2
+            h[:path] = path_parts.first
+            h[:query] = path_parts.last if path_parts.length == 2
+          end)
+          request = Webmachine::Request.new(wreq.method.to_s.upcase,
+                                            requri,
+                                            header,
+                                            LazyRequestBody.new(wreq))
+          response = Webmachine::Response.new
+          @dispatcher.dispatch(request,response)
+
+          connection.respond ::Reel::Response.new(response.code, response.headers, response.body)
+        end
+      end
+    end
+  end
+end

data/lib/webmachine/adapters/webrick.rb

@@ -35,7 +35,7 @@ module Webmachine
           request = Webmachine::Request.new(wreq.request_method,
                                             wreq.request_uri,
                                             header,
-                                            RequestBody.new(wreq))
+                                            LazyRequestBody.new(wreq))
           response = Webmachine::Response.new
           @dispatcher.dispatch(request, response)
           wres.status = response.code.to_i
@@ -61,35 +61,6 @@ module Webmachine
           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/lib/webmachine/decision/falsey.rb

@@ -0,0 +1,10 @@
+module Webmachine
+  module Decision
+    Falsey = Object.new
+
+    def Falsey.===(other)
+      !other
+    end
+  end
+end
+

data/lib/webmachine/decision/flow.rb

@@ -1,7 +1,9 @@
 require 'time'
 require 'digest/md5'
 require 'webmachine/decision/conneg'
+require 'webmachine/decision/falsey'
 require 'webmachine/translation'
+require 'webmachine/etags'
 
 module Webmachine
   module Decision
@@ -27,30 +29,30 @@ module Webmachine
       include Translation
 
       # Handles standard decisions where halting is allowed
-      def decision_test(test, value, iftrue, iffalse)
+      def decision_test(test, iftrue, iffalse)
         case test
-        when value
-          iftrue
         when Fixnum # Allows callbacks to "halt" with a given response code
           test
-        else
+        when Falsey
           iffalse
+        else
+          iftrue
         end
       end
 
       # Service available?
       def b13
-        decision_test(resource.service_available?, true, :b12, 503)
+        decision_test(resource.service_available?, :b12, 503)
       end
 
       # Known method?
       def b12
-        decision_test(resource.known_methods.include?(request.method), true, :b11, 501)
+        decision_test(resource.known_methods.include?(request.method), :b11, 501)
       end
 
       # URI too long?
       def b11
-        decision_test(resource.uri_too_long?(request.uri), true, 414, :b10)
+        decision_test(resource.uri_too_long?(request.uri), 414, :b10)
       end
 
       # Method allowed?
@@ -90,7 +92,7 @@ module Webmachine
 
       # Malformed?
       def b9b
-        decision_test(resource.malformed_request?, true, 400, :b8)
+        decision_test(resource.malformed_request?, 400, :b8)
       end
 
       # Authorized?
@@ -111,22 +113,22 @@ module Webmachine
 
       # Forbidden?
       def b7
-        decision_test(resource.forbidden?, true, 403, :b6)
+        decision_test(resource.forbidden?, 403, :b6)
       end
 
       # Okay Content-* Headers?
       def b6
-        decision_test(resource.valid_content_headers?(request.headers.grep(/content-/)), true, :b5,  501)
+        decision_test(resource.valid_content_headers?(request.headers.grep(/content-/)), :b5,  501)
       end
 
       # Known Content-Type?
       def b5
-        decision_test(resource.known_content_type?(request.content_type), true, :b4, 415)
+        decision_test(resource.known_content_type?(request.content_type), :b4, 415)
       end
 
       # Req Entity Too Large?
       def b4
-        decision_test(resource.valid_entity_length?(request.content_length), true, :b3, 413)
+        decision_test(resource.valid_entity_length?(request.content_length), :b3, 413)
       end
 
       # OPTIONS?
@@ -223,7 +225,7 @@ module Webmachine
       def g7
         # This is the first place after all conneg, so set Vary here
         response.headers['Vary'] =  variances.join(", ") if variances.any?
-        decision_test(resource.resource_exists?, true, :g8, :h7)
+        decision_test(resource.resource_exists?, :g8, :h7)
       end
 
       # If-Match exists?
@@ -233,18 +235,18 @@ module Webmachine
 
       # If-Match: * exists?
       def g9
-        request.if_match == "*" ? :h10 : :g11
+        quote(request.if_match) == '"*"' ? :h10 : :g11
       end
 
       # ETag in If-Match
       def g11
-        request_etags = request.if_match.split(/\s*,\s*/).map {|etag| unquote_header(etag) }
-        request_etags.include?(resource.generate_etag) ? :h10 : 412
+        request_etags = request.if_match.split(/\s*,\s*/).map {|etag| ETag.new(etag) }
+        request_etags.include?(ETag.new(resource.generate_etag)) ? :h10 : 412
       end
 
       # If-Match exists?
       def h7
-        (request.if_match && unquote_header(request.if_match) == '*') ? 412 : :i7
+        (request.if_match && unquote(request.if_match) == '*') ? 412 : :i7
       end
 
       # If-Unmodified-Since exists?
@@ -292,7 +294,7 @@ module Webmachine
 
       # If-none-match: * exists?
       def i13
-        request.if_none_match == "*" ? :j18 : :k13
+        quote(request.if_none_match) == '"*"' ? :j18 : :k13
       end
 
       # GET or HEAD?
@@ -315,13 +317,13 @@ module Webmachine
 
       # Previously existed?
       def k7
-        decision_test(resource.previously_existed?, true, :k5, :l7)
+        decision_test(resource.previously_existed?, :k5, :l7)
       end
 
       # Etag in if-none-match?
       def k13
-        request_etags = request.if_none_match.split(/\s*,\s*/).map {|etag| unquote_header(etag) }
-        request_etags.include?(resource.generate_etag) ? :j18 : :l13
+        request_etags = request.if_none_match.split(/\s*,\s*/).map {|etag| ETag.new(etag) }
+        request_etags.include?(ETag.new(resource.generate_etag)) ? :j18 : :l13
       end
 
       # Moved temporarily?
@@ -374,7 +376,7 @@ module Webmachine
 
       # Server allows POST to missing resource?
       def m7
-        decision_test(resource.allow_missing_post?, true, :n11, 404)
+        decision_test(resource.allow_missing_post?, :n11, 404)
       end
 
       # DELETE?
@@ -384,17 +386,17 @@ module Webmachine
 
       # DELETE enacted immediately? (Also where DELETE is forced.)
       def m20
-        decision_test(resource.delete_resource, true, :m20b, 500)
+        decision_test(resource.delete_resource, :m20b, 500)
       end
 
       # Did the DELETE complete?
       def m20b
-        decision_test(resource.delete_completed?, true, :o20, 202)
+        decision_test(resource.delete_completed?, :o20, 202)
       end
 
       # Server allows POST to missing resource?
       def n5
-        decision_test(resource.allow_missing_post?, true, :n11, 410)
+        decision_test(resource.allow_missing_post?, :n11, 410)
       end
 
       # Redirect?
@@ -475,7 +477,7 @@ module Webmachine
 
       # Multiple choices?
       def o18b
-        decision_test(resource.multiple_choices?, true, 300, 200)
+        decision_test(resource.multiple_choices?, 300, 200)
       end
 
       # Response includes an entity?