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

rackful 0.0.2 → 0.1.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 (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: