webmachine 1.2.2 → 1.6.0

data/lib/webmachine/request.rb

@@ -1,15 +1,19 @@
-require 'cgi'
+require 'cgi'
 require 'forwardable'
+require 'webmachine/constants'
+require 'ipaddr'
 
 module Webmachine
   # Request represents a single HTTP request sent from a client. It
   # should be instantiated by {Adapters} when a request is received
   class Request
+    HTTP_HEADERS_MATCH = /^(?:[a-z0-9])+(?:_[a-z0-9]+)*$/i.freeze
+    ROUTING_PATH_MATCH = /^\/(.*)/.freeze
+
     extend Forwardable
-    attr_reader :method, :uri, :headers, :body
-    attr_accessor :disp_path, :path_info, :path_tokens
 
-    STANDARD_HTTP_METHODS = %w[GET HEAD POST PUT DELETE TRACE CONNECT OPTIONS]
+    attr_reader :method, :uri, :headers, :body, :routing_tokens, :base_uri
+    attr_accessor :disp_path, :path_info, :path_tokens
 
     # @param [String] method the HTTP request method
     # @param [URI] uri the requested URI, including host, scheme and
@@ -17,8 +21,14 @@ module Webmachine
     # @param [Headers] headers the HTTP request headers
     # @param [String,#to_s,#each,nil] body the entity included in the
     #   request, if present
-    def initialize(method, uri, headers, body)
-      @method, @uri, @headers, @body = method, uri, headers, body
+    def initialize(method, uri, headers, body, routing_tokens=nil, base_uri=nil)
+      @method, @headers, @body = method, headers, body
+      @uri = build_uri(uri, headers)
+      @routing_tokens = routing_tokens || @uri.path.match(ROUTING_PATH_MATCH)[1].split(SLASH)
+      @base_uri = base_uri || @uri.dup.tap do |u|
+        u.path = SLASH
+        u.query = nil
+      end
     end
 
     def_delegators :headers, :[]
@@ -27,9 +37,18 @@ module Webmachine
     # lowercased-underscored version of the header name, e.g.
     # `if_unmodified_since`.
     def method_missing(m, *args, &block)
-      if m.to_s =~ /^(?:[a-z0-9])+(?:_[a-z0-9]+)*$/i
+      if m =~ HTTP_HEADERS_MATCH
         # Access headers more easily as underscored methods.
-        self[m.to_s.tr('_', '-')]
+        header_name = m.to_s.tr(UNDERSCORE, DASH)
+        if (header_value = @headers[header_name])
+          # Make future lookups faster.
+          self.class.class_eval <<-RUBY, __FILE__, __LINE__
+          def #{m}
+            @headers["#{header_name}"]
+          end
+          RUBY
+        end
+        header_value
       else
         super
       end
@@ -40,16 +59,6 @@ module Webmachine
       !(body.nil? || body.empty?)
     end
 
-    # The root URI for the request, ignoring path and query. This is
-    # useful for calculating relative paths to resources.
-    # @return [URI]
-    def base_uri
-      @base_uri ||= uri.dup.tap do |u|
-        u.path = "/"
-        u.query = nil
-      end
-    end
-
     # Returns a hash of query parameters (they come after the ? in the
     # URI). Note that this does NOT work in the same way as Rails,
     # i.e. it does not support nested arrays and hashes.
@@ -92,7 +101,7 @@ module Webmachine
     # @return [Boolean]
     #   true if this request was made with the GET method
     def get?
-      method == "GET"
+      method == GET_METHOD
     end
 
     # Is this a HEAD request?
@@ -100,7 +109,7 @@ module Webmachine
     # @return [Boolean]
     #   true if this request was made with the HEAD method
     def head?
-      method == "HEAD"
+      method == HEAD_METHOD
     end
 
     # Is this a POST request?
@@ -108,7 +117,7 @@ module Webmachine
     # @return [Boolean]
     #   true if this request was made with the GET method
     def post?
-      method == "POST"
+      method == POST_METHOD
     end
 
     # Is this a PUT request?
@@ -116,7 +125,7 @@ module Webmachine
     # @return [Boolean]
     #   true if this request was made with the PUT method
     def put?
-      method == "PUT"
+      method == PUT_METHOD
     end
 
     # Is this a DELETE request?
@@ -124,7 +133,7 @@ module Webmachine
     # @return [Boolean]
     #   true if this request was made with the DELETE method
     def delete?
-      method == "DELETE"
+      method == DELETE_METHOD
     end
 
     # Is this a TRACE request?
@@ -132,7 +141,7 @@ module Webmachine
     # @return [Boolean]
     #   true if this request was made with the TRACE method
     def trace?
-      method == "TRACE"
+      method == TRACE_METHOD
     end
 
     # Is this a CONNECT request?
@@ -140,7 +149,7 @@ module Webmachine
     # @return [Boolean]
     #   true if this request was made with the CONNECT method
     def connect?
-      method == "CONNECT"
+      method == CONNECT_METHOD
     end
 
     # Is this an OPTIONS request?
@@ -148,7 +157,39 @@ module Webmachine
     # @return [Boolean]
     #   true if this request was made with the OPTIONS method
     def options?
-      method == "OPTIONS"
+      method == OPTIONS_METHOD
+    end
+
+    private
+
+    IPV6_MATCH = /\A\[(?<address> .* )\]:(?<port> \d+ )\z/x.freeze  # string like "[::1]:80"
+    HOST_MATCH = /\A(?<host> [^:]+ ):(?<port> \d+ )\z/x.freeze      # string like "www.example.com:80"
+
+    def parse_host(uri, host_string)
+      # Split host and port number from string.
+      case host_string
+      when IPV6_MATCH
+        uri.host = IPAddr.new($~[:address], Socket::AF_INET6).to_s
+        uri.port = $~[:port].to_i
+      when HOST_MATCH
+        uri.host = $~[:host]
+        uri.port = $~[:port].to_i
+      else # string with no port number
+        uri.host = host_string
+      end
+
+      uri
+    end
+
+    def build_uri(uri, headers)
+      uri = URI(uri)
+      uri.port ||= 80
+      uri.scheme ||= HTTP
+      if uri.host
+        return uri
+      end
+
+      parse_host(uri, headers.fetch(HOST))
     end
 
   end # class Request

data/lib/webmachine/rescueable_exception.rb

@@ -0,0 +1,62 @@
+module Webmachine::RescuableException
+  require_relative 'errors'
+  require 'set'
+
+  UNRESCUABLE_DEFAULTS =  [
+    Webmachine::MalformedRequest,
+    NoMemoryError, SystemExit, SignalException
+  ].freeze
+
+  UNRESCUABLE = Set.new UNRESCUABLE_DEFAULTS.dup
+  private_constant :UNRESCUABLE
+
+  def self.===(e)
+    case e
+    when *UNRESCUABLE then false
+    else true
+    end
+  end
+
+  #
+  # Remove modifications to Webmachine::RescuableException.
+  # Restores default list of unrescue-able exceptions.
+  #
+  # @return [nil]
+  #
+  def self.default!
+    UNRESCUABLE.replace Set.new(UNRESCUABLE_DEFAULTS.dup)
+    nil
+  end
+
+  #
+  # @return [Array<Exception>]
+  #   Returns an Array of exceptions that will not be
+  #   rescued by {Webmachine::Resource#handle_exception}.
+  #
+  def self.UNRESCUABLEs
+    UNRESCUABLE.to_a
+  end
+
+  #
+  # Add a variable number of exceptions that should be rescued by
+  # {Webmachine::Resource#handle_exception}. See {UNRESCUABLE_DEFAULTS}
+  # for a list of exceptions that are not caught by default.
+  #
+  # @param (see #remove)
+  #
+  def self.add(*exceptions)
+    exceptions.each{|e| UNRESCUABLE.delete(e)}
+  end
+
+  #
+  # Remove a variable number of exceptions from being rescued by
+  # {Webmachine::Resource#handle_exception}. See {UNRESCUABLE_DEFAULTS}
+  # for a list of exceptions that are not caught by default.
+  #
+  # @param [Exception] *exceptions
+  #   A subclass of Exception.
+  #
+  def self.remove(*exceptions)
+    exceptions.each{|e| UNRESCUABLE.add(e)}
+  end
+end

