RubyGems - webmachine - Versions diffs - 0.1.0 → 0.2.0 - Mend

webmachine 0.1.0 → 0.2.0

Files changed (63) hide show

data/Gemfile +11 -3
data/README.md +55 -27
data/lib/webmachine/adapters/mongrel.rb +84 -0
data/lib/webmachine/adapters/webrick.rb +12 -3
data/lib/webmachine/adapters.rb +1 -7
data/lib/webmachine/configuration.rb +30 -0
data/lib/webmachine/decision/conneg.rb +7 -72
data/lib/webmachine/decision/flow.rb +13 -11
data/lib/webmachine/decision/fsm.rb +1 -9
data/lib/webmachine/decision/helpers.rb +27 -7
data/lib/webmachine/errors.rb +1 -0
data/lib/webmachine/headers.rb +12 -3
data/lib/webmachine/locale/en.yml +2 -2
data/lib/webmachine/media_type.rb +117 -0
data/lib/webmachine/resource/callbacks.rb +9 -0
data/lib/webmachine/streaming.rb +3 -3
data/lib/webmachine/version.rb +1 -1
data/lib/webmachine.rb +3 -1
data/pkg/webmachine-0.1.0/Gemfile +16 -0
data/pkg/webmachine-0.1.0/Guardfile +11 -0
data/pkg/webmachine-0.1.0/README.md +90 -0
data/pkg/webmachine-0.1.0/Rakefile +31 -0
data/pkg/webmachine-0.1.0/examples/webrick.rb +19 -0
data/pkg/webmachine-0.1.0/lib/webmachine/adapters/webrick.rb +74 -0
data/pkg/webmachine-0.1.0/lib/webmachine/adapters.rb +15 -0
data/pkg/webmachine-0.1.0/lib/webmachine/decision/conneg.rb +304 -0
data/pkg/webmachine-0.1.0/lib/webmachine/decision/flow.rb +502 -0
data/pkg/webmachine-0.1.0/lib/webmachine/decision/fsm.rb +79 -0
data/pkg/webmachine-0.1.0/lib/webmachine/decision/helpers.rb +80 -0
data/pkg/webmachine-0.1.0/lib/webmachine/decision.rb +12 -0
data/pkg/webmachine-0.1.0/lib/webmachine/dispatcher/route.rb +85 -0
data/pkg/webmachine-0.1.0/lib/webmachine/dispatcher.rb +40 -0
data/pkg/webmachine-0.1.0/lib/webmachine/errors.rb +37 -0
data/pkg/webmachine-0.1.0/lib/webmachine/headers.rb +16 -0
data/pkg/webmachine-0.1.0/lib/webmachine/locale/en.yml +28 -0
data/pkg/webmachine-0.1.0/lib/webmachine/request.rb +56 -0
data/pkg/webmachine-0.1.0/lib/webmachine/resource/callbacks.rb +362 -0
data/pkg/webmachine-0.1.0/lib/webmachine/resource/encodings.rb +36 -0
data/pkg/webmachine-0.1.0/lib/webmachine/resource.rb +48 -0
data/pkg/webmachine-0.1.0/lib/webmachine/response.rb +49 -0
data/pkg/webmachine-0.1.0/lib/webmachine/streaming.rb +27 -0
data/pkg/webmachine-0.1.0/lib/webmachine/translation.rb +11 -0
data/pkg/webmachine-0.1.0/lib/webmachine/version.rb +4 -0
data/pkg/webmachine-0.1.0/lib/webmachine.rb +19 -0
data/pkg/webmachine-0.1.0/spec/spec_helper.rb +13 -0
data/pkg/webmachine-0.1.0/spec/tests.org +57 -0
data/pkg/webmachine-0.1.0/spec/webmachine/decision/conneg_spec.rb +152 -0
data/pkg/webmachine-0.1.0/spec/webmachine/decision/flow_spec.rb +1030 -0
data/pkg/webmachine-0.1.0/spec/webmachine/dispatcher/route_spec.rb +109 -0
data/pkg/webmachine-0.1.0/spec/webmachine/dispatcher_spec.rb +34 -0
data/pkg/webmachine-0.1.0/spec/webmachine/headers_spec.rb +19 -0
data/pkg/webmachine-0.1.0/spec/webmachine/request_spec.rb +24 -0
data/pkg/webmachine-0.1.0/webmachine.gemspec +44 -0
data/pkg/webmachine-0.1.0.gem +0 -0
data/spec/webmachine/configuration_spec.rb +27 -0
data/spec/webmachine/decision/conneg_spec.rb +18 -11
data/spec/webmachine/decision/flow_spec.rb +2 -0
data/spec/webmachine/decision/helpers_spec.rb +105 -0
data/spec/webmachine/errors_spec.rb +13 -0
data/spec/webmachine/headers_spec.rb +2 -1
data/spec/webmachine/media_type_spec.rb +78 -0
data/webmachine.gemspec +4 -1
metadata +69 -11

