webmachine 0.4.1 → 0.4.2

data/pkg/webmachine-0.3.0/pkg/webmachine-0.2.0/lib/webmachine/dispatcher/route.rb

@@ -1,85 +0,0 @@
-require 'webmachine/resource'
-require 'webmachine/translation'
-
-module Webmachine
-  module 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
-
-      # 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}.
-      # @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 [Class] resource the {Resource} to dispatch to
-      # @param [Hash] bindings additional information to add to
-      #   {Request#path_info} when this route matches
-      # @see Dispatcher#add_route
-      def initialize(path_spec, resource, bindings={})
-        @path_spec, @resource, @bindings = path_spec, resource, 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, {})
-      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
-  end
-end

data/pkg/webmachine-0.3.0/pkg/webmachine-0.2.0/lib/webmachine/dispatcher.rb

@@ -1,40 +0,0 @@
-require 'webmachine/decision'
-require 'webmachine/dispatcher/route'
-
-module Webmachine
-  # Handles dispatching incoming requests to the proper registered
-  # resources and initializing the decision logic.
-  module Dispatcher
-    extend self
-    @routes = []
-
-    # Adds a route to the dispatch list. Routes will be matched in the
-    # order they are added.
-    # @see Route#new
-    def add_route(*args)
-      @routes << Route.new(*args)
-    end
-
-    # 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 = []
-    end
-  end
-end

data/pkg/webmachine-0.3.0/pkg/webmachine-0.2.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

data/pkg/webmachine-0.3.0/pkg/webmachine-0.2.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
-end

data/pkg/webmachine-0.3.0/pkg/webmachine-0.2.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.3.0/pkg/webmachine-0.2.0/lib/webmachine/media_type.rb

@@ -1,117 +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
-
-    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
-end

data/pkg/webmachine-0.3.0/pkg/webmachine-0.2.0/lib/webmachine/request.rb

@@ -1,56 +0,0 @@
-require 'forwardable'
-
-module Webmachine
-  # This represents a single HTTP request sent from a client.
-  class Request
-    extend Forwardable
-    attr_reader :method, :uri, :headers, :body
-    attr_accessor :disp_path, :path_info, :path_tokens
-
-    def initialize(meth, uri, headers, body)
-      @method, @uri, @headers, @body = meth, uri, headers, body
-    end
-
-    def_delegators :headers, :[]
-
-    # @private
-    def method_missing(m, *args)
-      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
-
-    # 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 = URI.unescape(kv).split(/=/)
-          @query[k] = v if k && v
-        end
-      end
-      @query
-    end
-  end
-end