webmachine 0.4.1 → 0.4.2

data/pkg/webmachine-0.4.0/lib/webmachine/dispatcher/route.rb

@@ -1,126 +0,0 @@
-require 'webmachine/resource'
-require 'webmachine/translation'
-
-module Webmachine
-  class Dispatcher
-    # Pairs URIs with {Resource} classes in the {Dispatcher}. To
-    # create routes, use {Dispatcher#add_route}.
-    class Route
-      # @return [Class] the resource this route will dispatch to, a
-      #   subclass of {Resource}
-      attr_reader :resource
-
-      # @return [Array<String|Symbol>] the list of path segments
-      #   used to define this route (see #initialize).
-      attr_reader :path_spec
-
-      # @return [Array<Proc>] the list of guard blocks used to define this
-      #   route (see #initialize).
-      attr_reader :guards
-
-      # When used in a path specification, will match all remaining
-      # segments
-      MATCH_ALL = '*'.freeze
-
-      # Creates a new Route that will associate a pattern to a
-      # {Resource}.
-      #
-      # @example Standard route
-      #   Route.new(["*"], MyResource)
-      #
-      # @example Guarded route
-      #   Route.new ["/notes"],
-      #     ->(request) { request.method == "POST" },
-      #     Resources::Note
-      #   Route.new ["/notes"], Resources::NoteList
-      #   Route.new ["/notes", :id], Resources::Note
-      #   Route.new ["/notes"], Resources::Note do |req|
-      #     req.query['foo']
-      #   end
-      #
-      # @overload initialize(path_spec, *guards, resource, bindings = {}, &block)
-      #   @param [Array<String|Symbol>] path_spec a list of path
-      #     segments (String) and identifiers (Symbol) to bind.
-      #     Strings will be simply matched for equality. Symbols in
-      #     the path spec will be extracted into {Request#path_info} for use
-      #     inside your {Resource}. The special segment {MATCH_ALL} will match
-      #     all remaining segments.
-      #   @param [Proc] guards optional guard blocks called with the request.
-      #   @param [Class] resource the {Resource} to dispatch to
-      #   @param [Hash] bindings additional information to add to
-      #     {Request#path_info} when this route matches
-      #   @yield [req] an optional guard block
-      #   @yieldparam [Request] req the request object
-      # @see Dispatcher#add_route
-      def initialize(path_spec, *args)
-        if args.last.is_a? Hash
-          bindings = args.pop
-        else
-          bindings = {}
-        end
-
-        resource = args.pop
-        guards = args
-        guards << Proc.new if block_given?
-
-        @path_spec = path_spec
-        @guards    = guards
-        @resource  = resource
-        @bindings  =  bindings
-
-        raise ArgumentError, t('not_resource_class', :class => resource.name) unless resource < Resource
-      end
-
-      # Determines whether the given request matches this route and
-      # should be dispatched to the {#resource}.
-      # @param [Reqeust] request the request object
-      def match?(request)
-        tokens = request.uri.path.match(/^\/(.*)/)[1].split('/')
-        bind(tokens, {}) && guards.all? { |guard| guard.call(request) }
-      end
-
-      # Decorates the request with information about the dispatch
-      # route, including path bindings.
-      # @param [Request] request the request object
-      def apply(request)
-        request.disp_path = request.uri.path.match(/^\/(.*)/)[1]
-        request.path_info = @bindings.dup
-        tokens = request.disp_path.split('/')
-        depth, trailing = bind(tokens, request.path_info)
-        request.path_tokens = trailing || []
-      end
-
-      private
-      # Attempts to match the path spec against the path tokens, while
-      # accumulating variable bindings.
-      # @param [Array<String>] tokens the list of path segments
-      # @param [Hash] bindings where path bindings will be stored
-      # @return [Fixnum, Array<Fixnum, Array>, false] either the depth
-      #   that the path matched at, the depth and tokens matched by
-      #   {MATCH_ALL}, or false if it didn't match.
-      def bind(tokens, bindings)
-        depth = 0
-        spec = @path_spec
-        loop do
-          case
-          when spec.empty? && tokens.empty?
-            return depth
-          when spec == [MATCH_ALL]
-            return [depth, tokens]
-          when tokens.empty?
-            return false
-          when Symbol === spec.first
-            bindings[spec.first] = tokens.first
-          when spec.first == tokens.first
-          else
-            return false
-          end
-          spec = spec[1..-1]
-          tokens = tokens[1..-1]
-          depth += 1
-        end
-      end
-
-    end # class Route
-  end # module Dispatcher
-end # module Webmachine