data/pkg/webmachine-0.1.0/examples/webrick.rb ADDED Viewed

@@ -0,0 +1,19 @@
+require 'webmachine'
+class HelloResource < Webmachine::Resource
+  def last_modified
+    File.mtime(__FILE__)
+  end
+  def encodings_provided
+    { "gzip" => :encode_gzip, "identity" => :encode_identity }
+  end
+  def to_html
+    "<html><head><title>Hello from Webmachine</title></head><body>Hello, world!</body></html>"
+  end
+end
+Webmachine::Dispatcher.add_route([], HelloResource)
+Webmachine.run

data/pkg/webmachine-0.1.0/lib/webmachine/adapters/webrick.rb ADDED Viewed

@@ -0,0 +1,74 @@
+require 'webrick'
+require 'webmachine/version'
+require 'webmachine/headers'
+require 'webmachine/request'
+require 'webmachine/response'
+require 'webmachine/dispatcher'
+module Webmachine
+  module Adapters
+    # Connects Webmachine to WEBrick.
+    module WEBrick
+      # Starts the WEBrick adapter
+      def self.run
+        server = Webmachine::Adapters::WEBrick::Server.new :Port => 3000
+        trap("INT"){ server.shutdown }
+        Thread.new { server.start }.join
+      end
+      class Server < ::WEBrick::HTTPServer
+        def service(wreq, wres)
+          header = Webmachine::Headers.new
+          wreq.each {|k,v| header[k] = v }
+          request = Webmachine::Request.new(wreq.request_method,
+                                            wreq.request_uri,
+                                            header,
+                                            RequestBody.new(wreq))
+          response = Webmachine::Response.new
+          Webmachine::Dispatcher.dispatch(request, response)
+          wres.status = response.code.to_i
+          response.headers.each do |k,v|
+            wres[k] = v
+          end
+          wres['Server'] = [Webmachine::SERVER_STRING, wres.config[:ServerSoftware]].join(" ")
+          case response.body
+          when String
+            wres.body << response.body
+          when Enumerable
+            response.body.each {|part| wres.body << part }
+          when response.body.respond_to?(:call)
+            wres.body << response.body.call
+          end
+        end
+      end
+      # Wraps the WEBrick request body so that it can be passed to
+      # {Request} while still lazily evaluating the body.
+      class RequestBody
+        def initialize(request)
+          @request = request
+        end
+        # Converts the body to a String so you can work with the entire
+        # thing.
+        def to_s
+          @value ? @value.join : @request.body
+        end
+        # Iterates over the body in chunks. If the body has previously
+        # been read, this method can be called again and get the same
+        # sequence of chunks.
+        # @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
+        end
+      end
+    end
+  end
+end

data/pkg/webmachine-0.1.0/lib/webmachine/adapters.rb ADDED Viewed

@@ -0,0 +1,15 @@
+require 'webmachine/adapters/webrick'
+module Webmachine
+  # Contains classes and modules that connect Webmachine to Ruby
+  # application servers.
+  module Adapters
+  end
+  class << self
+    # @return [Symbol] the current webserver adapter
+    attr_accessor :adapter
+  end
+  self.adapter = :WEBrick
+end

data/pkg/webmachine-0.1.0/lib/webmachine/decision/conneg.rb ADDED Viewed

