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_serializer.rb ADDED Viewed

@@ -0,0 +1,318 @@
+# Required for parsing:
+# Required for running:
+require 'rack/utils'
+require 'uri'
+require 'base64'
+require 'json'
+require 'time'
+#require 'json/pure'
+module Rackful
+=begin markdown
+Base class for all serializers.
+The default serializers defined in this library ({Rackful::XHTML} and {Rackful::JSON})
+depend on the availability of method {Rackful::Resource#to_rackful.}
+@abstract Subclasses must implement method `#each` end define constant
+  `CONTENT_TYPES`
+@since 0.1.0
+=end
+class Serializer
+  include Enumerable
+  attr_reader :resource, :content_type
+  # @since 0.1.0
+  def initialize resource, content_type
+    @resource, @content_type = resource, content_type
+  end
+=begin markdown
+Every serializer must implement this method.
+@abstract
+@since 0.1.0
+=end
+  def each
+    raise HTTP500InternalServerError, "Class #{self.class} doesn't implement #each()."
+  end
+=begin markdown
+You don't have to include the `Content-Type` header, as this is done _for_ you.
+This method is optional.
+@!method headers()
+@return [Hash, nil]
+@abstract
+@since 0.1.0
+=end
+=begin markdown
+The content types this serializer can produce.
+@!const CONTENT_TYPES
+@return [(String)]
+@abstract
+@since 0.1.0
+=end
+end # class Serializer
+=begin markdown
+@since 0.1.0
+=end
+class XHTML < Serializer
+  # The content types served by this serializer.
+  # @see Serializer::CONTENT_TYPES
+  CONTENT_TYPES = [
+    'application/xhtml+xml; charset=UTF-8',
+    'text/html; charset=UTF-8',
+    'text/xml; charset=UTF-8',
+    'application/xml; charset=UTF-8'
+  ]
+  # Turns a relative URI (starting with `/`) into a relative path (starting with `./`)
+  # @param path [Path]
+  # @return [String]
+  # @since 0.1.0
+  def htmlify path
+    @rackful_bp ||= Request.current.base_path # caching
+    length = @rackful_bp.length
+    if @rackful_bp == path[0, length]
+      './' + path[length .. -1]
+    else
+      path.dup
+    end
+  end
+  def each &block
+    request = Request.current
+    if /xml/ === self.content_type
+      yield <<EOS
+<?xml version="1.0" encoding="UTF-8"?>
+EOS
+    end
+    yield <<EOS
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+<head>
+EOS
+    unless request.path == request.content_path
+      yield <<EOS
+<base href="#{request.base_path}"/>
+EOS
+    end
+    unless '/' == request.path
+      yield <<EOS
+<link rel="contents" href="#{File::dirname(request.path).to_path.slashify}"/>
+EOS
+    end
+    yield header + '<div id="rackful_content">'
+    each_nested &block
+    yield '</div>' + footer
+  end
+  # Look at the source code!
+  def header
+    "<title>#{ Rack::Utils.escape_html(resource.title) }</title></head><body>"
+  end
+  # Look at the source code!
+  def footer
+    '<div class="rackful_powered">Powered by <a href="http://github.com/pieterb/Rackful">Rackful</a></div></body></html>'
+  end
+  # Serialize almost any kind of Ruby object to XHTML.
+  def each_nested p = self.resource.to_rackful, &block
+    # p = (args.size > 0) ? args[0] : self.resource.to_rackful
+    if p.kind_of?( Path )
+      yield "<a href=\"#{self.htmlify(p)}\">" +
+        Rack::Utils.escape_html( File::basename(p.unslashify).to_path.unescape ) +
+        '</a>'
+    elsif p.kind_of?( Resource ) && ! p.equal?( self.resource )
+      p.serializer( self.content_type ).each_nested &block
+    # elsif p.kind_of?( Hash )
+      # yield '<dl class="rackful_object">'
+      # p.each_pair do
+        # |key, value|
+        # yield '<dt>' + key.to_s.split('_').join(' ').escape_html +
+          # "</dt><dd class=\"rackful_object_#{key.to_s.escape_html}\"#{self.xsd_type(value)}>"
+        # self.each_nested value, &block
+        # yield "</dd>\n"
+      # end
+      # yield '</dl>'
+    elsif p.kind_of?( Enumerable ) and p.respond_to?( :each_pair ) and
+          p.all? { |r, s| r.kind_of?( Path ) }
+      yield '<dl class="rackful-resources">'
+      p.each_pair do
+        |path, child|
+        yield '<dt>'
+        self.each_nested path, &block
+        yield '</dt><dd>'
+        self.each_nested child, &block
+        yield "</dd>\n"
+      end
+      yield '</dl>'
+    elsif p.respond_to?( :each_pair )
+      yield '<dl class="rackful-object">'
+      p.each_pair do
+        |path, child|
+        yield '<dt>'
+        self.each_nested path, &block
+        yield '</dt><dd>'
+        self.each_nested child, &block
+        yield "</dd>\n"
+      end
+      yield '</dl>'
+    elsif p.kind_of?( Enumerable ) and ( q = p.first ) and (
+            q.respond_to?(:keys) && ( keys = q.keys ) &&
+            p.all? { |r| r.respond_to?(:keys) && r.keys == keys }
+          )
+      yield '<table class="rackful-objects"><thead><tr>' +
+        keys.collect {
+          |column|
+          '<th>' +
+          Rack::Utils.escape_html( column.to_s.split('_').join(' ') ) +
+          "</th>\n"
+        }.join + '</tr></thead><tbody>'
+      p.each do
+        |h|
+        yield '<tr>'
+        h.each_pair do
+          |key, value|
+          yield "<td class=\"rackful-objects-#{Rack::Utils.escape_html( key.to_s )}\"#{self.xsd_type(value)}>"
+          self.each_nested value, &block
+          yield "</td>\n"
+        end
+        yield '</tr>'
+      end
+      yield "</tbody></table>"
+    elsif p.kind_of?( Enumerable )
+      yield '<ul class="rackful-array">'
+      p.each do
+        |value|
+        yield "<li#{self.xsd_type(value)}>"
+        self.each_nested value, &block
+        yield "</li>\n"
+      end
+      yield '</ul>'
+    elsif p.kind_of?( Time )
+      yield p.utc.xmlschema
+    elsif p.kind_of?( String ) && p.encoding == Encoding::BINARY
+      yield Base64.encode64(p).chomp
+    else
+      yield Rack::Utils.escape_html( p.to_s )
+    end
+  end
+  # @private
+  def xsd_type v
+    if v.respond_to? :to_rackful
+      v = v.to_rackful
+    end
+    if [nil, true, false].include? v
+      ' xs:type="xs:boolean" xs:nil="true"'
+    elsif v.kind_of? Integer
+      ' xs:type="xs:integer"'
+    elsif v.kind_of? Numeric
+      ' xs:type="xs:decimal"'
+    elsif v.kind_of? Time
+      ' xs:type="xs:dateTime"'
+    elsif v.kind_of?( String ) && v.encoding == Encoding::BINARY
+      ' xs:type="xs:base64Binary"'
+    elsif v.kind_of?( String ) && !v.kind_of?( Path )
+      ' xs:type="xs:string"'
+    else
+      ''
+    end
+  end
+end # class XHTML
+class JSON < Serializer
+  CONTENT_TYPES = [
+    'application/json',
+    'application/x-json'
+  ]
+=begin markdown
+@yield [json]
+@yieldparam json [String]
+=end
+  def each thing = self.resource.to_rackful, &block
+    if thing.kind_of?( Resource ) && ! thing.equal?( self.resource )
+      thing.serializer( self.content_type ).each &block
+    elsif thing.respond_to? :each_pair
+      first = true
+      thing.each_pair do
+        |k, v|
+        yield( ( first ? "{\n" : ",\n" ) + k.to_s.to_json + ":" )
+        first = false
+        self.each v, &block
+      end
+      yield( first ? "{}" : "\n}" )
+    elsif thing.respond_to? :each
+      first = true
+      thing.each do
+        |v|
+        yield( first ? "[\n" : ",\n" )
+        first = false
+        self.each v, &block
+      end
+      yield( first ? "[]" : "\n]" )
+    elsif thing.kind_of?( String ) && thing.encoding == Encoding::BINARY
+      yield Base64.encode64(thing).chomp.to_json
+    elsif thing.kind_of?( Time )
+      yield thing.utc.xmlschema.to_json
+    else
+      yield thing.to_json
+    end
+  end
+  def self.parse input
+    r = ::JSON.parse(
+      input.read,
+      :symbolize_names => true
+    )
+    self.recursive_datetime_parser r
+  end
+  def self.recursive_datetime_parser p
+    if p.kind_of?(String)
+      begin
+        return Time.xmlschema(p)
+      rescue
+      end
+    elsif p.kind_of?(Hash)
+      p.keys.each do
+        |key|
+        p[key] = self.recursive_datetime_parser( p[key] )
+      end
+    elsif p.kind_of?(Array)
+      (0 ... p.size).each do
+        |i|
+        p[i] = self.recursive_datetime_parser( p[i] )
+      end
+    end
+    p
+  end
+end # class HTTPStatus::JSON
+end # module Rackful

data/lib/rackful_server.rb ADDED Viewed

@@ -0,0 +1,124 @@
+# Required for parsing:
+#require 'forwardable' # Used to be for ResourceFactoryWrapper.
+# Required for running:
+module Rackful
+=begin markdown
+Rack compliant server class for implementing RESTful web services.
+@since 0.0.1
+=end
+class Server
+=begin markdown
+An object responding thread safely to method `#[]`.
+A {Server} has no knowledge, and makes no presumptions, about your URI namespace.
+It requires a _Resource Factory_ which produces {Resource Resources} given
+a certain absolute path.
+The Resource Factory you provide need only implement one method, with signature
+`Resource #[]( String path )`.
+This method will be called with a URI-encoded path string, and must return a
+{Resource}, or `nil` if there's no resource at the given path.
+For example, if a Rackful client
+tries to access a resource with URI {http://example.com/your/resource http://example.com/some/resource},
+then your Resource Factory can expect to be called like this:
+    resource = resource_factory[ '/your/resource' ]
+If there's no resource at the given path, but you'd still like to respond to
+`POST` or `PUT` requests to this path, you must return an
+{Resource#empty? empty resource}.
+@return [#[]]
+@see #initialize
+@since 0.0.1
+=end
+  attr_reader :resource_factory
+=begin markdown
+{include:Server#resource_factory}
+@since 0.0.1
+=end
+  def initialize(resource_factory)
+    super()
+    @resource_factory = resource_factory
+  end
+=begin markdown
+As required by the Rack specification.
+For thread safety, this method clones `self`, which handles the request in
+{#call!}. A similar approach is taken by the Sinatra library.
+@return [Array<(status_code, response_headers, response_body)>]
+@since 0.0.1
+=end
+  def call(p_env)
+    start = Time.now
+    retval = dup.call! p_env
+    #$stderr.puts( 'Duration: ' + ( Time.now - start ).to_s )
+    retval
+  end
+=begin markdown
+@return [Array<(status_code, response_headers, response_body)>]
+@since 0.0.1
+=end
+  def call!(p_env)
+    request = Request.new( self.resource_factory, p_env )
+    # See also Request::current():
+    Thread.current[:rackful_request] = request
+    response = Rack::Response.new
+    begin
+      raise HTTP404NotFound \
+        unless resource = self.resource_factory[Path.new(request.path)]
+      unless resource.path == request.path
+        response.header['Content-Location'] = resource.path
+        request.content_path = resource.path
+      end
+      request.assert_if_headers resource
+      if %w{HEAD GET OPTIONS PUT DELETE}.include?( request.request_method )
+        resource.__send__( :"http_#{request.request_method}", request, response )
+      else
+        resource.http_method request, response
+      end
+    rescue HTTPStatus => e
+      # Already handled by HTTPStatus#initialize:
+      #raise if $DEBUG && 500 <= e.status
+      bct = e.class.best_content_type request.accept, false
+      serializer = e.serializer(bct)
+      response = Rack::Response.new serializer, e.status, e.headers
+    ensure
+      # The next line fixes a small peculiarity in RFC2616: the response body of
+      # a `HEAD` request _must_ be empty, even for responses outside 2xx.
+      if request.head?
+        response.body = []
+      end
+    end
+    if  201 == response.status &&
+        ( location = response['Location'] ) &&
+        ( new_resource = request.resource_factory[location] ) &&
+        ! new_resource.empty? \
+    or  ( (200...300) === response.status ||
+           304        ==  response.status ) &&
+        ! response['Location'] &&
+        ( new_resource = request.resource_factory[request.path] ) &&
+        ! new_resource.empty?
+      response.headers.merge! new_resource.default_headers
+    end
+    r = response.finish
+    $stderr.puts r.inspect
+    r
+  end
+end # class Server
+end # module Rackful

data/rackful.gemspec CHANGED Viewed

@@ -2,12 +2,14 @@ Gem::Specification.new do |s|
   # Required properties:
   s.name        = 'rackful'
-  s.version     = '0.0.2'
+  s.version     = '0.1.0'
   s.summary     = "Library for building ReSTful web services with Rack"
   s.description = <<EOS
 Rackful provides a minimal interface for developing ReSTful web services with
 Rack and Ruby. Instead of writing HTTP method handlers, you'll implement
 resource objects, which expose their state at URLs.
+This version is NOT backward compatible with versions 0.0.x.
 EOS
   s.files       = Dir[ '{example/*,lib/**/*}' ] +
                   %w( rackful.gemspec README.md LICENSE.md mkdoc.sh )

metadata CHANGED Viewed

@@ -1,86 +1,83 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification
 name: rackful
-version: !ruby/object:Gem::Version
-  prerelease: false
-  segments:
-  - 0
-  - 0
-  - 2
-  version: 0.0.2
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease:
 platform: ruby
-authors:
+authors:
 - Pieter van Beek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-07-17 00:00:00 +02:00
-default_executable:
-dependencies:
-- !ruby/object:Gem::Dependency
+date: 2012-08-04 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rack
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        segments:
-        - 1
-        - 4
-        version: "1.4"
+  requirement: &70130076580680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.4'
   type: :runtime
-  version_requirements: *id001
-description: |
-  Rackful provides a minimal interface for developing ReSTful web services with
-  Rack and Ruby. Instead of writing HTTP method handlers, you'll implement
+  prerelease: false
+  version_requirements: *70130076580680
+description: ! 'Rackful provides a minimal interface for developing ReSTful web services
+  with
+  Rack and Ruby. Instead of writing HTTP method handlers, you''ll implement
   resource objects, which expose their state at URLs.
+  This version is NOT backward compatible with versions 0.0.x.
+'
 email: rackful@djinnit.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files:
+files:
 - example/config.ru
+- example/config2.ru
 - lib/rackful/header_spoofing.rb
 - lib/rackful/method_spoofing.rb
 - lib/rackful/relative_location.rb
 - lib/rackful.rb
+- lib/rackful_http_status.rb
+- lib/rackful_path.rb
+- lib/rackful_request.rb
+- lib/rackful_resource.rb
+- lib/rackful_serializer.rb
+- lib/rackful_server.rb
 - rackful.gemspec
 - README.md
 - LICENSE.md
 - mkdoc.sh
-has_rdoc: true
 homepage: http://pieterb.github.com/Rackful/
-licenses:
+licenses:
 - Apache License 2.0
 post_install_message:
 rdoc_options: []
-require_paths:
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ">="
-    - !ruby/object:Gem::Version
-      segments:
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ">="
-    - !ruby/object:Gem::Version
-      segments:
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 1.3.6
+rubygems_version: 1.8.10
 signing_key:
 specification_version: 3
 summary: Library for building ReSTful web services with Rack
 test_files: []
+has_rdoc: