webmachine 1.2.2 → 1.6.0

data/lib/webmachine/decision/helpers.rb

@@ -1,9 +1,11 @@
-require 'stringio'
+require 'stringio'
 require 'time'
 require 'webmachine/streaming'
 require 'webmachine/media_type'
 require 'webmachine/quoted_string'
 require 'webmachine/etags'
+require 'webmachine/header_negotiation'
+require 'webmachine/constants'
 
 module Webmachine
   module Decision
@@ -11,6 +13,7 @@ module Webmachine
     module Helpers
       include QuotedString
       include Streaming
+      include HeaderNegotiation
 
       # Determines if the response has a body/entity set.
       def has_response_body?
@@ -26,8 +29,8 @@ module Webmachine
       # Encodes the body in the selected charset and encoding.
       def encode_body
         body = response.body
-        chosen_charset = metadata['Charset']
-        chosen_encoding = metadata['Content-Encoding']
+        chosen_charset = metadata[CHARSET]
+        chosen_encoding = metadata[CONTENT_ENCODING]
         charsetter = resource.charsets_provided && resource.charsets_provided.find {|c,_| c == chosen_charset }.last || :charset_nop
         encoder = resource.encodings_provided[chosen_encoding]
         response.body = case body
@@ -47,10 +50,10 @@ module Webmachine
                           end
                         end
         if body_is_fixed_length?
-          set_content_length
+          ensure_content_length(response)
         else
-          response.headers.delete 'Content-Length'
-          response.headers['Transfer-Encoding'] = 'chunked'
+          response.headers.delete CONTENT_LENGTH
+          response.headers[TRANSFER_ENCODING] = 'chunked'
         end
       end
 
@@ -88,42 +91,11 @@ module Webmachine
         end
       end
 
-      # Ensures that responses have an appropriate Content-Length
-      # header
-      def ensure_content_length
-        case
-        when response.headers['Transfer-Encoding']
-          return
-        when [204, 205, 304].include?(response.code)
-          response.headers.delete 'Content-Length'
-        when has_response_body?
-          set_content_length
-        else
-          response.headers['Content-Length'] = '0'
-        end
-      end
-
-      # Ensures that responses have an appropriate Date header
-      def ensure_date_header
-        if (200..499).include?(response.code)
-          response.headers['Date'] ||= Time.now.httpdate
-        end
-      end
-
-      # Sets the Content-Length header on the response
-      def set_content_length
-        if response.body.respond_to?(:bytesize)
-          response.headers['Content-Length'] = response.body.bytesize.to_s
-        else
-          response.headers['Content-Length'] = response.body.length.to_s
-        end
-      end
-
       # Determines whether the response is of a fixed lenghth, i.e. it
       # is a String or IO with known size.
       def body_is_fixed_length?
         response.body.respond_to?(:bytesize) &&
-          Fixnum === response.body.bytesize
+          Integer === response.body.bytesize
       end
     end # module Helpers
   end # module Decision

data/lib/webmachine/dispatcher.rb

@@ -1,12 +1,13 @@
-require 'forwardable'
+require 'forwardable'
 require 'webmachine/decision'
 require 'webmachine/dispatcher/route'
-require 'webmachine/dispatcher/not_found_resource'
 
 module Webmachine
   # Handles dispatching incoming requests to the proper registered
   # resources and initializing the decision logic.
   class Dispatcher
+    WM_DISPATCH = 'wm.dispatch'.freeze
+
     # @return [Array<Route>] the list of routes that will be
     #   dispatched to
     # @see #add_route
@@ -40,12 +41,16 @@ module Webmachine
     # @param [Request] request the request object
     # @param [Response] response the response object
     def dispatch(request, response)
-      resource = find_resource(request, response)
-      Webmachine::Events.instrument('wm.dispatch') do |payload|
-        Webmachine::Decision::FSM.new(resource, request, response).run
-        payload[:resource] = resource.class.name
-        payload[:request] = request.dup
-        payload[:code] = response.code
+      if resource = find_resource(request, response)
+        Webmachine::Events.instrument(WM_DISPATCH) do |payload|
+          Webmachine::Decision::FSM.new(resource, request, response).run
+
+          payload[:resource] = resource.class.name
+          payload[:request] = request.dup
+          payload[:code] = response.code
+        end
+      else
+        Webmachine.render_error(404, request, response)
       end
     end
 