@@ -0,0 +1,304 @@
+require 'webmachine/translation'
+module Webmachine
+  module Decision
+    # Contains methods concerned with Content Negotiation,
+    # specifically, choosing media types, encodings, character sets
+    # and languages.
+    module Conneg
+      HAS_ENCODING = defined?(::Encoding) # Ruby 1.9 compat
+      # Given the 'Accept' header and provided types, chooses an
+      # appropriate media type.
+      # @api private
+      def choose_media_type(provided, header)
+        requested = MediaTypeList.build(header.split(/\s*,\s*/))
+        provided = provided.map do |p| # normalize_provided
+          MediaType.new(*Array(p))
+        end
+        # choose_media_type1
+        chosen = nil
+        requested.each do |_, requested_type|
+          break if chosen = media_match(requested_type, provided)
+        end
+        chosen
+      end
+      # Given the 'Accept-Encoding' header and provided encodings, chooses an appropriate
+      # encoding.
+      # @api private
+      def choose_encoding(provided, header)
+        encodings = provided.keys
+        if encoding = do_choose(encodings, header, "identity")
+          response.headers['Content-Encoding'] = encoding unless encoding == 'identity'
+          metadata['Content-Encoding'] = encoding
+        end
+      end
+      # Given the 'Accept-Charset' header and provided charsets,
+      # chooses an appropriate charset.
+      # @api private
+      def choose_charset(provided, header)
+        if provided && !provided.empty?
+          charsets = provided.map {|c| c.first }
+          if charset = do_choose(charsets, header, HAS_ENCODING ? Encoding.default_external.name : kcode_charset)
+            metadata['Charset'] = charset
+          end
+        else
+          true
+        end
+      end
+      # Given the 'Accept-Language' header and provided languages,
+      # chooses an appropriate language.
+      # @api private
+      def choose_language(provided, header)
+        if provided && !provided.empty?
+          requested = PriorityList.build(header.split(/\s*,\s*/))
+          star_priority = requested.priority_of("*")
+          any_ok = star_priority && star_priority > 0.0
+          accepted = requested.find do |priority, range|
+            if priority == 0.0
+              provided.delete_if {|tag| language_match(range, tag) }
+              false
+            else
+              provided.any? {|tag| language_match(range, tag) }
+            end
+          end
+          chosen = if accepted
+                     provided.find {|tag| language_match(accepted.last, tag) }
+                   elsif any_ok
+                     provided.first
+                   end
+          if chosen
+            metadata['Language'] = chosen
+            response.headers['Content-Language'] = chosen
+          end
+        else
+          true
+        end
+      end
+      # RFC2616, section 14.14:
+      #
+      # A language-range matches a language-tag if it exactly
+      # equals the tag, or if it exactly equals a prefix of the
+      # tag such that the first tag character following the prefix
+      # is "-".
+      def language_match(range, tag)
+        range.downcase == tag.downcase || tag =~ /^#{Regexp.escape(range)}\-/i
+      end
+      # Makes an conneg choice based what is accepted and what is
+      # provided.
+      # @api private
+      def do_choose(choices, header, default)
+        choices = choices.dup.map {|s| s.downcase }
+        accepted = PriorityList.build(header.split(/\s*,\s/))
+        default_priority = accepted.priority_of(default)
+        star_priority = accepted.priority_of("*")
+        default_ok = (default_priority.nil? && star_priority != 0.0) || default_priority
+        any_ok = star_priority && star_priority > 0.0
+        chosen = accepted.find do |priority, acceptable|
+          if priority == 0.0
+            choices.delete(acceptable.downcase)
+            false
+          else
+            choices.include?(acceptable.downcase)
+          end
+        end
+        (chosen && chosen.last) ||  # Use the matching one
+          (any_ok && choices.first) || # Or first if "*"
+          (default_ok && choices.include?(default) && default) # Or default
+      end
+      private
+      # Matches acceptable items that include 'q' values
+      CONNEG_REGEX = /^\s*(\S+);\s*q=(\S*)\s*$/
+      # Matches sub-type parameters
+      PARAMS_REGEX = /;([^=]+)=([^;=\s]+)/
+      # Matches valid media types
+      MEDIA_TYPE_REGEX = /^\s*([^;\s]+)\s*((?:;\S+\s*)*)\s*$/
+      # Encapsulates a MIME media type, with logic for matching types.
+      class MediaType
+        # Creates a new MediaType by parsing its string representation.
+        def self.parse(str)
+          if str =~ MEDIA_TYPE_REGEX
+            type, raw_params = $1, $2
+            params = Hash[raw_params.scan(PARAMS_REGEX)]
+            new(type, params)
+          end
+        end
+        # @return [String] the MIME media type
+        attr_accessor :type
+        # @return [Hash] any type parameters, e.g. charset
+        attr_accessor :params
+        def initialize(type, params={})
+          @type, @params = type, params
+        end
+        # Detects whether the {MediaType} represents an open wildcard
+        # type, that is, "*/*" without any {#params}.
+        def matches_all?
+          @type == "*/*" && @params.empty?
+        end
+        def ==(other)
+          other = self.class.parse(other) if String === other
+          other.type == type && other.params == params
+        end
+        # Detects whether this {MediaType} matches the other {MediaType},
+        # taking into account wildcards.
+        def match?(other)
+          type_matches?(other) && other.params == params
+        end
+        # Reconstitutes the type into a String
+        def to_s
+          [type, *params.map {|k,v| "#{k}=#{v}" }].join(";")
+        end
+        # @return [String] The major type, e.g. "application", "text", "image"
+        def major
+          type.split("/").first
+        end
+        # @return [String] the minor or sub-type, e.g. "json", "html", "jpeg"
+        def minor
+          type.split("/").last
+        end
+        def type_matches?(other)
+          if ["*", "*/*", type].include?(other.type)
+            true
+          else
+            other.major == major && other.minor == "*"
+          end
+        end
+      end
+      # Matches the requested media type (with potential modifiers)
+      # against the provided types (with potential modifiers).
+      # @param [MediaType] requested the requested media type
+      # @param [Array<MediaType>] provided the provided media
+      #     types
+      # @return [MediaType] the first media type that matches
+      def media_match(requested, provided)
+        return provided.first if requested.matches_all?
+        provided.find do |p|
+          p.match?(requested)
+        end
+      end
+      # Translate a KCODE value to a charset name
+      def kcode_charset
+        case $KCODE
+        when /^U/i
+          "UTF-8"
+        when /^S/i
+          "Shift-JIS"
+        when /^B/i
+          "Big5"
+        else #when /^A/i, nil
+          "ASCII"
+        end
+      end
+      # @private
+      # Content-negotiation priority list that takes into account both
+      # assigned priority ("q" value) as well as order, since items
+      # that come earlier in an acceptance list have higher priority
+      # by fiat.
+      class PriorityList
+        # Given an acceptance list, create a PriorityList from them.
+        def self.build(list)
+          new.tap do |plist|
+            list.each {|item| plist.add_header_val(item) }
+          end
+        end
+        include Enumerable
+        # Creates a {PriorityList}.
+        # @see PriorityList::build
+        def initialize
+          @hash = Hash.new {|h,k| h[k] = [] }
+          @index = {}
+        end
+        # Adds an acceptable item with the given priority to the list.
+        # @param [Float] q the priority
+        # @param [String] choice the acceptable item
+        def add(q, choice)
+          @index[choice] = q
+          @hash[q] << choice
+        end
+        # Given a raw acceptable value from an acceptance header,
+        # parse and add it to the list.
+        # @param [String] c the raw acceptable item
+        # @see #add
+        def add_header_val(c)
+          if c =~ CONNEG_REGEX
+            choice, q = $1, $2
+            q = "0" << q if q =~ /^\./ # handle strange FeedBurner Accept
+            add(q.to_f,choice)
+          else
+            add(1.0, c)
+          end
+        end
+        # @param [Float] q the priority to lookup
+        # @return [Array<String>] the list of acceptable items at
+        #     the given priority
+        def [](q)
+          @hash[q]
+        end
+        # @param [String] choice the acceptable item
+        # @return [Float] the priority of that value
+        def priority_of(choice)
+          @index[choice]
+        end
+        # Iterates over the list in priority order, that is, taking
+        # into account the order in which items were added as well as
+        # their priorities.
+        # @yield [q,v]
+        # @yieldparam [Float] q the acceptable item's priority
+        # @yieldparam [String] v the acceptable item
+        def each
+          @hash.to_a.sort.reverse_each do |q,l|
+            l.each {|v| yield q, v }
+          end
+        end
+      end
+      # Like a {PriorityList}, but for {MediaTypes}, since they have
+      # parameters in addition to q.
+      # @private
+      class MediaTypeList < PriorityList
+        include Translation
+        # Overrides {PriorityList#add_header_val} to insert
+        # {MediaType} items instead of Strings.
+        # @see PriorityList#add_header_val
+        def add_header_val(c)
+          if mt = MediaType.parse(c)
+            q = mt.params.delete('q') || 1.0
+            add(q.to_f, mt)
+          else
+            raise MalformedRequest, t('invalid_media_type', :type => c)
+          end
+        end
+      end
+    end
+  end
+end

