webmachine 1.0.0 → 1.1.0

data/lib/webmachine/streaming/callable_encoder.rb

@@ -0,0 +1,21 @@
+module Webmachine
+  module Streaming
+    # Implements a streaming encoder for callable bodies, such as
+    # Proc. (essentially futures)
+    # @api private
+    class CallableEncoder < Encoder
+      # Encodes the output of the body Proc.
+      # @return [String]
+      def call
+        resource.send(encoder, resource.send(charsetter, body.call.to_s))
+      end
+
+      # Converts this encoder into a Proc.
+      # @return [Proc] a closure that wraps the {#call} method
+      # @see #call
+      def to_proc
+        method(:call).to_proc
+      end
+    end # class CallableEncoder
+  end
+end

data/lib/webmachine/streaming/encoder.rb

@@ -0,0 +1,24 @@
+module Webmachine
+  module Streaming
+    # Subclasses of this class implement means for streamed/chunked
+    # response bodies to be coerced to the negotiated character set and
+    # encoded automatically as they are output to the client.
+    # @api private
+    class Encoder
+      attr_accessor :resource, :encoder, :charsetter, :body
+
+      def initialize(resource, encoder, charsetter, body)
+        @resource, @encoder, @charsetter, @body = resource, encoder, charsetter, body
+      end
+
+      protected
+      # @return [true, false] whether the stream will be modified by
+      # the encoder and/or charsetter. Only returns true if using the
+      # built-in "encode_identity" and "charset_nop" methods.
+      def is_unencoded?
+        encoder.to_s == "encode_identity" &&
+          charsetter.to_s == "charset_nop"
+      end
+    end # class Encoder
+  end # module Streaming
+end # module Webmachine

data/lib/webmachine/streaming/enumerable_encoder.rb

@@ -0,0 +1,20 @@
+module Webmachine
+  module Streaming
+    # Implements a streaming encoder for Enumerable response bodies, such as
+    # Arrays.
+    # @api private
+    class EnumerableEncoder < Encoder
+      include Enumerable
+
+      # Iterates over the body, encoding and yielding individual chunks
+      # of the response entity.
+      # @yield [chunk]
+      # @yieldparam [String] chunk a chunk of the response, encoded
+      def each
+        body.each do |block|
+          yield resource.send(encoder, resource.send(charsetter, block.to_s))
+        end
+      end
+    end # class EnumerableEncoder
+  end # module Streaming
+end # module Webmachine

data/lib/webmachine/streaming/fiber_encoder.rb

@@ -0,0 +1,25 @@
+begin
+  require 'fiber'
+rescue LoadError
+  require 'webmachine/fiber18'
+end
+
+module Webmachine
+  module Streaming
+    # Implements a streaming encoder for Fibers with the same API as the
+    # EnumerableEncoder. This will resume the Fiber until it terminates
+    # or returns a falsey value.
+    # @api private
+    class FiberEncoder < Encoder
+      include Enumerable
+
+      # Iterates over the body by yielding to the fiber.
+      # @api private
+      def each
+        while body.alive? && chunk = body.resume
+          yield resource.send(encoder, resource.send(charsetter, chunk.to_s))
+        end
+      end
+    end # class FiberEncoder
+  end
+end

data/lib/webmachine/streaming/io_encoder.rb

@@ -0,0 +1,65 @@
+require 'stringio'
+
+module Webmachine
+  module Streaming
+    # Implements a streaming encoder for IO response bodies, such as
+    # File objects.
+    # @api private
+    class IOEncoder < Encoder
+      include Enumerable
+      CHUNK_SIZE = 8192
+      # Iterates over the IO, encoding and yielding individual chunks
+      # of the response entity.
+      # @yield [chunk]
+      # @yieldparam [String] chunk a chunk of the response, encoded
+      def each
+        while chunk = body.read(CHUNK_SIZE) && chunk != ""
+          yield resource.send(encoder, resource.send(charsetter, chunk))
+        end
+      end
+
+      # If IO#copy_stream is supported, and the stream is unencoded,
+      # optimize the output by copying directly. Otherwise, defers to
+      # using #each.
+      # @param [IO] outstream the output stream to copy the body into
+      def copy_stream(outstream)
+        if can_copy_stream?
+          IO.copy_stream(body, outstream)
+        else
+          each {|chunk| outstream << chunk }
+        end
+      end
+
+      # Returns the length of the IO stream, if known. Returns nil if
+      # the stream uses an encoder or charsetter that might modify the
+      # length of the stream, or the stream size is unknown.
+      # @return [Fixnum] the size, in bytes, of the underlying IO, or
+      #   nil if unsupported
+      def size
+        if is_unencoded?
+          if is_string_io?
+            body.size
+          else
+            begin
+              body.stat.size
+            rescue SystemCallError
+              # IO objects might raise an Errno if stat is unsupported.
+              nil
+            end
+          end
+        end
+      end
+
+      alias bytesize size
+
+      private
+      def can_copy_stream?
+        IO.respond_to?(:copy_stream) && is_unencoded? && !is_string_io?
+      end
+
+      def is_string_io?
+        StringIO === body
+      end
+    end # class IOEncoder
+  end # module Streaming
+end # module Webmachine

data/lib/webmachine/trace/fsm.rb

@@ -16,7 +16,8 @@ module Webmachine
         }
       end
 
-      # Adds the response to the trace.
+      # Adds the response to the trace and then commits the trace to
+      # separate storage which can be discovered by the debugger.
       # @param [Webmachine::Response] response the response to be traced
       def trace_response(response)
         response.trace << {
@@ -25,6 +26,8 @@ module Webmachine
           :headers => response.headers,
           :body => trace_response_body(response.body)
         }
+      ensure
+        Trace.record(resource.object_id.to_s, response.trace)
       end
 
       # Adds a decision to the trace.
@@ -43,14 +46,16 @@ module Webmachine
       # Works around streaming encoders where possible
       def trace_response_body(body)
         case body
-        when FiberEncoder
+        when Streaming::FiberEncoder
           # TODO: figure out how to properly rewind or replay the
           # fiber
           body.inspect
-        when EnumerableEncoder
+        when Streaming::EnumerableEncoder
           body.body.join
-        when CallableEncoder
+        when Streaming::CallableEncoder
           body.body.call.to_s
+        when Streaming::IOEncoder
+          body.body.inspect
         else
           body.to_s
         end

data/lib/webmachine/trace/resource_proxy.rb

@@ -35,14 +35,12 @@ module Webmachine
         proxy_callback :charset_nop, *args
       end
 
-      # Calls the resource's finish_request method and then commits
-      # the trace to separate storage which can be discovered by the
-      # debugger.
+      # Calls the resource's finish_request method and then sets the trace id
+      # header in the response.
       def finish_request(*args)
         proxy_callback :finish_request, *args
       ensure
         resource.response.headers['X-Webmachine-Trace-Id'] = object_id.to_s
-        Trace.record(object_id.to_s, resource.response.trace)
       end
 
       private

data/lib/webmachine/trace/static/tracelist.erb

@@ -6,8 +6,8 @@
   <body>
     <h1>Traces</h1>
     <ul>
-      <% traces.each do |trace| %>
-      <li><a href="<%= trace %>"><%= trace %></a></li>
+      <% traces.each do |(trace, uri)| %>
+      <li><a href="<%= uri %>"><%= trace %></a></li>
       <% end %>
     </ul>
   </body>

data/lib/webmachine/trace/trace_resource.rb

@@ -73,11 +73,12 @@ module Webmachine
         # TODO: Add support for IO objects as response bodies,
         # allowing server optimizations like sendfile or chunked
         # downloads
-        File.read(@file)
+        open(@file, "rb") {|io| io.read }
       end
 
       def produce_list
-        traces = Trace.traces
+        base   = request.uri.path.chomp("/")
+        traces = Trace.traces.map {|t| [ t, "#{base}/#{t}" ] }
         self.class.tracelist.result(binding)
       end
 

data/lib/webmachine/version.rb

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

data/spec/webmachine/adapters/hatetepe_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+examples = proc do
+  let(:configuration) { Webmachine::Configuration.default              }
+  let(:dispatcher)    { Webmachine::Dispatcher.new                     }
+  let(:adapter)       { described_class.new(configuration, dispatcher) }
+
+  it "inherits from Webmachine::Adapter" do
+    adapter.should be_a(Webmachine::Adapter)
+  end
+
+  describe "#run" do
+    it "starts a server" do
+      Hatetepe::Server.should_receive(:start).with(adapter.options) { EM.stop }
+      adapter.run
+    end
+  end
+
+  describe "#call" do
+    let :request do
+      Hatetepe::Request.new(:get, "/", {}, StringIO.new("hello, world!"))
+    end
+
+    it "builds a string-like and enumerable request body" do
+      dispatcher.should_receive(:dispatch) do |req, res|
+        req.body.to_s.should       eq("hello, world!")
+        enum_to_s(req.body).should eq("hello, world!")
+      end
+      adapter.call(request) {}
+    end
+
+    shared_examples "enumerable response body" do
+      before do
+        dispatcher.stub(:dispatch) {|_, response| response.body = body }
+      end
+
+      it "builds an enumerable response body" do
+        adapter.call(request) do |response|
+          enum_to_s(response.body).should eq("bye, world!")
+        end
+      end
+    end
+
+    describe "with normal response" do
+      let(:body) { "bye, world!" }
+
+      it_behaves_like "enumerable response body"
+    end
+
+    describe "with streaming response" do
+      let(:body) { proc { "bye, world!" } }
+
+      it_behaves_like "enumerable response body"
+    end
+  end
+
+  def enum_to_s(enum)
+    Enumerator.new(enum).to_a.join
+  end
+end
+
+if RUBY_VERSION >= "1.9"
+  describe Webmachine::Adapters::Hatetepe, &examples
+end