@@ -61,8 +66,6 @@ module Webmachine
     def find_resource(request, response)
       if route = find_route(request)
         prepare_resource(route, request, response)
-      else
-        NotFoundResource.new(request, response)
       end
     end
 

data/lib/webmachine/dispatcher/route.rb

@@ -1,12 +1,13 @@
-require 'webmachine/resource'
+require 'webmachine/resource'
 require 'webmachine/translation'
+require 'webmachine/constants'
 
 module Webmachine
   class Dispatcher
     # Pairs URIs with {Resource} classes in the {Dispatcher}. To
     # create routes, use {Dispatcher#add_route}.
     class Route
-      include Webmachine::Translation
+      include Translation
 
       # @return [Class] the resource this route will dispatch to, a
       #   subclass of {Resource}
@@ -22,13 +23,16 @@ module Webmachine
 
       # When used in a path specification, will match all remaining
       # segments
-      MATCH_ALL = '*'.freeze
+      MATCH_ALL = :*
+
+      # String version of MATCH_ALL, deprecated. Use the symbol instead.
+      MATCH_ALL_STR = '*'.freeze
 
       # Creates a new Route that will associate a pattern to a
       # {Resource}.
       #
       # @example Standard route
-      #   Route.new(["*"], MyResource)
+      #   Route.new([:*], MyResource)
       #
       # @example Guarded route
       #   Route.new ["/notes"],
@@ -65,6 +69,8 @@ module Webmachine
         guards = args
         guards << Proc.new if block_given?
 
+        warn t('match_all_symbol') if path_spec.include? MATCH_ALL_STR
+
         @path_spec = path_spec
         @guards    = guards
         @resource  = resource
@@ -77,7 +83,7 @@ module Webmachine
       # should be dispatched to the {#resource}.
       # @param [Reqeust] request the request object
       def match?(request)
-        tokens = request.uri.path.match(/^\/(.*)/)[1].split('/')
+        tokens = request.routing_tokens
         bind(tokens, {}) && guards.all? { |guard| guard.call(request) }
       end
 
@@ -85,9 +91,9 @@ module Webmachine
       # route, including path bindings.
       # @param [Request] request the request object
       def apply(request)
-        request.disp_path = request.uri.path.match(/^\/(.*)/)[1]
+        request.disp_path = request.routing_tokens.join(SLASH)
         request.path_info = @bindings.dup
-        tokens = request.disp_path.split('/')
+        tokens = request.routing_tokens
         depth, trailing = bind(tokens, request.path_info)
         request.path_tokens = trailing || []
       end
@@ -97,7 +103,7 @@ module Webmachine
       # accumulating variable bindings.
       # @param [Array<String>] tokens the list of path segments
       # @param [Hash] bindings where path bindings will be stored
-      # @return [Fixnum, Array<Fixnum, Array>, false] either the depth
+      # @return [Integer, Array<Integer, Array>, false] either the depth
       #   that the path matched at, the depth and tokens matched by
       #   {MATCH_ALL}, or false if it didn't match.
       def bind(tokens, bindings)
@@ -107,12 +113,28 @@ module Webmachine
           case
           when spec.empty? && tokens.empty?
             return depth
+          when spec == [MATCH_ALL_STR]
+            return [depth, tokens]
           when spec == [MATCH_ALL]
             return [depth, tokens]
           when tokens.empty?
             return false
+          when Regexp === spec.first
+            matches = spec.first.match Route.rfc3986_percent_decode(tokens.first)
+            if matches
+              if spec.first.named_captures.empty?
+                bindings[:captures] = (bindings[:captures] || []) + matches.captures
+              else
+                spec.first.named_captures.reduce(bindings) do |bindings, (name, idxs)|
+                  bindings[name.to_sym] = matches.captures[idxs.first-1]
+                  bindings
+                end
+              end
+            else
+              return false
+            end
           when Symbol === spec.first
-            bindings[spec.first] = tokens.first
+            bindings[spec.first] = Route.rfc3986_percent_decode(tokens.first)
           when spec.first == tokens.first
           else
             return false
@@ -123,6 +145,20 @@ module Webmachine
         end
       end
 