data/pkg/webmachine-0.4.0/lib/webmachine/dispatcher.rb

@@ -1,61 +0,0 @@
-require 'forwardable'
-require 'webmachine/decision'
-require 'webmachine/dispatcher/route'
-
-module Webmachine
-  # Handles dispatching incoming requests to the proper registered
-  # resources and initializing the decision logic.
-  class Dispatcher
-    # @return [Array<Route>] the list of routes that will be
-    #   dispatched to
-    # @see #add_route
-    attr_reader :routes
-
-    # Initialize a Dispatcher instance
-    def initialize
-      @routes = []
-    end
-
-    # Adds a route to the dispatch list. Routes will be matched in the
-    # order they are added.
-    # @see Route#new
-    def add_route(*args, &block)
-      route = Route.new(*args, &block)
-      @routes << route
-      route
-    end
-    alias :add :add_route
-
-    # Dispatches a request to the appropriate {Resource} in the
-    # dispatch list. If a matching resource is not found, a "404 Not
-    # Found" will be rendered.
-    # @param [Request] request the request object
-    # @param [Response] response the response object
-    def dispatch(request, response)
-      route = @routes.find {|r| r.match?(request) }
-      if route
-        resource = route.resource.new(request, response)
-        route.apply(request)
-        Webmachine::Decision::FSM.new(resource, request, response).run
-      else
-        Webmachine.render_error(404, request, response)
-      end
-    end
-
-    # Resets, removing all routes. Useful for testing or reloading the
-    # application.
-    def reset
-      @routes.clear
-    end
-  end
-
-  # Evaluates the passed block in the context of
-  # {Webmachine::Dispatcher} for use in adding a number of routes at
-  # once.
-  # @return [Webmachine] self
-  # @see Webmachine::Dispatcher#add_route
-  def self.routes(&block)
-    application.routes(&block)
-    self
-  end
-end # module Webmachine

data/pkg/webmachine-0.4.0/lib/webmachine/errors.rb

@@ -1,38 +0,0 @@
-require 'webmachine/translation'
-require 'webmachine/version'
-
-module Webmachine
-  extend Translation
-
-  # Renders a standard error message body for the response. The
-  # standard messages are defined in localization files.
-  # @param [Fixnum] code the response status code
-  # @param [Request] req the request object
-  # @param [Response] req the response object
-  # @param [Hash] options keys to override the defaults when rendering
-  #     the response body
-  def self.render_error(code, req, res, options={})
-    res.code = code
-    unless res.body
-      title, message = t(["errors.#{code}.title", "errors.#{code}.message"],
-                         { :method => req.method,
-                           :error => res.error}.merge(options))
-      res.body = t("errors.standard_body",
-                   {:title => title,
-                     :message => message,
-                     :version => Webmachine::SERVER_STRING}.merge(options))
-      res.headers['Content-Type'] = "text/html"
-    end
-  end
-
-  # Superclass of all errors generated by Webmachine.
-  class Error < ::StandardError; end
-
-  # Raised when the resource violates specific constraints on its API.
-  class InvalidResource < Error; end
-
-  # Raised when the client has submitted an invalid request, e.g. in
-  # the case where a request header is improperly formed. Raising this
-  # exception will result in a 400 response.
-  class MalformedRequest < Error; end
-end # module Webmachine

data/pkg/webmachine-0.4.0/lib/webmachine/fiber18.rb

