RubyGems - rackful - Versions diffs - 0.0.2 → 0.1.0 - Mend

rackful 0.0.2 → 0.1.0

Files changed (15) hide show

data/README.md +14 -2
data/example/config.ru +19 -13
data/example/config2.ru +41 -0
data/lib/rackful/header_spoofing.rb +39 -32
data/lib/rackful/method_spoofing.rb +56 -58
data/lib/rackful/relative_location.rb +35 -21
data/lib/rackful.rb +6 -934
data/lib/rackful_http_status.rb +288 -0
data/lib/rackful_path.rb +112 -0
data/lib/rackful_request.rb +268 -0
data/lib/rackful_resource.rb +454 -0
data/lib/rackful_serializer.rb +318 -0
data/lib/rackful_server.rb +124 -0
data/rackful.gemspec +3 -1
metadata +49 -52

data/lib/rackful_http_status.rb ADDED Viewed

@@ -0,0 +1,288 @@
+# Required for parsing:
+require 'rackful_resource.rb'
+require 'rackful_serializer.rb'
+# Required for running
+require 'rexml/rexml'
+module Rackful
+=begin markdown
+Exception which represents an HTTP Status response.
+@since 0.1.0
+@abstract
+=end
+class HTTPStatus < RuntimeError
+  include Resource
+  attr_reader :status, :headers, :to_rackful
+=begin markdown
+@param message [String] XHTML
+@param status [Symbol, Integer] e.g. `404` or `:not_found`
+@param headers [Hash] HTTP response headers
+=end
+  def initialize status, message = nil, info = {}
+    self.path = Request.current.path
+    @status = status_code status
+    raise "Wrong status: #{status}" if 0 == @status
+    message ||= ''
+    @headers = {}
+    @to_rackful = {}
+    info.each do
+      |k, v|
+      if k.kind_of? Symbol then @to_rackful[k] = v
+      else @headers[k] = v end
+    end
+    @to_rackful = nil if @to_rackful.empty?
+    begin
+      REXML::Document.new \
+        '<?xml version="1.0" encoding="UTF-8" ?>' +
+        "<div>#{message}</div>"
+    rescue
+      message = Rack::Utils.escape_html(message)
+    end
+    super message
+    if 500 <= @status
+      errors = Request.current.env['rack.errors']
+      errors.puts self.inspect
+      errors.puts "Headers: #{@headers.inspect}"
+      errors.puts "Info: #{@to_rackful.inspect}"
+    end
+  end
+  class XHTML < ::Rackful::XHTML
+    HTTP_STATUS_CODES = Rack::Utils::HTTP_STATUS_CODES
+    def header
+      <<EOS
+<title>#{self.resource.status} #{HTTP_STATUS_CODES[self.resource.status]}</title>
+</head><body>
+<h1>HTTP/1.1 #{self.resource.status} #{HTTP_STATUS_CODES[self.resource.status]}</h1>
+<div id="rackful_description">#{self.resource.message}</div>
+EOS
+    end
+    def headers
+      self.resource.headers
+    end
+  end # class HTTPStatus::XHTML
+  add_serializer XHTML, 1.0
+end # class Rackful::HTTPStatus
+=begin markdown
+@abstract Base class for HTTP status codes with only a simple text message, or
+  no message at all.
+@since 0.1.0
+=end
+class HTTPSimpleStatus < HTTPStatus
+  def initialize message = nil
+    /HTTP(\d\d\d)\w+\z/ === self.class.to_s
+    status = $1.to_i
+    super( status, message )
+  end
+end
+# @since 0.1.0
+class HTTP201Created < HTTPStatus
+  def initialize locations
+    locations = [ locations ] unless locations.kind_of? Array
+    locations = locations.collect { |l| l.to_path }
+    rf = Request.current.resource_factory
+    if locations.size > 1
+      locations = locations.collect {
+        |l|
+        resource = rf[l]
+        { :location => l }.merge( resource.default_headers )
+        rf.uncache l if rf.respond_to? :uncache
+      }
+      super(
+        201, 'New resources were created:', :locations => locations
+      )
+    else
+      location = locations[0]
+      resource = rf[location]
+      super(
+        201, 'A new resource was created:', {
+          :location => location,
+          'Location' => location
+        }.merge( resource.default_headers )
+      )
+    end
+  end
+end # class HTTP201Created
+# @since 0.1.0
+class HTTP202Accepted < HTTPStatus
+  def initialize location = nil
+    if location
+      super(
+        202, '', {
+          :'Job status location:' => Path.new(locations),
+          'Location' => locations
+        }
+      )
+    else
+      super 202
+    end
+  end
+end # class HTTP202Accepted
+# @since 0.1.0
+class HTTP301MovedPermanently < HTTPStatus
+  def initialize location
+    super(
+      301, '', {
+        :'New location:' => Path.new(location),
+        'Location' => location
+      }
+    )
+  end
+end
+# @since 0.1.0
+class HTTP303SeeOther < HTTPStatus
+  def initialize location
+    super(
+      303, '', {
+        :'See:' => Path.new(location),
+        'Location' => location
+      }
+    )
+  end
+end
+# @since 0.1.0
+class HTTP304NotModified < HTTPStatus
+  def initialize location
+    super( 304, nil, self.resource.default_headers )
+  end
+end
+# @since 0.1.0
+class HTTP307TemporaryRedirect < HTTPStatus
+  def initialize location
+    super(
+      301, '', {
+        :'Current location:' => Path.new(location),
+        'Location' => location
+      }
+    )
+  end
+end
+# @since 0.1.0
+class HTTP400BadRequest < HTTPSimpleStatus; end
+# @since 0.1.0
+class HTTP403Forbidden < HTTPSimpleStatus; end
+# @since 0.1.0
+class HTTP404NotFound < HTTPSimpleStatus; end
+# @since 0.1.0
+class HTTP405MethodNotAllowed < HTTPStatus
+  def initialize methods
+    super 405, '', 'Allow' => methods.join(', '),
+          :'Allowed methods:' => methods
+  end
+end
+# @since 0.1.0
+class HTTP406NotAcceptable < HTTPStatus
+  def initialize content_types
+    super 406, '',
+          :'Available content-type(s):' => content_types
+  end
+end
+# @since 0.1.0
+class HTTP409Conflict < HTTPSimpleStatus; end
+# @since 0.1.0
+class HTTP410Gone < HTTPSimpleStatus; end
+# @since 0.1.0
+class HTTP411LengthRequired < HTTPSimpleStatus; end
+# @since 0.1.0
+class HTTP412PreconditionFailed < HTTPStatus
+  def initialize header = nil
+    info =
+      if header
+        { header.to_sym => Request.current.env[ 'HTTP_' + header.gsub('-', '_').upcase ] }
+      else
+        {}
+      end
+    super 412, 'Failed precondition:', info
+  end
+end
+# @since 0.1.0
+class HTTP415UnsupportedMediaType < HTTPStatus
+  def initialize media_types
+    super 405, '',
+          :'Supported media-type(s):' => media_types
+  end
+end
+# @since 0.1.0
+class HTTP422UnprocessableEntity < HTTPSimpleStatus; end
+# @since 0.1.0
+class HTTP501NotImplemented < HTTPSimpleStatus; end
+# @since 0.1.0
+class HTTP503ServiceUnavailable < HTTPSimpleStatus; end
+end # module Rackful