+      # Decode a string using the scheme described in RFC 3986 2.1. Percent-Encoding (https://www.ietf.org/rfc/rfc3986.txt)
+      def self.rfc3986_percent_decode(value)
+        s = StringScanner.new(value)
+        result = ''
+        until s.eos?
+          encoded_val = s.scan(/%([0-9a-fA-F]){2}/)
+          result << if encoded_val.nil?
+            s.getch
+          else
+            [encoded_val[1..-1]].pack('H*')
+          end
+        end
+        result
+      end
     end # class Route
   end # module Dispatcher
 end # module Webmachine

data/lib/webmachine/errors.rb

@@ -1,12 +1,15 @@
+require 'webmachine/header_negotiation'
 require 'webmachine/translation'
+require 'webmachine/constants'
 require 'webmachine/version'
 
 module Webmachine
+  extend HeaderNegotiation
   extend Translation
 
   # Renders a standard error message body for the response. The
   # standard messages are defined in localization files.
-  # @param [Fixnum] code the response status code
+  # @param [Integer] code the response status code
   # @param [Request] req the request object
   # @param [Response] req the response object
   # @param [Hash] options keys to override the defaults when rendering
@@ -21,10 +24,13 @@ module Webmachine
                    {:title => title,
                      :message => message,
                      :version => Webmachine::SERVER_STRING}.merge(options))
-      res.headers['Content-Type'] = "text/html"
+      res.headers[CONTENT_TYPE] = TEXT_HTML
     end
+    ensure_content_length(res)
+    ensure_date_header(res)
   end
 
+
   # Superclass of all errors generated by Webmachine.
   class Error < ::StandardError; end
 
@@ -33,6 +39,6 @@ module Webmachine
 
   # Raised when the client has submitted an invalid request, e.g. in
   # the case where a request header is improperly formed. Raising this
-  # exception will result in a 400 response.
+  # error will result in a 400 response.
   class MalformedRequest < Error; end
 end # module Webmachine

data/lib/webmachine/events.rb

@@ -55,9 +55,9 @@ module Webmachine
       # and publish it. Notice that events get sent even if an error occurs
       # in the passed-in block.
       #
-      # If an exception happens during an instrumentation the payload will
+      # If an error happens during an instrumentation the payload will
       # have a key `:exception` with an array of two elements as value:
-      # a string with the name of the exception class, and the exception
+      # a string with the name of the error class, and the error
       # message. (when using the default
       # [AS::Notifications](http://rubydoc.info/gems/as-notifications/AS/Notifications)
       # backend)

data/lib/webmachine/header_negotiation.rb

@@ -0,0 +1,25 @@
+require 'webmachine/constants'
+
+module Webmachine
+  module HeaderNegotiation
+    def ensure_date_header(res)
+      if (200..499).include?(res.code)
+        res.headers[DATE] ||= Time.now.httpdate
+      end
+    end
+
+    def ensure_content_length(res)
+      body = res.body
+      case
+      when res.headers[TRANSFER_ENCODING]
+        return
+      when [204, 205, 304].include?(res.code)
+        res.headers.delete CONTENT_LENGTH
+      when body != nil
+        res.headers[CONTENT_LENGTH] = body.respond_to?(:bytesize) ? body.bytesize.to_s : body.length.to_s
+      else
+        res.headers[CONTENT_LENGTH] = '0'
+      end
+    end
+  end
+end

data/lib/webmachine/headers.rb

@@ -1,13 +1,18 @@
+require 'webmachine/constants'
+
 module Webmachine
   # Case-insensitive Hash of Request headers
   class Headers < ::Hash
+    CGI_HTTP_MATCH = /^HTTP_(\w+)$/.freeze
+    CONTENT_TYPE_LENGTH_MATCH = /^(CONTENT_(?:TYPE|LENGTH))$/.freeze
+
     # Convert CGI-style Hash into Request headers
     # @param [Hash] env a hash of CGI-style env/headers
     # @return [Webmachine::Headers]
     def self.from_cgi(env)
       env.inject(new) do |h,(k,v)|
-        if k =~ /^HTTP_(\w+)$/ || k =~ /^(CONTENT_(?:TYPE|LENGTH))$/
-          h[$1.tr("_", "-")] = v
+        if k =~ CGI_HTTP_MATCH || k =~ CONTENT_TYPE_LENGTH_MATCH
+          h[$1.tr(UNDERSCORE, DASH)] = v
         end
         h
       end
