RubyGems - webmachine - Versions diffs - 1.1.0 → 1.2.0 - Mend

webmachine 1.1.0 → 1.2.0

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 (36) hide show

data/Gemfile +5 -4
data/README.md +25 -2
data/examples/debugger.rb +7 -0
data/examples/logging.rb +41 -0
data/lib/webmachine/adapters.rb +1 -1
data/lib/webmachine/adapters/hatetepe.rb +5 -1
data/lib/webmachine/adapters/lazy_request_body.rb +7 -7
data/lib/webmachine/adapters/mongrel.rb +27 -12
data/lib/webmachine/adapters/rack.rb +42 -6
data/lib/webmachine/adapters/reel.rb +91 -23
data/lib/webmachine/adapters/webrick.rb +12 -6
data/lib/webmachine/application.rb +1 -0
data/lib/webmachine/cookie.rb +1 -1
data/lib/webmachine/dispatcher.rb +7 -1
data/lib/webmachine/events.rb +179 -0
data/lib/webmachine/events/instrumented_event.rb +19 -0
data/lib/webmachine/response.rb +1 -1
data/lib/webmachine/streaming/io_encoder.rb +5 -1
data/lib/webmachine/trace.rb +18 -0
data/lib/webmachine/trace/fsm.rb +4 -1
data/lib/webmachine/trace/listener.rb +12 -0
data/lib/webmachine/version.rb +1 -1
data/spec/spec_helper.rb +11 -0
data/spec/support/adapter_lint.rb +125 -0
data/spec/support/test_resource.rb +73 -0
data/spec/webmachine/adapters/hatetepe_spec.rb +2 -2
data/spec/webmachine/adapters/mongrel_spec.rb +6 -51
data/spec/webmachine/adapters/rack_spec.rb +22 -155
data/spec/webmachine/adapters/reel_spec.rb +59 -7
data/spec/webmachine/adapters/webrick_spec.rb +7 -13
data/spec/webmachine/cookie_spec.rb +1 -1
data/spec/webmachine/decision/helpers_spec.rb +10 -0
data/spec/webmachine/events_spec.rb +58 -0
data/spec/webmachine/request_spec.rb +41 -0
data/webmachine.gemspec +1 -1
metadata +63 -24

data/Gemfile CHANGED Viewed

@@ -1,6 +1,6 @@
 require 'rbconfig'
-source :rubygems
+source 'https://rubygems.org'
 gemspec
@@ -8,10 +8,11 @@ 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'
+    gem 'reel', '~> 0.3.0', :platform => [:ruby_19, :ruby_20, :jruby]
   end
   gem 'hatetepe', '~> 0.5'
 end
@@ -29,7 +30,7 @@ group :guard do
 end
 group :docs do
-  platform :mri do
+  platform :mri_19, :mri_20 do
     gem 'redcarpet'
   end
 end

data/README.md CHANGED Viewed