@@ -1,88 +0,0 @@
-# -*- coding: utf-8 -*-
-# Poor Man's Fiber (API compatible Thread based Fiber implementation for Ruby 1.8)
-# (c) 2008 Aman Gupta (tmm1)
-
-unless defined? Fiber
-  require 'thread'
-
-  # Raised by {Fiber} when they are used improperly
-  class FiberError < StandardError; end
-
-  # Implements a reasonably-compatible Fiber class that can be used on
-  # Rubies that have 1.8-style APIs.
-  class Fiber
-    # @yield the block that should be executed inside the Fiber
-    def initialize
-      raise ArgumentError, 'new Fiber requires a block' unless block_given?
-
-      @yield = Queue.new
-      @resume = Queue.new
-
-      @thread = Thread.new{ @yield.push [ *yield(*@resume.pop) ] }
-      @thread.abort_on_exception = true
-      @thread[:fiber] = self
-    end
-    attr_reader :thread
-
-    # Returns true if the fiber can still be resumed (or transferred
-    # to). After finishing execution of the fiber block this method
-    # will always return false.
-    def alive?
-      @thread.alive?
-    end
-
-    # Resumes the fiber from the point at which the last Fiber.yield
-    # was called, or starts running it if it is the first call to
-    # resume. Arguments passed to resume will be the value of the
-    # Fiber.yield expression or will be passed as block parameters to
-    # the fiber’s block if this is the first resume.
-    #
-    # Alternatively, when resume is called it evaluates to the arguments
-    # passed to the next Fiber.yield statement inside the fiber’s block or
-    # to the block value if it runs to completion without any Fiber.yield
-    def resume *args
-      raise FiberError, 'dead fiber called' unless @thread.alive?
-      @resume.push(args)
-      result = @yield.pop
-      result.size > 1 ? result : result.first
-    end
-
-    # Yields control back to the context that resumed this fiber,
-    # passing along any arguments that were passed to it. The fiber
-    # will resume processing at this point when resume is called
-    # next. Any arguments passed to the next resume will be the value
-    # that this Fiber.yield expression evaluates to.
-    # @note This method is only called internally. In your code, use
-    #   {Fiber.yield}.
-    def yield *args
-      @yield.push(args)
-      result = @resume.pop
-      result.size > 1 ? result : result.first
-    end
-
-    # Yields control back to the context that resumed the fiber,
-    # passing along any arguments that were passed to it. The fiber
-    # will resume processing at this point when resume is called
-    # next. Any arguments passed to the next resume will be the value
-    # that this Fiber.yield expression evaluates to.  This will raise
-    # a {FiberError} if you are not inside a {Fiber}.
-    # @raise FiberError
-    def self.yield *args
-      raise FiberError, "can't yield from root fiber" unless fiber = Thread.current[:fiber]
-      fiber.yield(*args)
-    end
-
-    # Returns the current fiber.  If you are not running in the
-    # context of a fiber this method will raise a {FiberError}.
-    # @raise FiberError
-    def self.current
-      Thread.current[:fiber] or raise FiberError, 'not inside a fiber'
-    end
-
-    # Returns a string containing a human-readable representation of
-    # this Fiber.
-    def inspect
-      "#<#{self.class}:0x#{self.object_id.to_s(16)}>"
-    end
-  end
-end

data/pkg/webmachine-0.4.0/lib/webmachine/headers.rb

@@ -1,40 +0,0 @@
-module Webmachine
-  # Case-insensitive Hash of Request headers
-  class Headers < ::Hash
-    # Convert CGI-style Hash into Request headers
-    # @param [Hash] env a hash of CGI-style env/headers
-    def self.from_cgi(env)
-      env.inject(new) do |h,(k,v)|
-        if k =~ /^HTTP_(\w+)$/
-          h[$1.tr("_", "-")] = v
-        end
-        h
-      end
-    end
-
-    # Fetch a header
-    def [](key)
-      super transform_key(key)
-    end
-
-    # Set a header
-    def []=(key,value)
-      super transform_key(key), value
-    end
-
-    # Delete a header
-    def delete(key)
-      super transform_key(key)
-    end
-
-    # Select matching headers
-    def grep(pattern)
-      self.class[select { |k,_| pattern === k }]
-    end
-
-    private
-    def transform_key(key)
-      key.to_s.downcase
-    end
-  end # class Headers
-end # module Webmachine

data/pkg/webmachine-0.4.0/lib/webmachine/locale/en.yml

@@ -1,28 +0,0 @@
-en:
-  webmachine:
-    errors:
-      standard_body: "<!DOCTYPE html><html>
-        <head><title>%{title}</title></head>
-        <body><h1>%{title}</h1><p>%{message}</p>
-        <address>%{version} server</address></body></html>"
-      "400":
-        title: 400 Malformed Request
-        message: The request was malformed and could not be processed.
-      "404":
-        title: 404 Not Found
-        message: The requested document was not found on this server.
-      "500":
-        title: 500 Internal Server Error
-        message: "The server encountered an error while processing this request: <pre>%{error}</pre>"
-      "501":
-        title: 501 Not Implemented
-        message: "The server does not support the %{method} method."
-      "503":
-        title: 503 Service Unavailable
-        message: The server is currently unable to handle the request due to a temporary overloading or maintenance of the server.
-    create_path_nil: "post_is_create? returned true but create_path is nil! Define the create_path method in %{class}"
-    do_redirect: "Response had do_redirect but no Location header."
-    fsm_broke: "Decision FSM returned an unexpected value %{result} from decision %{state}."
-    invalid_media_type: "Invalid media type: %{type}"
-    not_resource_class: "%{class} is not a subclass of Webmachine::Resource"
-    process_post_invalid: "process_post returned %{result}"

