webmachine 1.2.2 → 1.6.0

data/lib/webmachine/spec/test_resource.rb

@@ -17,8 +17,10 @@ module Test
         ["test/response.enumbody", :to_enum],
         ["test/response.procbody", :to_proc],
         ["test/response.fiberbody", :to_fiber],
-        ["test/response.iobody", :to_io],
-        ["test/response.cookies", :to_cookies]
+        ["test/response.iobody", :to_io_body],
+        ["test/response.cookies", :to_cookies],
+        ["test/response.request_uri", :to_request_uri],
+        ["test/response.rack_env", :to_rack_env]
       ]
     end
 
@@ -58,8 +60,8 @@ module Test
       end
     end
 
-    def to_io
-      StringIO.new("IO response body")
+    def to_io_body
+      File.new(File.expand_path('../IO_response.body', __FILE__))
     end
 
     def to_cookies
@@ -67,7 +69,16 @@ module Test
       response.set_cookie("rodeo", "clown")
       # FIXME: Mongrel/WEBrick fail if this method returns nil
       # Might be a net/http issue. Is this a bug?
+      # @see Flow#o18, Helpers#encode_body_if_set
       request.cookies["echo"] || ""
     end
+
+    def to_request_uri
+      request.uri.to_s
+    end
+
+    def to_rack_env
+      request.env.to_json
+    end
   end
 end

data/lib/webmachine/streaming/fiber_encoder.rb

@@ -1,8 +1,4 @@
-begin
-  require 'fiber'
-rescue LoadError
-  require 'webmachine/fiber18'
-end
+require 'fiber'
 
 module Webmachine
   module Streaming

data/lib/webmachine/streaming/io_encoder.rb

@@ -30,10 +30,16 @@ module Webmachine
         end
       end
 
+      # Allows the response body to be converted to a IO object.
+      # @return [IO,nil] the body as a IO object, or nil.
+      def to_io
+        IO.try_convert(body)
+      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
+      # @return [Integer] the size, in bytes, of the underlying IO, or
       #   nil if unsupported
       def size
         if is_unencoded?

data/lib/webmachine/trace.rb

@@ -1,3 +1,4 @@
+require 'webmachine/events'
 require 'webmachine/trace/resource_proxy'
 require 'webmachine/trace/fsm'
 require 'webmachine/trace/pstore_trace_store'

data/lib/webmachine/trace/fsm.rb

@@ -4,6 +4,22 @@ module Webmachine
     # tracing is enabled for a resource, enabling the capturing of
     # traces.
     module FSM
+      # Overrides the default resource accessor so that incoming
+      # callbacks are traced.
+      def initialize(_resource, _request, _response)
+        if trace?
+          class << self
+            def resource
+              @resource_proxy ||= ResourceProxy.new(@resource)
+            end
+          end
+        end
+      end
+
+      def trace?
+        Trace.trace?(@resource)
+      end
+
       # Adds the request to the trace.
       # @param [Webmachine::Request] request the request to be traced
       def trace_request(request)
@@ -13,7 +29,7 @@ module Webmachine
           :path => request.uri.request_uri.to_s,
           :headers => request.headers,
           :body => request.body.to_s
-        }
+        } if trace?
       end
 
       # Adds the response to the trace and then commits the trace to
@@ -25,24 +41,18 @@ module Webmachine
           :code => response.code.to_s,
           :headers => response.headers,
           :body => trace_response_body(response.body)
-        }
+        } if trace?
       ensure
         Webmachine::Events.publish('wm.trace.record', {
           :trace_id => resource.object_id.to_s,
           :trace => response.trace
-        })
+        }) if trace?
       end
 
       # Adds a decision to the trace.
       # @param [Symbol] decision the decision being processed
       def trace_decision(decision)
-        response.trace << {:type => :decision, :decision => decision}
-      end
-
-      # Overrides the default resource accessor so that incoming
-      # callbacks are traced.
-      def resource
-        @resource_proxy ||= ResourceProxy.new(@resource)
+        response.trace << {:type => :decision, :decision => decision} if trace?
       end
 
       private

data/lib/webmachine/trace/resource_proxy.rb

@@ -1,3 +1,5 @@
+require 'webmachine/resource'
+
 module Webmachine
   module Trace
     # This class is injected into the decision FSM as a stand-in for

data/lib/webmachine/translation.rb

@@ -1,5 +1,6 @@
+require 'set'
 require 'i18n'
-
+I18n.enforce_available_locales = true if I18n.respond_to?(:enforce_available_locales)
 I18n.config.load_path << File.expand_path("../locale/en.yml", __FILE__)
 
 module Webmachine

data/lib/webmachine/version.rb

@@ -1,8 +1,8 @@
-module Webmachine
+module Webmachine
   # Library version
