RubyGems - webmachine - Versions diffs - 0.4.1 → 0.4.2 - Mend

webmachine 0.4.1 → 0.4.2

Files changed (907) hide show

data/pkg/webmachine-0.3.0/doc/top-level-namespace.html DELETED Viewed

@@ -1,103 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<title>
-  Top Level Namespace
-    &mdash; Documentation by YARD 0.7.3
-</title>
-  <link rel="stylesheet" href="css/style.css" type="text/css" media="screen" charset="utf-8" />
-  <link rel="stylesheet" href="css/common.css" type="text/css" media="screen" charset="utf-8" />
-<script type="text/javascript" charset="utf-8">
-  relpath = '';
-  if (relpath != '') relpath += '/';
-</script>
-  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
-  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
-  </head>
-  <body>
-    <script type="text/javascript" charset="utf-8">
-      if (window.top.frames.main) document.body.className = 'frames';
-    </script>
-    <div id="header">
-      <div id="menu">
-    <a href="_index.html">Index</a> &raquo;
-    <span class="title">Top Level Namespace</span>
-  <div class="noframes"><span class="title">(</span><a href="." target="_top">no frames</a><span class="title">)</span></div>
-</div>
-      <div id="search">
-    <a id="class_list_link" href="#">Class List</a>
-    <a id="method_list_link" href="#">Method List</a>
-    <a id="file_list_link" href="#">File List</a>
-</div>
-      <div class="clear"></div>
-    </div>
-    <iframe id="search_frame"></iframe>
-    <div id="content"><h1>Top Level Namespace
-</h1>
-<dl class="box">
-</dl>
-<div class="clear"></div>
-<h2>Defined Under Namespace</h2>
-<p class="children">
-      <strong class="modules">Modules:</strong> <span class='object_link'><a href="Webmachine.html" title="Webmachine (module)">Webmachine</a></span>
-</p>
-</div>
-    <div id="footer">
-  Generated on Wed Jan  4 08:47:41 2012 by
-  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.7.3 (ruby-1.9.3).
-</div>
-  </body>
-</html>

data/pkg/webmachine-0.3.0/examples/webrick.rb DELETED Viewed

@@ -1,19 +0,0 @@
-require 'webmachine'
-class HelloResource < Webmachine::Resource
-  def last_modified
-    File.mtime(__FILE__)
-  end
-  def encodings_provided
-    { "gzip" => :encode_gzip, "identity" => :encode_identity }
-  end
-  def to_html
-    "<html><head><title>Hello from Webmachine</title></head><body>Hello, world!</body></html>"
-  end
-end
-Webmachine::Dispatcher.add_route([], HelloResource)
-Webmachine.run

data/pkg/webmachine-0.3.0/lib/webmachine/adapters/mongrel.rb DELETED Viewed

@@ -1,80 +0,0 @@
-require 'mongrel'
-require 'webmachine/version'
-require 'webmachine/headers'
-require 'webmachine/request'
-require 'webmachine/response'
-require 'webmachine/dispatcher'
-require 'webmachine/chunked_body'
-module Webmachine
-  module Adapters
-    # Connects Webmachine to Mongrel.
-    module Mongrel
-      # Starts the Mongrel adapter
-      def self.run
-        c = Webmachine.configuration
-        options = {
-          :port => c.port,
-          :host => c.ip
-        }.merge(c.adapter_options)
-        config = ::Mongrel::Configurator.new(options) do
-          listener do
-            uri '/', :handler => Webmachine::Adapters::Mongrel::Handler.new
-          end
-          trap("INT") { stop }
-          run
-        end
-        config.join
-      end
-      # A Mongrel handler for Webmachine
-      class Handler < ::Mongrel::HttpHandler
-        # Processes an individual request from Mongrel through Webmachine.
-        def process(wreq, wres)
-          header = Webmachine::Headers.from_cgi(wreq.params)
-          request = Webmachine::Request.new(wreq.params["REQUEST_METHOD"],
-                                            URI.parse(wreq.params["REQUEST_URI"]),
-                                            header,
-                                            wreq.body || StringIO.new(''))
-          response = Webmachine::Response.new
-          Webmachine::Dispatcher.dispatch(request, response)
-          begin
-            wres.status = response.code.to_i
-            wres.send_status(nil)
-            response.headers.each { |k, vs|
-              vs.split("\n").each { |v|
-                wres.header[k] = v
-              }
-            }
-            wres.header['Server'] = [Webmachine::SERVER_STRING, "Mongrel/#{::Mongrel::Const::MONGREL_VERSION}"].join(" ")
-            wres.send_header
-            case response.body
-            when String
-              wres.write response.body
-              wres.socket.flush
-            when Enumerable
-              Webmachine::ChunkedBody.new(response.body).each { |part|
-                wres.write part
-                wres.socket.flush
-              }
-            else
-              if response.body.respond_to?(:call)
-                Webmachine::ChunkedBody.new(Array(response.body.call)).each { |part|
-                  wres.write part
-                  wres.socket.flush
-                }
-              end
-            end
-          ensure
-            response.body.close if response.body.respond_to? :close
-          end
-        end
-      end
-    end
-  end
-end

data/pkg/webmachine-0.3.0/lib/webmachine/adapters/rack.rb DELETED Viewed

@@ -1,50 +0,0 @@
-require 'rack/request'
-require 'webmachine/version'
-require 'webmachine/headers'
-require 'webmachine/request'
-require 'webmachine/response'
-require 'webmachine/dispatcher'
-module Webmachine
-  module Adapters
-    # A minimal "shim" adapter to allow Webmachine to interface with Rack. The
-    # intention here is to allow Webmachine to run under Rack-compatible
-    # web-servers, like unicorn and pow, and is not intended to allow Webmachine
-    # to be "plugged in" to an existing Rack app as middleware.
-    #
-    # To use this adapter, create a config.ru file and populate it like so:
-    #
-    #     require 'webmachine/adapters/rack'
-    #
-    #     # put your own Webmachine resources in another file:
-    #     require 'my/resources'
-    #
-    #     run Webmachine::Adapters::Rack.new
-    #
-    # Servers like pow and unicorn will read config.ru by default and it should
-    # all "just work".
-    class Rack
-      # Handles a Rack-based request.
-      # @param [Hash] env the Rack environment
-      def call(env)
-        headers = Webmachine::Headers.from_cgi(env)
-        rack_req = ::Rack::Request.new env
-        request = Webmachine::Request.new(rack_req.request_method,
-                                          URI.parse(rack_req.url),
-                                          headers,
-                                          rack_req.body)
-        response = Webmachine::Response.new
-        Webmachine::Dispatcher.dispatch request, response
-        response.headers['Server'] = [Webmachine::SERVER_STRING, "Rack/#{::Rack.version}"].join(" ")
-        body = response.body.respond_to?(:call) ? response.body.call : response.body
-        body = body.is_a?(String) ? [ body ] : body
-        [response.code.to_i, response.headers, body || []]
-      end
-    end
-  end
-end

data/pkg/webmachine-0.3.0/lib/webmachine/adapters/webrick.rb DELETED Viewed

@@ -1,85 +0,0 @@
-require 'webrick'
-require 'webmachine/version'
-require 'webmachine/headers'
-require 'webmachine/request'
-require 'webmachine/response'
-require 'webmachine/dispatcher'
-module Webmachine
-  module Adapters
-    # Connects Webmachine to WEBrick.
-    module WEBrick
-      # Starts the WEBrick adapter
-      def self.run
-        c = Webmachine.configuration
-        options = {
-          :Port => c.port,
-          :BindAddress => c.ip
-        }.merge(c.adapter_options)
-        server = Webmachine::Adapters::WEBrick::Server.new options
-        trap("INT"){ server.shutdown }
-        Thread.new { server.start }.join
-      end
-      # WEBRick::HTTPServer that is run by the WEBrick adapter.
-      class Server < ::WEBrick::HTTPServer
-        # Handles a request
-        def service(wreq, wres)
-          header = Webmachine::Headers.new
-          wreq.each {|k,v| header[k] = v }
-          request = Webmachine::Request.new(wreq.request_method,
-                                            wreq.request_uri,
-                                            header,
-                                            RequestBody.new(wreq))
-          response = Webmachine::Response.new
-          Webmachine::Dispatcher.dispatch(request, response)
-          wres.status = response.code.to_i
-          response.headers.each do |k,v|
-            wres[k] = v
-          end
-          wres['Server'] = [Webmachine::SERVER_STRING, wres.config[:ServerSoftware]].join(" ")
-          case response.body
-          when String
-            wres.body << response.body
-          when Enumerable
-            wres.chunked = true
-            response.body.each {|part| wres.body << part }
-          else
-            if response.body.respond_to?(:call)
-              wres.chunked = true
-              wres.body << response.body.call
-            end
-          end
-        end
-      end
-      # Wraps the WEBrick request body so that it can be passed to
-      # {Request} while still lazily evaluating the body.
-      class RequestBody
-        def initialize(request)
-          @request = request
-        end
-        # Converts the body to a String so you can work with the entire
-        # thing.
-        def to_s
-          @value ? @value.join : @request.body
-        end
-        # Iterates over the body in chunks. If the body has previously
-        # been read, this method can be called again and get the same
-        # sequence of chunks.
-        # @yield [chunk]
-        # @yieldparam [String] chunk a chunk of the request body
-        def each
-          if @value
-            @value.each {|chunk| yield chunk }
-          else
-            @value = []
-            @request.body {|chunk| @value << chunk; yield chunk }
-          end
-        end
-      end
-    end
-  end
-end

data/pkg/webmachine-0.3.0/lib/webmachine/adapters.rb DELETED Viewed

@@ -1,9 +0,0 @@
-require 'webmachine/adapters/webrick'
-module Webmachine
-  # Contains classes and modules that connect Webmachine to Ruby
-  # application servers.
-  module Adapters
-    autoload :Mongrel, 'webmachine/adapters/mongrel'
-  end
-end

data/pkg/webmachine-0.3.0/lib/webmachine/chunked_body.rb DELETED Viewed

@@ -1,43 +0,0 @@
-module Webmachine
-  # {ChunkedBody} is used to wrap an {Enumerable} object (like an enumerable
-  # {Response#body}) so it yields proper chunks for chunked transfer encoding.
-  #
-  #     case response.body
-  #     when String
-  #       socket.write(response.body)
-  #     when Enumerable
-  #       Webmachine::ChunkedBody.new(response.body).each do |chunk|
-  #         socket.write(chunk)
-  #       end
-  #     end
-  #
-  # This is needed for Ruby webservers which don't do the chunking themselves.
-  class ChunkedBody
-    # Delimiter for chunked encoding
-    CRLF = "\r\n"
-    # Final chunk in any chunked-encoding response
-    FINAL_CHUNK = "0#{CRLF}#{CRLF}"
-    # Creates a new {ChunkedBody} from the given {Enumerable}.
-    # @param [Enumerable] body the enumerable response body
-    # @return [ChunkedBody] the wrapped response body
-    def initialize(body)
-      @body = body
-    end
-    # Calls the given block once for each chunk, passing that chunk as a
-    # parameter.
-    # Returns an {Enumerator} if no block is given.
-    def each
-      return self.to_enum unless block_given?
-      @body.each do |chunk|
-        size = chunk.bytesize
-        next if size == 0
-        yield([size.to_s(16), CRLF, chunk, CRLF].join)
-      end
-      yield(FINAL_CHUNK)
-    end
-  end
-end

data/pkg/webmachine-0.3.0/lib/webmachine/configuration.rb DELETED Viewed