data/pkg/webmachine-0.4.0/lib/webmachine/media_type.rb

@@ -1,120 +0,0 @@
-require 'webmachine/translation'
-
-module Webmachine
-  # Encapsulates a MIME media type, with logic for matching types.
-  class MediaType
-    extend Translation
-    # Matches valid media types
-    MEDIA_TYPE_REGEX = /^\s*([^;\s]+)\s*((?:;\s*\S+\s*)*)\s*$/
-
-    # Matches sub-type parameters
-    PARAMS_REGEX = /;\s*([^=]+)=([^;=\s]+)/
-
-    # Creates a new MediaType by parsing an alternate representation.
-    # @param [MediaType, String, Array<String,Hash>] obj the raw type
-    #   to be parsed
-    # @return [MediaType] the parsed media type
-    # @raise [ArgumentError] when the type could not be parsed
-    def self.parse(obj)
-      case obj
-      when MediaType
-        obj
-      when MEDIA_TYPE_REGEX
-        type, raw_params = $1, $2
-        params = Hash[raw_params.scan(PARAMS_REGEX)]
-        new(type, params)
-      else
-        unless Array === obj && String === obj[0] && Hash === obj[1]
-          raise ArgumentError, t('invalid_media_type', :type => obj.inspect)
-        end
-        type = parse(obj[0])
-        type.params.merge!(obj[1])
-        type
-      end
-    end
-
-    # @return [String] the MIME media type
-    attr_accessor :type
-
-    # @return [Hash] any type parameters, e.g. charset
-    attr_accessor :params
-
-    # @param [String] type the main media type, e.g. application/json
-    # @param [Hash] params the media type parameters
-    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
-
-    # @return [true,false] Are these two types strictly equal?
-    # @param other the other media type.
-    # @see MediaType.parse
-    def ==(other)
-      other = self.class.parse(other)
-      other.type == type && other.params == params
-    end
-
-    # Detects whether this {MediaType} matches the other {MediaType},
-    # taking into account wildcards. Sub-type parameters are treated
-    # strictly.
-    # @param [MediaType, String, Array<String,Hash>] other the other type 
-    # @return [true,false] whether it is an acceptable match
-    def exact_match?(other)
-      other = self.class.parse(other)
-      type_matches?(other) && other.params == params
-    end
-
-    # Detects whether the {MediaType} is an acceptable match for the
-    # other {MediaType}, taking into account wildcards and satisfying
-    # all requested parameters, but allowing this type to have extra
-    # specificity.
-    # @param [MediaType, String, Array<String,Hash>] other the other type 
-    # @return [true,false] whether it is an acceptable match
-    def match?(other)
-      other = self.class.parse(other)
-      type_matches?(other) && params_match?(other.params)
-    end
-
-    # Detects whether the passed sub-type parameters are all satisfied
-    # by this {MediaType}. The receiver is allowed to have other
-    # params than the ones specified, but all specified must be equal.
-    # @param [Hash] params the requested params
-    # @return [true,false] whether it is an acceptable match
-    def params_match?(other)
-      other.all? {|k,v| params[k] == v }
-    end
-    
-    # Reconstitutes the type into a String
-    # @return [String] the type as 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
-
-    # @param [MediaType] other the other type
-    # @return [true,false] whether the main media type is acceptable,
-    #   ignoring params and taking into account wildcards
-    def type_matches?(other)
-      other = self.class.parse(other)
-      if ["*", "*/*", type].include?(other.type)
-        true
-      else
-        other.major == major && other.minor == "*"
-      end
-    end
-  end # class MediaType
-end # module Webmachine

data/pkg/webmachine-0.4.0/lib/webmachine/request.rb