@@ -43,7 +48,7 @@ module Webmachine
 
     # Returns the value for the given key. If the key can't be found,
     # there are several options:
-    # With no other arguments, it will raise a KeyError exception;
+    # With no other arguments, it will raise a KeyError error;
     # if default is given, then that will be returned;
     # if the optional code block is specified, then that will be run and its
     # result returned.

data/lib/webmachine/locale/en.yml

@@ -1,10 +1,11 @@
 en:
   webmachine:
     errors:
-      standard_body: "<!DOCTYPE html><html>
-        <head><title>%{title}</title></head>
-        <body><h1>%{title}</h1><p>%{message}</p>
-        <address>%{version} server</address></body></html>"
+      standard_body: "<!DOCTYPE html><html>\n
+        <head><title>%{title}</title></head>\n
+        <body><h1>%{title}</h1>\n
+        <p>%{message}</p>\n
+        <address>%{version} server</address></body></html>\n"
       "400":
         title: 400 Malformed Request
         message: The request was malformed and could not be processed.
@@ -13,7 +14,7 @@ en:
         message: The requested document was not found on this server.
       "500":
         title: 500 Internal Server Error
-        message: "The server encountered an error while processing this request: <pre>%{error}</pre>"
+        message: "The server encountered an error while processing this request: <pre>\n%{error}</pre>"
       "501":
         title: 501 Not Implemented
         message: "The server does not support the %{method} method."
@@ -26,3 +27,4 @@ en:
     invalid_media_type: "Invalid media type: %{type}"
     not_resource_class: "%{class} is not a subclass of Webmachine::Resource"
     process_post_invalid: "process_post returned %{result}"
+    match_all_symbol: '"*" as a path segment is deprecated and will be removed in a future release. Please use :*'

data/lib/webmachine/media_type.rb

@@ -1,14 +1,16 @@
-require 'webmachine/translation'
+require 'webmachine/translation'
+require 'webmachine/constants'
+require 'webmachine/dispatcher/route'
 
 module Webmachine
   # Encapsulates a MIME media type, with logic for matching types.
   class MediaType
     extend Translation
     # Matches valid media types
-    MEDIA_TYPE_REGEX = /^\s*([^;\s]+)\s*((?:;\s*\S+\s*)*)\s*$/
+    MEDIA_TYPE_REGEX = /^\s*([^;\s]+)\s*((?:;\s*\S+\s*)*)\s*$/.freeze
 
     # Matches sub-type parameters
-    PARAMS_REGEX = /;\s*([^=]+)(=([^;=\s]*))?/
+    PARAMS_REGEX = /;\s*([^=]+)(=([^;=\s]*))?/.freeze
 
     # Creates a new MediaType by parsing an alternate representation.
     # @param [MediaType, String, Array<String,Hash>] obj the raw type
@@ -48,7 +50,7 @@ module Webmachine
     # Detects whether the {MediaType} represents an open wildcard
     # type, that is, "*/*" without any {#params}.
     def matches_all?
-      @type == "*/*" && @params.empty?
+      @type == MATCHES_ALL && @params.empty?
     end
 
     # @return [true,false] Are these two types strictly equal?
@@ -97,12 +99,12 @@ module Webmachine
 
     # @return [String] The major type, e.g. "application", "text", "image"
     def major
-      type.split("/").first
+      type.split(SLASH).first
     end
 
     # @return [String] the minor or sub-type, e.g. "json", "html", "jpeg"
     def minor
-      type.split("/").last
+      type.split(SLASH).last
     end
 
     # @param [MediaType] other the other type
@@ -110,10 +112,10 @@ module Webmachine
     #   ignoring params and taking into account wildcards
     def type_matches?(other)
       other = self.class.parse(other)
-      if ["*", "*/*", type].include?(other.type)
+      if [Dispatcher::Route::MATCH_ALL_STR, MATCHES_ALL, type].include?(other.type)
         true
       else
-        other.major == major && other.minor == "*"
+        other.major == major && other.minor == Dispatcher::Route::MATCH_ALL_STR
       end
     end
   end # class MediaType