data/lib/webmachine/resource.rb

@@ -53,7 +53,7 @@ module Webmachine
       resource = self
       Application.new do |app|
         app.routes do |router|
-          router.add ["*"], resource
+          router.add [:*], resource
         end
       end.run
     end

data/lib/webmachine/resource/callbacks.rb

@@ -1,3 +1,5 @@
+require 'webmachine/constants'
+
 module Webmachine
   class Resource
     # These methods are the primary way your {Webmachine::Resource}
@@ -101,7 +103,7 @@ module Webmachine
       # If the entity length on PUT or POST is invalid, this should
       # return false, which will result in a '413 Request Entity Too
       # Large' response. Defaults to true.
-      # @param [Fixnum] length the size of the request body (entity)
+      # @param [Integer] length the size of the request body (entity)
       # @return [true,false] Whether the body is a valid length (not too
       #    large)
       # @api callback
@@ -123,7 +125,7 @@ module Webmachine
       # @return [Array<String>] allowed methods on this resource
       # @api callback
       def allowed_methods
-        ['GET', 'HEAD']
+        [GET_METHOD, HEAD_METHOD]
       end
 
       # HTTP methods that are known to the resource. Like
@@ -134,7 +136,7 @@ module Webmachine
       # @return [Array<String>] known methods
       # @api callback
       def known_methods