data/pkg/webmachine-0.1.0/lib/webmachine/decision/flow.rb ADDED Viewed

@@ -0,0 +1,502 @@
+require 'time'
+require 'digest/md5'
+require 'webmachine/decision/conneg'
+require 'webmachine/translation'
+module Webmachine
+  module Decision
+    # This module encapsulates all of the decisions in Webmachine's
+    # flow-chart. These invoke {Resource} {Callbacks} to determine the
+    # appropriate response code, headers, and body for the response.
+    #
+    # This module is included into {FSM}, which drives the processing
+    # of the chart.
+    # @see http://webmachine.basho.com/images/http-headers-status-v3.png
+    module Flow
+      # Version of the flow diagram
+      VERSION = 3
+      # The first state in flow diagram
+      START = :b13
+      # Separate content-negotiation logic from flow diagram.
+      include Conneg
+      # Extract error strings into locale files
+      include Translation
+      # Handles standard decisions where halting is allowed
+      def decision_test(test, value, iftrue, iffalse)
+        case test
+        when value
+          iftrue
+        when Fixnum # Allows callbacks to "halt" with a given response code
+          test
+        else
+          iffalse
+        end
+      end
+      # Service available?
+      def b13
+        decision_test(resource.service_available?, true, :b12, 503)
+      end
+      # Known method?
+      def b12
+        decision_test(resource.known_methods.include?(request.method), true, :b11, 501)
+      end
+      # URI too long?
+      def b11
+        decision_test(resource.uri_too_long?(request.uri), true, 414, :b10)
+      end
+      # Method allowed?
+      def b10
+        if resource.allowed_methods.include?(request.method)
+          :b9
+        else
+          response.headers["Allow"] = resource.allowed_methods.join(", ")
+          405
+        end
+      end
+      # Content-MD5 present?
+      def b9
+        request.content_md5 ? :b9a : :b9b
+      end
+      # Content-MD5 valid?
+      def b9a
+        case valid = resource.validate_content_checksum
+        when Fixnum
+          valid
+        when true
+          :b9b
+        when false
+          response.body = "Content-MD5 header does not match request body."
+          400
+        else # not_validated
+          if request.content_md5 == Digest::MD5.hexdigest(request.body)
+            :b9b
+          else
+            response.body = "Content-MD5 header does not match request body."
+            400
+          end
+        end
+      end
+      # Malformed?
+      def b9b
+        decision_test(resource.malformed_request?, true, 400, :b8)
+      end
+      # Authorized?
+      def b8
+        result = resource.is_authorized?(request.authorization)
+        case result
+        when true
+          :b7
+        when Fixnum
+          result
+        when String
+          response.headers['WWW-Authenticate'] = result
+          401
+        else
+          401
+        end
+      end
+      # Forbidden?
+      def b7
+        decision_test(resource.forbidden?, true, 403, :b6)
+      end
+      # Okay Content-* Headers?
+      def b6
+        decision_test(resource.valid_content_headers?(request.headers.grep(/content-/)), true, :b5,  501)
+      end
+      # Known Content-Type?
+      def b5
+        decision_test(resource.known_content_type?(request.content_type), true, :b4, 415)
+      end
+      # Req Entity Too Large?
+      def b4
+        decision_test(resource.valid_entity_length?(request.content_length), true, :b3, 413)
+      end
+      # OPTIONS?
+      def b3
+        if request.method == "OPTIONS"
+          response.headers.merge!(resource.options)
+          200
+        else
+          :c3
+        end
+      end
+      # Accept exists?
+      def c3
+        if !request.accept
+          metadata['Content-Type'] = MediaType.parse(resource.content_types_provided.first.first)
+          :d4
+        else
+          :c4
+        end
+      end
+      # Acceptable media type available?
+      def c4
+        types = resource.content_types_provided.map {|pair| pair.first }
+        chosen_type = choose_media_type(types, request.accept)
+        if !chosen_type
+          406
+        else
+          metadata['Content-Type'] = chosen_type
+          :d4
+        end
+      end
+      # Accept-Language exists?
+      def d4
+        if !request.accept_language
+          choose_language(resource.languages_provided, "*") ? :e5 : 406
+        else
+          :d5
+        end
+      end
+      # Acceptable language available?
+      def d5
+        choose_language(resource.languages_provided, request.accept_language) ? :e5 : 406
+      end
+      # Accept-Charset exists?
+      def e5
+        if !request.accept_charset
+          choose_charset(resource.charsets_provided, "*") ? :f6 : 406
+        else
+          :e6
+        end
+      end
+      # Acceptable Charset available?
+      def e6
+        choose_charset(resource.charsets_provided, request.accept_charset) ? :f6 : 406
+      end
+      # Accept-Encoding exists?
+      # (also, set content-type header here, now that charset is chosen)
+      def f6
+        chosen_type = metadata['Content-Type']
+        if chosen_charset = metadata['Charset']
+          chosen_type.params['charset'] = chosen_charset
+        end
+        response.headers['Content-Type'] = chosen_type.to_s
+        if !request.accept_encoding
+          choose_encoding(resource.encodings_provided, "identity;q=1.0,*;q=0.5") ? :g7 : 406
+        else
+          :f7
+        end
+      end
+      # Acceptable encoding available?
+      def f7
+        choose_encoding(resource.encodings_provided, request.accept_encoding) ? :g7 : 406
+      end
+      # Resource exists?
+      def g7
+        # This is the first place after all conneg, so set Vary here
+        response.headers['Vary'] =  variances.join(", ") if variances.any?
+        decision_test(resource.resource_exists?, true, :g8, :h7)
+      end
+      # If-Match exists?
+      def g8
+        request.if_match ? :g9 : :h10
+      end
+      # If-Match: * exists?
+      def g9
+        request.if_match == "*" ? :h10 : :g11
+      end
+      # ETag in If-Match
+      def g11
+        request_etags = request.if_match.split(/\s*,\s*/).map {|etag| unquote_header(etag) }
+        request_etags.include?(resource.generate_etag) ? :h10 : 412
+      end
+      # If-Match exists?
+      def h7
+        (request.if_match && unquote_header(request.if_match) == '*') ? 412 : :i7
+      end
+      # If-Unmodified-Since exists?
+      def h10
+        request.if_unmodified_since ? :h11 : :i12
+      end
+      # If-Unmodified-Since is valid date?
+      def h11
+        begin
+          date = Time.httpdate(request.if_unmodified_since)
+          metadata['If-Unmodified-Since'] = date
+        rescue ArgumentError
+          :i12
+        else
+          :h12
+        end
+      end
+      # Last-Modified > I-UM-S?
+      def h12
+        resource.last_modified > metadata['If-Unmodified-Since'] ? 412 : :i12
+      end
+      # Moved permanently? (apply PUT to different URI)
+      def i4
+        case uri = resource.moved_permanently?
+        when String, URI
+          response.headers["Location"] = uri.to_s
+          301
+        when Fixnum
+          uri
+        else
+          :p3
+        end
+      end
+      # PUT?
+      def i7
+        request.method == "PUT" ? :i4 : :k7
+      end
+      # If-none-match exists?
+      def i12
+        request.if_none_match ? :i13 : :l13
+      end
+      # If-none-match: * exists?
+      def i13
+        request.if_none_match == "*" ? :j18 : :k13
+      end
+      # GET or HEAD?
+      def j18
+        %w{GET HEAD}.include?(request.method) ? 304 : 412
+      end
+      # Moved permanently?
+      def k5
+        case uri = resource.moved_permanently?
+        when String, URI
+          response.headers["Location"] = uri.to_s
+          301
+        when Fixnum
+          uri
+        else
+          :l5
+        end
+      end
+      # Previously existed?
+      def k7
+        decision_test(resource.previously_existed?, true, :k5, :l7)
+      end
+      # Etag in if-none-match?
+      def k13
+        request_etags = request.if_none_match.split(/\s*,\s*/).map {|etag| unquote_header(etag) }
+        request_etags.include?(resource.generate_etag) ? :j18 : :l13
+      end
+      # Moved temporarily?
+      def l5
+        case uri = resource.moved_temporarily?
+        when String, URI
+          response.headers["Location"] = uri.to_s
+          307
+        when Fixnum
+          uri
+        else
+          :m5
+        end
+      end
+      # POST?
+      def l7
+        request.method == "POST" ? :m7 : 404
+      end
+      # If-Modified-Since exists?
+      def l13
+        request.if_modified_since ? :l14 : :m16
+      end
+      # IMS is valid date?
+      def l14
+        begin
+          date = Time.httpdate(request.if_modified_since)
+          metadata['If-Modified-Since'] = date
+        rescue ArgumentError
+          :m16
+        else
+          :l15
+        end
+      end
+      # IMS > Now?
+      def l15
+        metadata['If-Modified-Since'] > Time.now ? :m16 : :l17
+      end
+      # Last-Modified > IMS?
+      def l17
+        resource.last_modified.nil? || resource.last_modified > metadata['If-Modified-Since'] ? :m16 : 304
+      end
+      # POST?
+      def m5
+        request.method == "POST" ? :n5 : 410
+      end
+      # Server allows POST to missing resource?
+      def m7
+        decision_test(resource.allow_missing_post?, true, :n11, 404)
+      end
+      # DELETE?
+      def m16
+        request.method == "DELETE" ? :m20 : :n16
+      end
+      # DELETE enacted immediately? (Also where DELETE is forced.)
+      def m20
+        decision_test(resource.delete_resource, true, :m20b, 500)
+      end
+      def m20b
+        decision_test(resource.delete_completed?, true, :o20, 202)
+      end
+      # Server allows POST to missing resource?
+      def n5
+        decision_test(resource.allow_missing_post?, true, :n11, 410)
+      end
+      # Redirect?
+      def n11
+        # Stage1
+        if resource.post_is_create?
+          case uri = resource.create_path
+          when nil
+            raise InvalidResource, t('create_path_nil', :class => resource.class)
+          when URI, String
+            base_uri = resource.base_uri || request.base_uri
+            new_uri = URI.join(base_uri.to_s, uri)
+            request.disp_path = new_uri.path
+            response.headers['Location'] = new_uri.to_s
+            result = accept_helper
+            return result if Fixnum === result
+          end
+        else
+          case result = resource.process_post
+          when true
+            encode_body_if_set
+          when Fixnum
+            return result
+          else
+            raise InvalidResource, t('process_post_invalid', :result => result)
+          end
+        end
+        if response.is_redirect?
+          if response.headers['Location']
+            303
+          else
+            raise InvalidResource, t('do_redirect')
+          end
+        else
+          :p11
+        end
+      end
+      # POST?
+      def n16
+        request.method == "POST" ? :n11 : :o16
+      end
+      # Conflict?
+      def o14
+        if resource.is_conflict?
+          409
+        else
+          res = accept_helper
+          (Fixnum === res) ? res : :p11
+        end
+      end
+      # PUT?
+      def o16
+        request.method == "PUT" ? :o14 : :o18
+      end
+      # Multiple representations?
+      # Also where body generation for GET and HEAD is done.
+      def o18
+        if request.method =~ /^(GET|HEAD)$/
+          if etag = resource.generate_etag
+            response.headers['ETag'] = ensure_quoted_header(etag)
+          end
+          if last_modified = resource.last_modified
+            response.headers['Last-Modified'] = last_modified.httpdate
+          end
+          if expires = resource.expires
+            response.headers['Expires'] = expires.httpdate
+          end
+          content_type = metadata['Content-Type']
+          handler = resource.content_types_provided.find {|ct, _| content_type.type_matches?(MediaType.parse(ct)) }.last
+          result = resource.send(handler)
+          if Fixnum === result
+            result
+          else
+            response.body = result
+            encode_body
+            :o18b
+          end
+        else
+          :o18b
+        end
+      end
+      # Multiple choices?
+      def o18b
+        decision_test(resource.multiple_choices?, true, 300, 200)
+      end
+      # Response includes an entity?
+      def o20
+        has_response_body? ? :o18 : 204
+      end
+      # Conflict?
+      def p3
+        if resource.is_conflict?
+          409
+        else
+          res = accept_helper
+          (Fixnum === res) ? res : :p11
+        end
+      end
+      # New resource?
+      def p11
+        !response.headers["Location"] ? :o20 : 201
+      end
+    end
+  end
+end