data/lib/rackful_path.rb ADDED Viewed

@@ -0,0 +1,112 @@
+# Required for parsing:
+# Required for running:
+require 'rack/utils'
+# A String monkeypatch
+# @private
+class String
+  def to_path; Rackful::Path.new(self); end
+end
+module Rackful
+# Relative URI (a path)
+class Path < String
+  def slashify
+    r = self.dup
+    r << '/' if '/' != r[-1,1]
+    r
+  end
+  def slashify!
+    if '/' != self[-1,1]
+      self << '/'
+    else
+      nil
+    end
+  end
+  def unslashify
+    r = self.dup
+    r = r.chomp( '/' ) if '/' == r[-1,1]
+    r
+  end
+  def unslashify!
+    if '/' == self[-1,1]
+      self.chomp! '/'
+    else
+      nil
+    end
+  end
+  # An alias for Rack::Utils.unescape
+  def unescape( encoding = Encoding::UTF_8 ); Rack::Utils.unescape(self, encoding); end
+end # class Path
+end # module Rackful
+=begin comment
+# Monkeypatch to this stdlib class.
+class URI::Generic
+  # @see http://www.w3.org/TR/html401/struct/links.html#adef-rel the HTML `rel` attribute.
+  attr_accessor :rel
+  # @see http://www.w3.org/TR/html401/struct/links.html#adef-rev the HTML `rev` attribute.
+  attr_accessor :rev
+  def to_xhtml base_path, encoding = Encoding::UTF_8
+    retval = "<a href=\"#{self.route_from(base_path)}\"".encode encoding
+    retval << " rel=\"#{self.rel}\"" if self.rel
+    retval << " rev=\"#{self.rev}\"" if self.rev
+    retval << '>'
+    if self.relative? && ! self.query && ! self.fragment
+      retval << Rack::Utils.escape_html(
+                  Rack::Utils.unescape( self.route_from(base_path).to_s, encoding )
+                )
+    else
+      retval << self.to_s
+    end
+    retval << '</a>'
+    retval
+  end
+  # @return [URI::Generic]
+  def slashify
+    r = self.dup
+    r.path = r.path.unslashify
+    r
+  end
+  # @return [self, nil]
+  def slashify!
+    self.path.slashify! && self
+  end
+  # @return [URI::Generic]
+  def unslashify
+    r = self.dup
+    r.path = r.path.unslashify
+    r
+  end
+  # @return [self, nil]
+  def unslashify!
+    self.path.unslashify! && self
+  end
+end # class ::URI::Generic
+=end comment