-        ['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'TRACE', 'CONNECT', 'OPTIONS']
+        STANDARD_HTTP_METHODS
       end
 
       # This method is called when a DELETE request should be enacted,
@@ -190,7 +192,7 @@ module Webmachine
 
       # If post_is_create? returns false, then this will be called to
       # process any POST request. If it succeeds, it should return true.
-      # @return [true,false,Fixnum] Whether the POST was successfully
+      # @return [true,false,Integer] Whether the POST was successfully
       #    processed, or an alternate response code
       # @api callback
       def process_post
@@ -209,7 +211,7 @@ module Webmachine
       # @return an array of mediatype/handler pairs
       # @api callback
       def content_types_provided
-        [['text/html', :to_html]]
+        [[TEXT_HTML, :to_html]]
       end
 
       # Similarly to content_types_provided, this should return an array
@@ -263,7 +265,7 @@ module Webmachine
       # @api callback
       # @see Encodings
       def encodings_provided
-        {"identity" => :encode_identity }
+        {IDENTITY => :encode_identity }
       end
 
       # If this method is implemented, it should return a list of
@@ -361,11 +363,11 @@ module Webmachine
       def finish_request; end
 
       #
-      # This method is called when an exception is raised within a subclass of
+      # This method is called when an error is raised within a subclass of
       # {Webmachine::Resource}.
       #
-      # @param [Exception] e
-      #   The exception.
+      # @param [StandardError] e
+      #   The error.
       #
       # @return [void]
       #

data/lib/webmachine/response.rb

@@ -4,7 +4,7 @@ module Webmachine
     # @return [HeaderHash] Response headers that will be sent to the client
     attr_reader :headers
 
-    # @return [Fixnum] The HTTP status code of the response
+    # @return [Integer] The HTTP status code of the response
     attr_accessor :code
 
     # @return [String, #each] The response body
@@ -48,11 +48,9 @@ module Webmachine
       cookie = Webmachine::Cookie.new(name, value, attributes).to_s
       case headers['Set-Cookie']
       when nil
-        headers['Set-Cookie'] = cookie
-      when String
-        headers['Set-Cookie'] = [headers['Set-Cookie'], cookie]
+        headers['Set-Cookie'] = [cookie]
       when Array
-        headers['Set-Cookie'] = headers['Set-Cookie'] + cookie
+        headers['Set-Cookie'] << cookie
       end
     end
 

data/lib/webmachine/spec/IO_response.body

@@ -0,0 +1 @@
+IO response body

data/lib/webmachine/spec/adapter_lint.rb

@@ -1,44 +1,92 @@
-require "webmachine/spec/test_resource"
+require "webmachine/spec/test_resource"
 require "net/http"
 
+ADDRESS = "127.0.0.1"
+
 shared_examples_for :adapter_lint do
-  attr_accessor :client
+  attr_reader :client
 
-  before(:all) do
-    configuration = Webmachine::Configuration.default
-    dispatcher = Webmachine::Dispatcher.new
-    dispatcher.add_route ["test"], Test::Resource
+  class TestApplicationNotResponsive < Timeout::Error; end
+
+  def find_free_port
+    temp_server = TCPServer.new(ADDRESS, 0)
+    port = temp_server.addr[1]
+    temp_server.close # only frees Ruby resource, socket is in TIME_WAIT at OS level
+                      # so we can't have our adapter use it too quickly
 
-    @adapter = described_class.new(configuration, dispatcher)
-    @client = Net::HTTP.new(configuration.ip, configuration.port)
+    sleep(0.1)        # 'Wait' for temp_server to *really* close, not just TIME_WAIT
+    port
+  end
+
+  def create_test_application(port)
+    Webmachine::Application.new.tap do |application|
+      application.dispatcher.add_route ["test"], Test::Resource
 
+      application.configure do |c|
+        c.ip   = ADDRESS
+        c.port = port
+      end
+    end
+  end
+
+  def run_application(adapter_class, application)
+    adapter = adapter_class.new(application)
     Thread.abort_on_exception = true
-    @server_thread = Thread.new { @adapter.run }
+    Thread.new { adapter.run }
+  end
 
-    # Wait until the server is responsive
-    timeout(5) do
+  def wait_until_server_responds_to(client)
+    Timeout.timeout(5, TestApplicationNotResponsive) do
       begin
         client.start
       rescue Errno::ECONNREFUSED
-        sleep(0.1)
+        sleep(0.01)
         retry
       end
     end
   end
 
+  before(:all) do
+    @port = find_free_port
+    application = create_test_application(@port)
+
+    adapter_class = described_class
+    @server_thread = run_application(adapter_class, application)
+
+    @client = Net::HTTP.new(application.configuration.ip, @port)
+    wait_until_server_responds_to(client)
+  end
+
   after(:all) do
-    @adapter.shutdown
     @client.finish
-    @server_thread.join
+    @server_thread.kill
+  end
+
+  it "provides the request URI" do
+    request = Net::HTTP::Get.new("/test")
+    request["Accept"] = "test/response.request_uri"
+    response = client.request(request)
+    expect(response.body).to eq("http://#{ADDRESS}:#{@port}/test")
   end
 
+  # context do
+  #   let(:address) { "::1" }
+
+  #   it "provides the IPv6 request URI" do
+  #     request = Net::HTTP::Get.new("/test")
+  #     request["Accept"] = "test/response.request_uri"
+  #     response = client.request(request)
+  #     expect(response.body).to eq("http://[#{address}]:#{port}/test")
+  #   end
+  # end
+
   it "provides a string-like request body" do
     request = Net::HTTP::Put.new("/test")
     request.body = "Hello, World!"
     request["Content-Type"] = "test/request.stringbody"
     response = client.request(request)
-    response["Content-Length"].should eq("21")
-    response.body.should eq("String: Hello, World!")
+    expect(response["Content-Length"]).to eq("21")
+    expect(response.body).to eq("String: Hello, World!")
   end
 
   it "provides an enumerable request body" do
@@ -46,66 +94,64 @@ shared_examples_for :adapter_lint do
     request.body = "Hello, World!"
     request["Content-Type"] = "test/request.enumbody"
     response = client.request(request)
-    response["Content-Length"].should eq("19")
-    response.body.should eq("Enum: Hello, World!")
+    expect(response["Content-Length"]).to eq("19")
+    expect(response.body).to eq("Enum: Hello, World!")
   end
 
   it "handles missing pages" do
     request = Net::HTTP::Get.new("/missing")
     response = client.request(request)
-    response.code.should eq("404")
-    response["Content-Type"].should eq("text/html")
+    expect(response.code).to eq("404")
+    expect(response["Content-Type"]).to eq("text/html")
   end
 
   it "handles empty response bodies" do
     request = Net::HTTP::Post.new("/test")
     request.body = ""
     response = client.request(request)
-    response.code.should eq("204")
-    # FIXME: Mongrel/WEBrick fail this test. Is there a bug?
-    #response["Content-Type"].should be_nil
-    response["Content-Length"].should be_nil
-    response.body.should be_nil
+    expect(response.code).to eq("204")
+    expect(["0", nil]).to include(response["Content-Length"])
+    expect(response.body).to be_nil
   end
 
   it "handles string response bodies" do
     request = Net::HTTP::Get.new("/test")
     request["Accept"] = "test/response.stringbody"
     response = client.request(request)
-    response["Content-Length"].should eq("20")
-    response.body.should eq("String response body")
+    expect(response["Content-Length"]).to eq("20")
+    expect(response.body).to eq("String response body")
   end
 
   it "handles enumerable response bodies" do
     request = Net::HTTP::Get.new("/test")
     request["Accept"] = "test/response.enumbody"
     response = client.request(request)
-    response["Transfer-Encoding"].should eq("chunked")
-    response.body.should eq("Enumerable response body")
+    expect(response["Transfer-Encoding"]).to eq("chunked")
+    expect(response.body).to eq("Enumerable response body")
   end
 
   it "handles proc response bodies" do
     request = Net::HTTP::Get.new("/test")
     request["Accept"] = "test/response.procbody"
     response = client.request(request)
-    response["Transfer-Encoding"].should eq("chunked")
-    response.body.should eq("Proc response body")
+    expect(response["Transfer-Encoding"]).to eq("chunked")
+    expect(response.body).to eq("Proc response body")
   end
 
   it "handles fiber response bodies" do
     request = Net::HTTP::Get.new("/test")
     request["Accept"] = "test/response.fiberbody"
     response = client.request(request)
-    response["Transfer-Encoding"].should eq("chunked")
-    response.body.should eq("Fiber response body")
+    expect(response["Transfer-Encoding"]).to eq("chunked")
+    expect(response.body).to eq("Fiber response body")
   end
 
   it "handles io response bodies" do
     request = Net::HTTP::Get.new("/test")
     request["Accept"] = "test/response.iobody"
     response = client.request(request)
-    response["Content-Length"].should eq("16")
-    response.body.should eq("IO response body")
+    expect(response["Content-Length"]).to eq("17")
+    expect(response.body).to eq("IO response body\n")
   end
 
   it "handles request cookies" do
@@ -113,13 +159,13 @@ shared_examples_for :adapter_lint do
     request["Accept"] = "test/response.cookies"
     request["Cookie"] = "echo=echocookie"
     response = client.request(request)
-    response.body.should eq("echocookie")
+    expect(response.body).to eq("echocookie")
   end
 
   it "handles response cookies" do
     request = Net::HTTP::Get.new("/test")
     request["Accept"] = "test/response.cookies"
     response = client.request(request)
-    response["Set-Cookie"].should eq("cookie=monster, rodeo=clown")
+    expect(response["Set-Cookie"]).to eq("cookie=monster, rodeo=clown")
   end
 end