-  VERSION = "1.2.2"
+  VERSION = "1.6.0".freeze
 
   # String for use in "Server" HTTP response header, which includes
   # the {VERSION}.
-  SERVER_STRING = "Webmachine-Ruby/#{VERSION}"
+  SERVER_STRING = "Webmachine-Ruby/#{VERSION}".freeze
 end

data/memory_test.rb

@@ -0,0 +1,37 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'webmachine'
+
+class Constantized < Webmachine::Resource
+  HELLO_WORLD = "Hello World".freeze
+  ALLOWED_METHODS = ['GET'.freeze].freeze
+  CONTENT_TYPES_PROVIDED = [['text/html'.freeze, :to_html].freeze].freeze
+
+  def allowed_methods
+    ALLOWED_METHODS
+  end
+
+  def content_types_provided
+    CONTENT_TYPES_PROVIDED
+  end
+
+  def to_html
+    HELLO_WORLD
+  end
+end
+
+Webmachine.application.routes do
+  add ['constantized'], Constantized
+end
+
+require 'webmachine/test'
+session = Webmachine::Test::Session.new(Webmachine.application)
+CONSTANTIZED = '/constantized'.freeze
+require 'memory_profiler'
+report = MemoryProfiler.report do
+  100.times do
+    session.get(CONSTANTIZED)
+  end
+end
+
+report.pretty_print
+

data/spec/spec_helper.rb

@@ -1,16 +1,16 @@
-$LOAD_PATH << File.expand_path("..", __FILE__)
-$LOAD_PATH << File.expand_path("../../lib", __FILE__)
-
-require 'rubygems'
-require 'webmachine'
-require 'rspec'
+require "bundler/setup"
+Bundler.require :default, :test, :webservers
 require 'logger'
 
+class NullLogger < Logger
+  def add(severity, message=nil, progname=nil, &block)
+  end
+end
+
 RSpec.configure do |config|
   config.mock_with :rspec
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.formatter = :documentation if ENV['CI']
   if defined?(::Java)
     config.seed = Time.now.utc
@@ -18,13 +18,21 @@ RSpec.configure do |config|
     config.order = :random
   end
 
+  config.before :each do
+    Webmachine::RescuableException.remove(RSpec::Mocks::MockExpectationError)
+  end
+
+  config.after :each do
+    Webmachine::RescuableException.default!
+  end
+
   config.before(:suite) do
     options = {
-      :Logger => Logger.new("/dev/null"),
+      :Logger => NullLogger.new(STDERR),
       :AccessLog => []
     }
     Webmachine::Adapters::WEBrick::DEFAULT_OPTIONS.merge! options
-    Webmachine::Adapters::Rack::DEFAULT_OPTIONS.merge! options
+    Webmachine::Adapters::Rack::DEFAULT_OPTIONS.merge! options if defined?(Webmachine::Adapters::Rack)
   end
 end
 

data/spec/webmachine/adapter_spec.rb

@@ -1,39 +1,38 @@
 require "spec_helper"
 
 describe Webmachine::Adapter do
-  let(:configuration) { Webmachine::Configuration.default }
-  let(:dispatcher) { Webmachine::Dispatcher.new }
+  let(:application) { Webmachine::Application.new }
   let(:adapter) do
-    described_class.new(configuration, dispatcher)
+    server = TCPServer.new('0.0.0.0', 0)
+    application.configuration.port = server.addr[1]
+    server.close
+
+    described_class.new(application)
   end
 
   describe "#initialize" do
-    it "stores the provided configuration" do
-      adapter.configuration.should eql configuration
-    end
-
-    it "stores the provided dispatcher" do
-      adapter.dispatcher.should eql dispatcher
+    it "stores the provided application" do
+      expect(adapter.application).to eq(application)
     end
   end
 
   describe ".run" do
     it "creates a new adapter and runs it" do
-      adapter = mock(described_class)
+      adapter = double(described_class)
 
-      described_class.should_receive(:new).
-        with(configuration, dispatcher).
+      expect(described_class).to receive(:new).
+        with(application).
         and_return(adapter)
 
-      adapter.should_receive(:run)
+      expect(adapter).to receive(:run)
 
-      described_class.run(configuration, dispatcher)
+      described_class.run(application)
     end
   end
 
   describe "#run" do
     it "raises a NotImplementedError" do
-      lambda { adapter.run }.should raise_exception(NotImplementedError)
+      expect { adapter.run }.to raise_exception(NotImplementedError)
     end
   end
 

data/spec/webmachine/adapters/httpkit_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+require "webmachine/spec/adapter_lint"
+
+begin
+  describe Webmachine::Adapters::HTTPkit do
+    it_should_behave_like :adapter_lint
+  end
+rescue LoadError
+  warn "Platform is #{RUBY_PLATFORM}: skipping httpkit adapter spec."
+end