data/spec/webmachine/adapters/rack_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'webmachine/adapters/rack'
 require 'rack'
 require 'rack/test'
+require 'rack/lint'
 
 module Test
   class Resource < Webmachine::Resource
@@ -51,7 +52,7 @@ describe Webmachine::Adapters::Rack do
   let(:adapter) do
     described_class.new(configuration, dispatcher)
   end
-  let(:app) { adapter }
+  let(:app) { Rack::Lint.new(adapter) }
 
   before do
     dispatcher.add_route ['test'], Test::Resource
@@ -81,13 +82,14 @@ describe Webmachine::Adapters::Rack do
   it "should proxy request to webmachine" do
     get "/test"
     last_response.status.should == 200
-    last_response.headers["Content-Type"].should == "text/html"
+    last_response.original_headers["Content-Type"].should == "text/html"
     last_response.body.should == "<html><body>testing</body></html>"
   end
 
   it "should build a string-like request body" do
     dispatcher.should_receive(:dispatch) do |request, response|
       request.body.to_s.should eq("Hello, World!")
+      response.headers["Content-Type"] = "text/plain"
     end
     request "/test", :method => "GET", :input => "Hello, World!"
   end
@@ -96,6 +98,7 @@ describe Webmachine::Adapters::Rack do
     chunks = []
     dispatcher.should_receive(:dispatch) do |request, response|
       request.body.each { |chunk| chunks << chunk }
+      response.headers["Content-Type"] = "text/plain"
     end
     request "/test", :method => "GET", :input => "Hello, World!"
     chunks.join.should eq("Hello, World!")
@@ -109,14 +112,14 @@ describe Webmachine::Adapters::Rack do
 
   it "should set Server header" do
     get "/test"
-    last_response.headers.should have_key("Server")
+    last_response.original_headers.should have_key("Server")
   end
 
   it "should set Set-Cookie header" do
     get "/test"
     # Yes, Rack expects multiple values for a given cookie to be
     # \n separated.
-    last_response.headers["Set-Cookie"].should == "cookie=monster\nrodeo=clown"
+    last_response.original_headers["Set-Cookie"].should == "cookie=monster\nrodeo=clown"
   end
 
   it "should handle non-success correctly" do
@@ -129,8 +132,8 @@ describe Webmachine::Adapters::Rack do
     header "CONTENT_TYPE", "application/json"
     post "/test"
     last_response.status.should == 204
-    last_response.headers.should_not have_key("Content-Type")
-    last_response.headers.should_not have_key("Content-Length")
+    last_response.original_headers.should_not have_key("Content-Type")
+    last_response.original_headers.should_not have_key("Content-Length")
     last_response.body.should == ""
   end
 
@@ -145,7 +148,7 @@ describe Webmachine::Adapters::Rack do
     header "ACCEPT", "application/vnd.webmachine.streaming+enum"
     get "/test"
     last_response.status.should == 200
-    last_response.headers["Transfer-Encoding"].should == "chunked"
+    last_response.original_headers["Transfer-Encoding"].should == "chunked"
     last_response.body.split("\r\n").should == %W{6 Hello, 6 World! 0}
   end
 
@@ -153,7 +156,14 @@ describe Webmachine::Adapters::Rack do
     header "ACCEPT", "application/vnd.webmachine.streaming+proc"
     get "/test"
     last_response.status.should == 200
-    last_response.headers["Transfer-Encoding"].should == "chunked"
+    last_response.original_headers["Transfer-Encoding"].should == "chunked"
     last_response.body.split("\r\n").should == %W{6 Stream 0}
   end
+
+  it "should receive Content-Type on Not acceptable response" do
+    header "ACCEPT", "text/plain"
+    get "/test"
+    last_response.status.should == 406
+    last_response.original_headers.should have_key('Content-Type')
+  end
 end

data/spec/webmachine/adapters/reel_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+if RUBY_VERSION >= "1.9"
+  describe Webmachine::Adapters::Reel do
+    let(:configuration) { Webmachine::Configuration.default }
+    let(:dispatcher) { Webmachine::Dispatcher.new }
+    let(:adapter) do
+      described_class.new(configuration, dispatcher)
+    end
+
+    it 'inherits from Webmachine::Adapter' do
+      adapter.should be_a_kind_of(Webmachine::Adapter)
+    end
+
+    it 'implements #run' do
+      adapter.should respond_to(:run)
+    end
+
+    it 'implements #process' do
+      adapter.should respond_to(:process)
+    end
+  end
+end

data/spec/webmachine/decision/falsey_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Webmachine::Decision::Falsey do
+  specify { (described_class.=== false).should be_true }
+  specify { (described_class.=== nil).should be_true }
+  specify { (described_class.=== true).should be_false }
+  specify { (described_class.=== []).should be_false }
+end