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

webmachine 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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