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

webmachine 0.4.1 → 0.4.2

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 (907) hide show

data/pkg/webmachine-0.4.0/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.4.0/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.4.0/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.4.0/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.4.0/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.4.0/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.4.0/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.4.0/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.4.0/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