data/spec/webmachine/adapters/rack_mapped_spec.rb

@@ -0,0 +1,71 @@
+require 'webmachine/adapter'
+require 'webmachine/adapters/rack_mapped'
+require 'spec_helper'
+require 'webmachine/spec/adapter_lint'
+require 'rack/test'
+
+describe Webmachine::Adapters::RackMapped do
+  it_should_behave_like :adapter_lint do
+    it "should set Server header" do
+      response = client.request(Net::HTTP::Get.new("/test"))
+      expect(response["Server"]).to match(/Webmachine/)
+      expect(response["Server"]).to match(/Rack/)
+    end
+  end
+end
+
+describe Webmachine::Adapters::RackMapped do
+  class CreateResource < Webmachine::Resource
+    def allowed_methods
+      ["POST"]
+    end
+
+    def content_types_accepted
+      [["application/json", :from_json]]
+    end
+
+    def content_types_provided
+      [["application/json", :to_json]]
+    end
+
+    def post_is_create?
+      true
+    end
+
+    def create_path
+      "created_path_here/123"
+    end
+
+    def from_json
+      response.body = %{ {"foo": "bar"} }
+    end
+  end
+
+  let(:app) do
+    Rack::Builder.new do
+      map '/some/route' do
+        run(Webmachine::Application.new do |app|
+          app.add_route(["test"], Test::Resource)
+          app.add_route(["create_test"], CreateResource)
+          app.configure do | config |
+            config.adapter = :RackMapped
+          end
+        end.adapter)
+      end
+    end
+  end
+
+  context "using Rack::Test" do
+    include Rack::Test::Methods
+
+    it "provides the full request URI" do
+      rack_response = get "some/route/test", nil, {"HTTP_ACCEPT" => "test/response.request_uri"}
+      expect(rack_response.body).to eq "http://example.org/some/route/test"
+    end
+
+    it "provides LOCATION header using custom base_uri when creating from POST request" do
+      rack_response = post "/some/route/create_test", %{{"foo": "bar"}}, {"HTTP_ACCEPT" => "application/json", "CONTENT_TYPE" => "application/json"}
+      expect(rack_response.headers["Location"]).to eq("http://example.org/some/route/created_path_here/123")
+    end
+  end
+end

data/spec/webmachine/adapters/rack_spec.rb

@@ -2,35 +2,61 @@ require 'webmachine/adapter'
 require 'webmachine/adapters/rack'
 require 'spec_helper'
 require 'webmachine/spec/adapter_lint'
+require 'rack/test'
 
 describe Webmachine::Adapters::Rack do
   it_should_behave_like :adapter_lint do
     it "should set Server header" do
       response = client.request(Net::HTTP::Get.new("/test"))
-      response["Server"].should match(/Webmachine/)
-      response["Server"].should match(/Rack/)
+      expect(response["Server"]).to match(/Webmachine/)
+      expect(response["Server"]).to match(/Rack/)
     end
   end
 end
 
 describe Webmachine::Adapters::Rack::RackResponse do
   context "on Rack < 1.5 release" do
-    before { Rack.stub(:release => "1.4") }
+    before { allow(Rack).to receive_messages(:release => "1.4") }
 
     it "should add Content-Type header on not acceptable response" do
       rack_response = described_class.new(double(:body), 406, {})
       rack_status, rack_headers, rack_body = rack_response.finish
-      rack_headers.should have_key("Content-Type")
+      expect(rack_headers).to have_key("Content-Type")
     end
   end
 
   context "on Rack >= 1.5 release" do
-    before { Rack.stub(:release => "1.5") }
+    before { allow(Rack).to receive_messages(:release => "1.5") }
 
     it "should not add Content-Type header on not acceptable response" do
       rack_response = described_class.new(double(:body), 406, {})
       rack_status, rack_headers, rack_body = rack_response.finish
-      rack_headers.should_not have_key("Content-Type")
+      expect(rack_headers).not_to have_key("Content-Type")
+    end
+  end
+end
+
+describe Webmachine::Adapters::Rack do
+  let(:app) do
+    Webmachine::Application.new do |app|
+      app.add_route(["test"], Test::Resource)
+      app.configure do | config |
+        config.adapter = :Rack
+      end
+    end.adapter
+  end
+
+  context "using Rack::Test" do
+    include Rack::Test::Methods
+
+    it "provides the full request URI" do
+      rack_response = get "test", nil, {"HTTP_ACCEPT" => "test/response.request_uri"}
+      expect(rack_response.body).to eq "http://example.org/test"
+    end
+
+    it "provides the rack env on the request" do
+      rack_response = get "test", nil, {"HTTP_ACCEPT" => "test/response.rack_env"}
+      expect(JSON.parse(rack_response.body).keys).to include "rack.input"
     end
   end
 end