@@ -1,30 +0,0 @@
-module Webmachine
-  # A simple configuration container for items that are used across
-  # multiple web server adapters. Typically set using
-  # {Webmachine::configure}. If not set by your application, the
-  # defaults will be filled in when {Webmachine::run} is called.
-  # @attr [String] ip the interface to bind to, defaults to "0.0.0.0"
-  #    (all interfaces)
-  # @attr [Fixnum] port the port to bind to, defaults to 8080
-  # @attr [Symbol] adapter the adapter to use, defaults to :WEBrick
-  # @attr [Hash] adapter_options adapter-specific options, defaults to {}
-  Configuration = Struct.new(:ip, :port, :adapter, :adapter_options)
-  class << self
-    # @return [Configuration] the current configuration
-    attr_accessor :configuration
-  end
-  # Sets configuration for the web server via the passed
-  # block. Returns Webmachine so you can chain it with
-  # Webmachine.run.
-  # @yield [config] a block in which to set configuration values
-  # @yieldparam [Configuration] config the Configuration instance
-  # @return [Webmachine]
-  def self.configure
-    @configuration ||= Configuration.new("0.0.0.0", 8080, :WEBrick, {})
-    yield @configuration if block_given?
-    self
-  end
-end

data/pkg/webmachine-0.3.0/lib/webmachine/decision/conneg.rb DELETED Viewed

@@ -1,240 +0,0 @@
-require 'webmachine/translation'
-require 'webmachine/media_type'
-module Webmachine
-  module Decision
-    # Contains methods concerned with Content Negotiation,
-    # specifically, choosing media types, encodings, character sets
-    # and languages.
-    module Conneg
-      HAS_ENCODING = defined?(::Encoding) # Ruby 1.9 compat
-      # Given the 'Accept' header and provided types, chooses an
-      # appropriate media type.
-      # @api private
-      def choose_media_type(provided, header)
-        requested = MediaTypeList.build(header.split(/\s*,\s*/))
-        provided = provided.map do |p| # normalize_provided
-          MediaType.parse(p)
-        end
-        # choose_media_type1
-        chosen = nil
-        requested.each do |_, requested_type|
-          break if chosen = media_match(requested_type, provided)
-        end
-        chosen
-      end
-      # Given the 'Accept-Encoding' header and provided encodings, chooses an appropriate
-      # encoding.
-      # @api private
-      def choose_encoding(provided, header)
-        encodings = provided.keys
-        if encoding = do_choose(encodings, header, "identity")
-          response.headers['Content-Encoding'] = encoding unless encoding == 'identity'
-          metadata['Content-Encoding'] = encoding
-        end
-      end
-      # Given the 'Accept-Charset' header and provided charsets,
-      # chooses an appropriate charset.
-      # @api private
-      def choose_charset(provided, header)
-        if provided && !provided.empty?
-          charsets = provided.map {|c| c.first }
-          if charset = do_choose(charsets, header, HAS_ENCODING ? Encoding.default_external.name : kcode_charset)
-            metadata['Charset'] = charset
-          end
-        else
-          true
-        end
-      end
-      # Given the 'Accept-Language' header and provided languages,
-      # chooses an appropriate language.
-      # @api private
-      def choose_language(provided, header)
-        if provided && !provided.empty?
-          requested = PriorityList.build(header.split(/\s*,\s*/))
-          star_priority = requested.priority_of("*")
-          any_ok = star_priority && star_priority > 0.0
-          accepted = requested.find do |priority, range|
-            if priority == 0.0
-              provided.delete_if {|tag| language_match(range, tag) }
-              false
-            else
-              provided.any? {|tag| language_match(range, tag) }
-            end
-          end
-          chosen = if accepted
-                     provided.find {|tag| language_match(accepted.last, tag) }
-                   elsif any_ok
-                     provided.first
-                   end
-          if chosen
-            metadata['Language'] = chosen
-            response.headers['Content-Language'] = chosen
-          end
-        else
-          true
-        end
-      end
-      # Implements language-negotation matching as described in
-      # RFC2616, section 14.14.
-      #
-      # A language-range matches a language-tag if it exactly
-      # equals the tag, or if it exactly equals a prefix of the
-      # tag such that the first tag character following the prefix
-      # is "-".
-      # @api private
-      def language_match(range, tag)
-        range.downcase == tag.downcase || tag =~ /^#{Regexp.escape(range)}\-/i
-      end
-      # Makes an conneg choice based what is accepted and what is
-      # provided.
-      # @api private
-      def do_choose(choices, header, default)
-        choices = choices.dup.map {|s| s.downcase }
-        accepted = PriorityList.build(header.split(/\s*,\s/))
-        default_priority = accepted.priority_of(default)
-        star_priority = accepted.priority_of("*")
-        default_ok = (default_priority.nil? && star_priority != 0.0) || default_priority
-        any_ok = star_priority && star_priority > 0.0
-        chosen = accepted.find do |priority, acceptable|
-          if priority == 0.0
-            choices.delete(acceptable.downcase)
-            false
-          else
-            choices.include?(acceptable.downcase)
-          end
-        end
-        (chosen && chosen.last) ||  # Use the matching one
-          (any_ok && choices.first) || # Or first if "*"
-          (default_ok && choices.include?(default) && default) # Or default
-      end
-      private
-      # Matches acceptable items that include 'q' values
-      CONNEG_REGEX = /^\s*(\S+);\s*q=(\S*)\s*$/
-      # Matches the requested media type (with potential modifiers)
-      # against the provided types (with potential modifiers).
-      # @param [MediaType] requested the requested media type
-      # @param [Array<MediaType>] provided the provided media
-      #     types
-      # @return [MediaType] the first media type that matches
-      def media_match(requested, provided)
-        return provided.first if requested.matches_all?
-        provided.find do |p|
-          p.match?(requested)
-        end
-      end
-      # Translate a KCODE value to a charset name
-      def kcode_charset
-        case $KCODE
-        when /^U/i
-          "UTF-8"
-        when /^S/i
-          "Shift-JIS"
-        when /^B/i
-          "Big5"
-        else #when /^A/i, nil
-          "ASCII"
-        end
-      end
-      # @private
-      # Content-negotiation priority list that takes into account both
-      # assigned priority ("q" value) as well as order, since items
-      # that come earlier in an acceptance list have higher priority
-      # by fiat.
-      class PriorityList
-        # Given an acceptance list, create a PriorityList from them.
-        def self.build(list)
-          new.tap do |plist|
-            list.each {|item| plist.add_header_val(item) }
-          end
-        end
-        include Enumerable
-        # Creates a {PriorityList}.
-        # @see PriorityList::build
-        def initialize
-          @hash = Hash.new {|h,k| h[k] = [] }
-          @index = {}
-        end
-        # Adds an acceptable item with the given priority to the list.
-        # @param [Float] q the priority
-        # @param [String] choice the acceptable item
-        def add(q, choice)
-          @index[choice] = q
-          @hash[q] << choice
-        end
-        # Given a raw acceptable value from an acceptance header,
-        # parse and add it to the list.
-        # @param [String] c the raw acceptable item
-        # @see #add
-        def add_header_val(c)
-          if c =~ CONNEG_REGEX
-            choice, q = $1, $2
-            q = "0" << q if q =~ /^\./ # handle strange FeedBurner Accept
-            add(q.to_f,choice)
-          else
-            add(1.0, c)
-          end
-        end
-        # @param [Float] q the priority to lookup
-        # @return [Array<String>] the list of acceptable items at
-        #     the given priority
-        def [](q)
-          @hash[q]
-        end
-        # @param [String] choice the acceptable item
-        # @return [Float] the priority of that value
-        def priority_of(choice)
-          @index[choice]
-        end
-        # Iterates over the list in priority order, that is, taking
-        # into account the order in which items were added as well as
-        # their priorities.
-        # @yield [q,v]
-        # @yieldparam [Float] q the acceptable item's priority
-        # @yieldparam [String] v the acceptable item
-        def each
-          @hash.to_a.sort.reverse_each do |q,l|
-            l.each {|v| yield q, v }
-          end
-        end
-      end
-      # Like a {PriorityList}, but for {MediaType}s, since they have
-      # parameters in addition to q.
-      # @private
-      class MediaTypeList < PriorityList
-        include Translation
-        # Overrides {PriorityList#add_header_val} to insert
-        # {MediaType} items instead of Strings.
-        # @see PriorityList#add_header_val
-        def add_header_val(c)
-          begin
-            mt = MediaType.parse(c)
-            q = mt.params.delete('q') || 1.0
-            add(q.to_f, mt)
-          rescue ArgumentError
-            raise MalformedRequest, t('invalid_media_type', :type => c)
-          end
-        end
-      end
-    end
-  end
-end