data/lib/rackful_request.rb ADDED Viewed

@@ -0,0 +1,268 @@
+# Required for parsing:
+require 'rack'
+# Required for running:
+module Rackful
+=begin markdown
+Subclass of {Rack::Request}, augmented for Rackful requests.
+@since 0.0.1
+=end
+class Request < Rack::Request
+=begin markdown
+The resource factory for the current request.
+@return [#[]]
+@see Server#initialize
+@since 0.0.1
+=end
+  def resource_factory; self.env['rackful.resource_factory']; end
+  def base_path
+    self.env['rackful.base_path'] ||= begin
+      r = self.content_path.dup
+      r[%r{[^/]*\z}] = ''
+      r
+    end
+  end
+=begin markdown
+Similar to the HTTP/1.1 `Content-Location:` header. Contains the canonical path
+to the requested resource, which may differ from {#path}
+@return [Path]
+@since 0.1.0
+=end
+  def content_path; self.env['rackful.content_path'] ||= self.path; end
+=begin markdown
+Set by {Rackful::Server#call!}
+@return [Path]
+@since 0.1.0
+=end
+  def content_path= bp; self.env['rackful.content_path'] = bp.to_path; end
+=begin markdown
+@return [Path]
+@since 0.1.0
+=end
+  def path; super.to_path; end
+  def initialize resource_factory, *args
+    super( *args )
+    self.env['rackful.resource_factory'] = resource_factory
+  end
+=begin markdown
+The request currently being processed in the current thread.
+In a multi-threaded server, multiple requests can be handled at one time.
+This method returns the request object, created (and registered) by
+{Server#call!}
+@return [Request]
+@since 0.0.1
+=end
+  def self.current
+    Thread.current[:rackful_request]
+  end
+=begin markdown
+Assert all <tt>If-*</tt> request headers.
+@return [void]
+@raise [HTTP304NotModified, HTTP400BadRequest, HTTP404NotFound, HTTP412PreconditionFailed]
+  with the following meanings:
+  -   `304 Not Modified`
+  -   `400 Bad Request` Couldn't parse one or more <tt>If-*</tt> headers, or a
+      weak validator comparison was requested for methods other than `GET` or
+      `HEAD`.
+  -   `404 Not Found`
+  -   `412 Precondition Failed`
+@see http://tools.ietf.org/html/rfc2616#section-13.3.3 RFC2616, section 13.3.3
+  for details about weak and strong validator comparison.
+@todo Implement support for the `If-Range:` header.
+@since 0.0.1
+=end
+  def assert_if_headers resource
+    #raise HTTP501NotImplemented, 'If-Range: request header is not supported.' \
+    #  if @env.key? 'HTTP_IF_RANGE'
+    empty = resource.empty?
+    etag =
+      if ! empty && resource.respond_to?(:get_etag)
+        resource.get_etag
+      else
+        nil
+      end
+    last_modified =
+      if ! empty && resource.respond_to?(:get_last_modified)
+        resource.get_last_modified
+      else
+        nil
+      end
+    cond = {
+      :match => self.if_match,
+      :none_match => self.if_none_match,
+      :modified_since => self.if_modified_since,
+      :unmodified_since => self.if_unmodified_since
+    }
+    allow_weak = ['GET', 'HEAD'].include? self.request_method
+    if empty
+      if cond[:match]
+        raise HTTP412PreconditionFailed, 'If-Match'
+      elsif cond[:unmodified_since]
+        raise HTTP412PreconditionFailed, 'If-Unmodified-Since'
+      elsif cond[:modified_since]
+        raise HTTP404NotFound
+      end
+    else
+      if cond[:none_match] && self.validate_etag( etag, cond[:none_match] )
+        raise HTTP412PreconditionFailed, 'If-None-Match'
+      elsif cond[:match] && ! self.validate_etag( etag, cond[:match] )
+        raise HTTP412PreconditionFailed, 'If-Match'
+      elsif cond[:unmodified_since]
+        if ! last_modified || cond[:unmodified_since] < last_modified[0]
+          raise HTTP412PreconditionFailed, 'If-Unmodified-Since'
+        elsif last_modified && ! last_modified[1] && ! allow_weak &&
+              cond[:unmodified_since] == last_modified[0]
+          raise HTTP412PreconditionFailed, 'If-Unmodified-Since'
+        end
+      elsif cond[:modified_since]
+        if ! last_modified || cond[:modified_since] >= last_modified[0]
+          raise HTTP304NotModified
+        elsif last_modified && ! last_modified[1] && !allow_weak &&
+              cond[:modified_since] == last_modified[0]
+          raise HTTP412PreconditionFailed, 'If-Modified-Since'
+        end
+      end
+    end
+  end
+=begin markdown
+Hash of acceptable media types and their qualities.
+This method parses the HTTP/1.1 `Accept:` header. If no acceptable media
+types are provided, an empty Hash is returned.
+@return [Hash{media_type => quality}]
+@since 0.0.1
+=end
+  def accept
+    @env['rackful.accept'] ||= begin
+      Hash[
+        @env['HTTP_ACCEPT'].to_s.split(',').collect do
+          |entry|
+          type, *options = entry.delete(' ').split(';')
+          quality = 1
+          options.each { |e|
+            quality = e[2..-1].to_f if e.start_with? 'q='
+          }
+          [type, quality]
+        end
+      ]
+    rescue
+      {}
+    end
+  end # def accept
+=begin markdown
+@!method if_match()
+Parses the HTTP/1.1 `If-Match:` header.
+@return [nil, Array<String>]
+@see http://tools.ietf.org/html/rfc2616#section-14.24 RFC2616, section 14.24
+@see #if_none_match
+@since 0.0.1
+=end
+  def if_match none = false
+    header = @env["HTTP_IF_#{ none ? 'NONE_' : '' }MATCH"]
+    return nil unless header
+    envkey = "rackful.if_#{ none ? 'none_' : '' }match"
+    if %r{\A\s*\*\s*\z} === header
+      return [ '*' ]
+    elsif %r{\A(\s*(W/)?"([^"\\]|\\.)*"\s*,)+\z}m === ( header + ',' )
+      return header.scan( %r{(?:W/)?"(?:[^"\\]|\\.)*"}m )
+    end
+    raise HTTP400BadRequest, "Couldn't parse If-#{ none ? 'None-' : '' }Match: #{header}"
+  end
+=begin markdown
+Parses the HTTP/1.1 `If-None-Match:` header.
+@return [nil, Array<String>]
+@see http://tools.ietf.org/html/rfc2616#section-14.26 RFC2616, section 14.26
+@see #if_match
+@since 0.0.1
+=end
+  def if_none_match
+    self.if_match true
+  end
+=begin markdown
+@!method if_modified_since()
+@return [nil, Time]
+@see http://tools.ietf.org/html/rfc2616#section-14.25 RFC2616, section 14.25
+@see #if_unmodified_since
+@since 0.0.1
+=end
+  def if_modified_since unmodified = false
+    header = @env["HTTP_IF_#{ unmodified ? 'UN' : '' }MODIFIED_SINCE"]
+    return nil unless header
+    begin
+      header = Time.httpdate( header )
+    rescue ArgumentError
+      raise HTTP400BadRequest, "Couldn't parse If-#{ unmodified ? 'Unmodified' : 'Modified' }-Since: #{header}"
+    end
+    header
+  end
+=begin markdown
+@return [nil, Time]
+@see http://tools.ietf.org/html/rfc2616#section-14.28 RFC2616, section 14.28
+@see #if_modified_since
+@since 0.0.1
+=end
+  def if_unmodified_since
+    self.if_modified_since true
+  end
+=begin markdown
+Does any of the tags in `etags` match `etag`?
+@param etag [#to_s]
+@param etags [#to_a]
+@example
+  etag = '"foo"'
+  etags = [ 'W/"foo"', '"bar"' ]
+  validate_etag etag, etags
+  #> true
+@return [Boolean]
+@see http://tools.ietf.org/html/rfc2616#section-13.3.3 RFC2616 section 13.3.3
+  for details about weak and strong validator comparison.
+@since 0.0.1
+=end
+  def validate_etag etag, etags
+    etag = etag.to_s
+    match = etags.to_a.detect do
+      |tag|
+      tag = tag.to_s
+      tag == '*' or
+      tag == etag or
+      'W/' +  tag == etag or
+      'W/' + etag ==  tag
+    end
+    if  match and
+        '*' != match and
+        'W/' == etag[0,2] || 'W/' == match[0,2] and
+        ! [ 'HEAD', 'GET' ].include? self.request_method
+      raise HTTP400BadRequest, "Weak validators are only allowed for GET and HEAD requests."
+    end
+    !!match
+  end
+end # class Request
+end # module Rackful