@@ -179,14 +179,16 @@ for an example of how to enable the debugger.
 ## 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
 * [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
+* [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
 ## LICENSE
@@ -196,6 +198,27 @@ 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

data/examples/debugger.rb CHANGED Viewed

@@ -20,7 +20,14 @@ class MyTracedResource < Webmachine::Resource
   end
 end
+class MyTracer
+  def call(name, payload)
+    puts "MyTracer #{name} #{payload.inspect}"
+  end
+end
 # Webmachine::Trace.trace_store = :pstore, "./trace"
+# Webmachine::Trace.trace_listener = [Webmachine::Trace::Listener.new, MyTracer.new]
 TraceExample = Webmachine::Application.new do |app|
   app.routes do

data/examples/logging.rb ADDED Viewed

@@ -0,0 +1,41 @@
+require 'webmachine'
+require 'time'
+require 'logger'
+class HelloResource < Webmachine::Resource
+  def to_html
+    "<html><head><title>Hello from Webmachine</title></head><body>Hello, world!</body></html>\n"
+  end
+end
+class LogListener
+  def call(*args)
+    handle_event(Webmachine::Events::InstrumentedEvent.new(*args))
+  end
+  def handle_event(event)
+    request = event.payload[:request]
+    resource = event.payload[:resource]
+    code = event.payload[:code]
+    puts "[%s] method=%s uri=%s code=%d resource=%s time=%.4f" % [
+      Time.now.iso8601, request.method, request.uri.to_s, code, resource,
+      event.duration
+    ]
+  end
+end
+Webmachine::Events.subscribe('wm.dispatch', LogListener.new)
+App = Webmachine::Application.new do |app|
+  app.routes do
+    add_route [], HelloResource
+  end
+  app.configure do |config|
+    config.adapter = :WEBrick
+    config.adapter_options = {:AccessLog => [], :Logger => Logger.new('/dev/null')}
+  end
+end
+App.run

data/lib/webmachine/adapters.rb CHANGED Viewed

@@ -6,7 +6,7 @@ module Webmachine
   # application servers.
   module Adapters
     autoload :Mongrel,  'webmachine/adapters/mongrel'
-		autoload :Reel,     'webmachine/adapters/reel'
+    autoload :Reel,     'webmachine/adapters/reel'
     autoload :Hatetepe, 'webmachine/adapters/hatetepe'
   end
 end

data/lib/webmachine/adapters/hatetepe.rb CHANGED Viewed

@@ -30,10 +30,14 @@ module Webmachine
         EM.epoll
         EM.synchrony do
           ::Hatetepe::Server.start(options)
-          trap("INT") { EM.stop }
+          trap("INT") { shutdown }
         end
       end
+      def shutdown
+        EM.stop
+      end
       def call(request, &respond)
         response = Webmachine::Response.new
         dispatcher.dispatch(convert_request(request), response)

data/lib/webmachine/adapters/lazy_request_body.rb CHANGED Viewed

@@ -11,7 +11,12 @@ module Webmachine
       # Converts the body to a String so you can work with the entire
       # thing.
       def to_s
-        @value ? @value.join : @request.body
+        @request.body
+      end
+      # Converts the body to a String and checks if it is empty.
+      def empty?
+        to_s.empty?
       end
       # Iterates over the body in chunks. If the body has previously
@@ -20,12 +25,7 @@ module Webmachine
       # @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
+        @request.body {|chunk| yield chunk }
       end
     end # class RequestBody
   end # module Adapters

data/lib/webmachine/adapters/mongrel.rb CHANGED Viewed

@@ -18,14 +18,20 @@ module Webmachine
           :host => configuration.ip,
           :dispatcher => dispatcher
         }.merge(configuration.adapter_options)
-        config = ::Mongrel::Configurator.new(defaults) do
+        @config = ::Mongrel::Configurator.new(defaults) do
           listener do
             uri '/', :handler => Webmachine::Adapters::Mongrel::Handler.new(defaults[:dispatcher])
           end
           trap("INT") { stop }
           run
         end
-        config.join
+        @config.join
+      end
+      def shutdown
+        # The second argument tells mongrel to block until all listeners are shut down.
+        # This causes the mongrel tests to be very slow, but faster methods cause errors.
+        @config.stop(false, true) if @config
       end
       # A Mongrel handler for Webmachine
@@ -51,11 +57,12 @@ module Webmachine
             wres.status = response.code.to_i
             wres.send_status(nil)
-            response.headers.each { |k, vs|
-              vs.split("\n").each { |v|
+            response.headers.each do |k, vs|
+              [*vs].each do |v|
                 wres.header[k] = v
-              }
-            }
+              end
+            end
             wres.header['Server'] = [Webmachine::SERVER_STRING, "Mongrel/#{::Mongrel::Const::MONGREL_VERSION}"].join(" ")
             wres.send_header
@@ -64,16 +71,24 @@ module Webmachine
               wres.write response.body
               wres.socket.flush
             when Enumerable
-              Webmachine::ChunkedBody.new(response.body).each { |part|
-                wres.write part
-                wres.socket.flush
-              }
+              # This might be an IOEncoder with a Content-Length, which shouldn't be chunked.
+              if response.headers["Transfer-Encoding"] == "chunked"
+                Webmachine::ChunkedBody.new(response.body).each do |part|
+                  wres.write part
+                  wres.socket.flush
+                end
+              else
+                response.body.each do |part|
+                  wres.write part
+                  wres.socket.flush
+                end
+              end
             else
               if response.body.respond_to?(:call)
-                Webmachine::ChunkedBody.new(Array(response.body.call)).each { |part|
+                Webmachine::ChunkedBody.new(Array(response.body.call)).each do |part|
                   wres.write part
                   wres.socket.flush
-                }
+                end
               end
             end
           ensure

data/lib/webmachine/adapters/rack.rb CHANGED Viewed

@@ -31,16 +31,23 @@ module Webmachine
     #     MyApplication.run
     #
     class Rack < Adapter
+      # Used to override default Rack server options (useful in testing)
+      DEFAULT_OPTIONS = {}
       # Start the Rack adapter
       def run
-        options = {
+        options = DEFAULT_OPTIONS.merge({
           :app => self,
           :Port => configuration.port,
           :Host => configuration.ip
-        }.merge(configuration.adapter_options)
+        }).merge(configuration.adapter_options)
-        ::Rack::Server.start(options)
+        @server = ::Rack::Server.new(options)
+        @server.start
+      end
+      def shutdown
+        @server.server.shutdown if @server
       end
       # Handles a Rack-based request.
@@ -59,7 +66,7 @@ module Webmachine
         response.headers['Server'] = [Webmachine::SERVER_STRING, "Rack/#{::Rack.version}"].join(" ")
-        rack_status = response.code
+        rack_status  = response.code
         rack_headers = response.headers.flattened("\n")
         rack_body = case response.body
                     when String # Strings are enumerable in ruby 1.8
@@ -68,16 +75,45 @@ module Webmachine
                       if response.body.respond_to?(:call)
                         Webmachine::ChunkedBody.new(Array(response.body.call))
                       elsif response.body.respond_to?(:each)
-                        Webmachine::ChunkedBody.new(response.body)
+                        # This might be an IOEncoder with a Content-Length, which shouldn't be chunked.
+                        if response.headers["Transfer-Encoding"] == "chunked"
+                          Webmachine::ChunkedBody.new(response.body)
+                        else
+                          response.body
+                        end
                       else
                         [response.body.to_s]
                       end
                     end
-        rack_res = ::Rack::Response.new(rack_body, rack_status, rack_headers)
+        rack_res = RackResponse.new(rack_body, rack_status, rack_headers)
         rack_res.finish
       end
+      class RackResponse
+        def initialize(body, status, headers)
+          @body    = body
+          @status  = status
+          @headers = headers
+        end
+        def finish
+          @headers['Content-Type'] ||= 'text/html' if rack_release_enforcing_content_type
+          @headers.delete('Content-Type')          if response_without_body
+          [@status, @headers, @body]
+        end
+        protected
+        def response_without_body
+          ::Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? @status
+        end
+        def rack_release_enforcing_content_type
+          ::Rack.release < '1.5'
+        end
+      end
       # Wraps the Rack input so it can be treated like a String or
       # Enumerable.
       # @api private

data/lib/webmachine/adapters/reel.rb CHANGED Viewed

@@ -4,40 +4,108 @@ require 'webmachine/headers'
 require 'webmachine/request'
 require 'webmachine/response'
 require 'webmachine/dispatcher'
-require 'webmachine/chunked_body'
+require 'webmachine/adapters/lazy_request_body'
+require 'set'
 module Webmachine
   module Adapters
     class Reel < Adapter
       def run
-        options = {
+        @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
+        if extra_verbs = configuration.adapter_options[:extra_verbs]
+          @extra_verbs = Set.new(extra_verbs.map(&:to_s).map(&:upcase))
+        else
+          @extra_verbs = Set.new
+        end
+        @server = ::Reel::Server.supervise(@options[:host], @options[:port], &method(:process))
+        # FIXME: this will no longer work on Ruby 2.0. We need Celluloid.trap
+        trap("INT") { @server.terminate; exit 0 }
+        Celluloid::Actor.join(@server)
+      end
+      def shutdown
+        @server.terminate! if @server
       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)
+        while request = connection.request
+          # Users of the adapter can configure a custom WebSocket handler
+          if request.is_a? ::Reel::WebSocket
+            if handler = @options[:websocket_handler]
+              handler.call(request)
+            else
+              # Pretend we don't know anything about the WebSocket protocol
+              # FIXME: This isn't strictly what RFC 6455 would have us do
+              request.respond :bad_request, "WebSockets not supported"
+            end
+            next
+          end
+          # Optional support for e.g. WebDAV verbs not included in Webmachine's
+          # state machine. Do the "Railsy" thing and handle them like POSTs
+          # with a magical parameter
+          if @extra_verbs.include?(request.method)
+            method = "POST"
+            param  = "_method=#{request.method}"
+            uri    = request_uri(request.url, request.headers, param)
+          else
+            method = request.method
+            uri    = request_uri(request.url, request.headers)
+          end
+          wm_headers  = Webmachine::Headers[request.headers.dup]
+          wm_request  = Webmachine::Request.new(method, uri, wm_headers,
+                                                LazyRequestBody.new(request))
+          wm_response = Webmachine::Response.new
+          @dispatcher.dispatch(wm_request, wm_response)
+          fixup_headers(wm_response)
+          fixup_callable_encoder(wm_response)
+          request.respond ::Reel::Response.new(wm_response.code,
+                                               wm_response.headers,
+                                               wm_response.body)
+        end
+      end
+      def request_uri(path, headers, extra_query_params = nil)
+        host_parts = headers.fetch('Host').split(':')
+        path_parts = path.split('?')
+        uri_hash = {host: host_parts.first, path: path_parts.first}
+        uri_hash[:port]  = host_parts.last.to_i if host_parts.length == 2
+        uri_hash[:query] = path_parts.last      if path_parts.length == 2
+        if extra_query_params
+          if uri_hash[:query]
+            uri_hash[:query] << "&#{extra_query_params}"
+          else
+            uri_hash[:query] = extra_query_params
+          end
+        end
+        URI::HTTP.build(uri_hash)
+      end
+      def fixup_headers(response)
+        response.headers.each do |key, value|
+          if value.is_a?(Array)
+            response.headers[key] = value.join(", ")
+          end
+        end
+      end
+      def fixup_callable_encoder(response)
+        if response.body.is_a?(Streaming::CallableEncoder)
+          response.body = [response.body.call]
         end
       end
     end