@@ -1,141 +0,0 @@
-require 'cgi'
-require 'forwardable'
-
-module Webmachine
-  # Request represents a single HTTP request sent from a client. It
-  # should be instantiated by {Adapters} when a request is received
-  class Request
-    extend Forwardable
-    attr_reader :method, :uri, :headers, :body
-    attr_accessor :disp_path, :path_info, :path_tokens
-
-    STANDARD_HTTP_METHODS = %w[GET HEAD POST PUT DELETE TRACE CONNECT OPTIONS]
-
-    # @param [String] method the HTTP request method
-    # @param [URI] uri the requested URI, including host, scheme and
-    #   port
-    # @param [Headers] headers the HTTP request headers
-    # @param [String,#to_s,#each,nil] body the entity included in the
-    #   request, if present
-    def initialize(method, uri, headers, body)
-      @method, @uri, @headers, @body = method, uri, headers, body
-    end
-
-    def_delegators :headers, :[]
-
-    # Enables quicker access to request headers by using a
-    # lowercased-underscored version of the header name, e.g.
-    # `if_unmodified_since`.
-    def method_missing(m, *args, &block)
-      if m.to_s =~ /^(?:[a-z0-9])+(?:_[a-z0-9]+)*$/i
-        # Access headers more easily as underscored methods.
-        self[m.to_s.tr('_', '-')]
-      else
-        super
-      end
-    end
-
-    # @return[true, false] Whether the request body is present.
-    def has_body?
-      !(body.nil? || body.empty?)
-    end
-    
-    # The root URI for the request, ignoring path and query. This is
-    # useful for calculating relative paths to resources.
-    # @return [URI]
-    def base_uri
-      @base_uri ||= uri.dup.tap do |u|
-        u.path = "/"
-        u.query = nil
-      end
-    end
-
-    # Returns a hash of query parameters (they come after the ? in the
-    # URI). Note that this does NOT work in the same way as Rails,
-    # i.e. it does not support nested arrays and hashes.
-    # @return [Hash] query parameters
-    def query
-      unless @query
-        @query = {}
-        (uri.query || '').split(/&/).each do |kv|
-          k, v = CGI.unescape(kv).split(/=/)
-          @query[k] = v if k && v
-        end
-      end
-      @query
-    end
-
-    # Is this an HTTPS request?
-    #
-    # @return [Boolean]
-    #   true if this request was made via HTTPS
-    def https?
-      uri.scheme == "https"
-    end
-
-    # Is this a GET request?
-    #
-    # @return [Boolean]
-    #   true if this request was made with the GET method
-    def get?
-      method == "GET"
-    end
-
-    # Is this a HEAD request?
-    #
-    # @return [Boolean]
-    #   true if this request was made with the HEAD method
-    def head?
-      method == "HEAD"
-    end
-
-    # Is this a POST request?
-    #
-    # @return [Boolean]
-    #   true if this request was made with the GET method
-    def post?
-      method == "POST"
-    end
-
-    # Is this a PUT request?
-    #
-    # @return [Boolean]
-    #   true if this request was made with the PUT method
-    def put?
-      method == "PUT"
-    end
-
-    # Is this a DELETE request?
-    #
-    # @return [Boolean]
-    #   true if this request was made with the DELETE method
-    def delete?
-      method == "DELETE"
-    end
-
-    # Is this a TRACE request?
-    #
-    # @return [Boolean]
-    #   true if this request was made with the TRACE method
-    def trace?
-      method == "TRACE"
-    end
-
-    # Is this a CONNECT request?
-    #
-    # @return [Boolean]
-    #   true if this request was made with the CONNECT method
-    def connect?
-      method == "CONNECT"
-    end
-
-    # Is this an OPTIONS request?
-    #
-    # @return [Boolean]
-    #   true if this request was made with the OPTIONS method
-    def options?
-      method == "OPTIONS"
-    end
-
-  end # class Request
-end # module Webmachine

data/pkg/webmachine-0.4.0/lib/webmachine/resource/authentication.rb

@@ -1,36 +0,0 @@
-module Webmachine
-  class Resource
-    # Helper methods that can be included in your
-    # {Webmachine::Resource} to assist in performing HTTP
-    # Authentication.
-    module Authentication
-      # Pattern for matching Authorization headers that use the Basic
-      # auth scheme.
-      BASIC_HEADER = /^Basic (.*)$/i.freeze
-
-      # A simple implementation of HTTP Basic auth. Call this from the
-      # {Webmachine::Resource::Callbacks#is_authorized?} callback,
-      # giving it a block which will be yielded the username and
-      # password and return true or false.      
-      # @param [String] header the value of the Authentication request
-      #   header, passed to the {Callbacks#is_authorized?} callback.
-      # @param [String] realm the "realm", or description of the
-      #   resource that requires authentication
-      # @return [true, String] true if the client is authorized, or
-      #   the appropriate WWW-Authenticate header
-      # @yield [user, password] a block that will verify the client-provided user/password
-      #   against application constraints
-      # @yieldparam [String] user the passed username
-      # @yieldparam [String] password the passed password
-      # @yieldreturn [true,false] whether the username/password is correct
-      def basic_auth(header, realm="Webmachine")
-        if header =~ BASIC_HEADER && (yield *$1.unpack('m*').first.split(/:/,2))
-          true
-        else
-          %Q[Basic realm="#{realm}"]
-        end
-      end
-
-    end # module Authentication
-  end # class Resource
-end # module Webmachine