webmachine 0.4.1 → 0.4.2

data/pkg/tests.org

@@ -1,80 +0,0 @@
-* 2,2 Basic Rules
-  - HTTP/1.1 header field values can be folded onto multiple lines if
-    the continuation line begins with a space or horizontal tab. All
-    linear white space, including folding, has the same semantics as
-    SP. A recipient MAY replace any linear white space with a single
-    SP before interpreting the field value or forwarding the message
-    downstream.
-  - Many HTTP/1.1 header field values consist of words separated by
-    LWS or special characters. These special characters MUST be in a
-    quoted string to be used within a parameter value (as defined in
-    section 3.6).
-* 3.1 HTTP Version
-  - Note that the major and minor numbers MUST be treated as separate
-    integers and that each MAY be incremented higher than a single
-    digit.
-  - Leading zeros MUST be ignored by recipients and MUST NOT be sent.
-  - An application that sends a request or response message that
-    includes HTTP-Version of "HTTP/1.1" MUST be at least conditionally
-    compliant with this specification.
-  - Applications that are at least conditionally compliant with this
-    specification SHOULD use an HTTP-Version of "HTTP/1.1" in their
-    messages, and MUST do so for any message that is not compatible
-    with HTTP/1.0.
-  - Since the protocol version indicates the protocol capability of
-    the sender, a proxy/gateway MUST NOT send a message with a version
-    indicator which is greater than its actual version. If a higher
-    version request is received, the proxy/gateway MUST either
-    downgrade the request version, or respond with an error, or switch
-    to tunnel behavior.
-  - Due to interoperability problems with HTTP/1.0 proxies discovered
-    since the publication of RFC 2068 [33], caching proxies MUST,
-    gateways MAY, and tunnels MUST NOT upgrade the request to the
-    highest version they support. The proxy/gateway's response to that
-    request MUST be in the same major version as the request.
-* 3.2 URIs
-** General Syntax
-   - Servers MUST be able to handle the URI of any resource they serve.
-   - Servers SHOULD be able to handle URIs of unbounded length if they
-     provide GET-based forms that could generate such URIs.
-   - A server SHOULD return 414 (Request-URI Too Long) status if a URI
-     is longer than the server can handle
-** http URL
-   - If the abs_path is not present in the URL, it MUST be given as
-     "/" when used as a Request-URI for a resource.
-   - If a proxy receives a fully qualified domain name, the proxy MUST
-     NOT change the host name.
-** URI Comparison
-   - When comparing two URIs to decide if they match or not, a client
-     SHOULD use a case-sensitive octet-by-octet comparison of the
-     entire URIs, with these exceptions:
-     - A port that is empty or not given is equivalent to the default
-       port for that URI-reference
-     - Comparisons of host names MUST be case-insensitive
-     - Comparisons of scheme names MUST be case-insensitive
-     - An empty abs_path is equivalent to an abs_path of "/"  
-* 3.3 Date/Time Formats
-** 3.3.1 Full Date
-   Formats: (RFC 822/1123, RFC850/1036, asctime())
-
-   - HTTP/1.1 clients and servers that parse the date value MUST
-     accept all three formats (for compatibility with HTTP/1.0),
-     though they MUST only generate the RFC 1123 format for
-     representing HTTP-date values in header fields.
-   - All HTTP date/time stamps MUST be represented in GMT (UTC),
-     without exception... This is indicated in the first two formats by
-     the inclusion of "GMT" as the three-letter abbreviation for time
-     zone, and MUST be assumed when reading the asctime format.
-   - HTTP-date is case sensitive and MUST NOT include additional LWS
-     beyond that specifically included as SP in the grammar.
-* 3.4 Character Sets
-  - HTTP uses the same definition of the term “character set” as that
-    described for MIME.
-  - Character set tokens are defined by the IANA Character Set registry.
-  - ...any token that has a predefined value within the IANA Character
-    Set registry MUST represent the character set defined by that
-    registry.
-  - Applications SHOULD limit their use of character sets to those
-    defined by the IANA registry.
-** 3.4.1 Missing Charset
-   - 

data/pkg/trace/trace_resource.rb

@@ -1,83 +0,0 @@
-require 'webmachine/resource'
-require 'webmachine/trace'
-require 'pathname'
-require 'erb'
-
-module Webmachine
-  module Trace
-    # Serves request/response traces and assets, aka the "visual
-    # debugger"
-    class TraceResource < Webmachine::Resource
-      # The location of static assets (in the gem)
-      PUBLIC_DIR = Pathname.new(File.expand_path("../../../public", __FILE__))
-
-      # Path tokens for the map image/flowchart
-      MAP = ['map.png']
-
-      # Path tokens for the javascript
-      JS = ['wmtrace.js']
-
-      # Path tokens for the css
-      CSS = ['wmtrace.css']
-
-      # The ERB template for the trace html
-      TRACE_TEMPLATE = ERB.new((PUBLIC_DIR + "trace.html.erb").read)
-
-      # Pulls the trace directory out of the bindings
-      def initialize
-        @trace_dir = Pathname.new(request.path_info[:trace_dir])
-      end
-
-      def resource_exists?
-        case request.path_tokens
-        when MAP
-          (PUBLIC_DIR + 'map.png').file?
-        when JS
-          (PUBLIC_DIR + 'wmtrace.js').file?
-        when CSS
-          (PUBLIC_DIR + 'wmtrace.css').file?
-        else
-          @trace_file = request.path_tokens.dup.unshift(@trace_dir).reduce(:+)
-          @trace_file.exist?
-        end
-      end
-
-      def content_types_provided
-        case request.path_tokens
-        when MAP
-          [["image/png", :produce_file]]
-        when JS
-          [["text/javascript", :produce_file]]
-        when CSS
-          [["text/css", :produce_file]]
-        else
-          [["text/html", :produce_html]]
-        end
-      end
-
-      # Uses chunked encoding to stream static files to the client using
-      # a Fiber
-      def produce_file
-        Fiber.new do
-          File.open(PUBLIC_DIR + request.path_tokens.first, 'rb') do |f|
-            until f.eof?
-              Fiber.yield f.read(1024)
-            end
-          end
-        end
-      end
-
-      # Renders the template with the encoded trace information
-      def produce_html
-        @request_data, @response_data, @trace = encode_trace(@trace_file.read)
-        TRACE_TEMPLATE.result(binding)
-      end
-
-      private
-      # TODO
-      def encode_trace(data)
-        []
-      end
-    end
-  end
-end

data/pkg/trace.rb

@@ -1,40 +0,0 @@
-module Webmachine
-  module Trace
-    Call = Struct.new(:method, :args, :result)
-    
-    class Wrapper
-      attr_reader :trace
-      
-      def initialize(klass, *args)
-        @resource = klass.new(*args)
-        @trace = []
-      end
-      
-      def method_missing(method, *args, &block)
-        if @resource.respond_to?(method)
-          @trace << Call.new(method, args)
-          result = @resource.send(method, *args)
-          @trace.last.result = result
-          result
-        else
-          @trace << Call.new(method, args)
-          raise Webmachine::Error, t('unknown_call', :method => method.to_s)
-        end
-      end
-
-      def marshal_dump
-        @trace.map do |t|
-          (Symbol === t) ? base_decision_name(t) : {:call => t.values}
-        end
-      end
-
-      def base_decision_name(decision)
-        if decision.to_s =~ /[a-z]$/
-          $`.to_sym
-        else
-          decision
-        end
-      end
-    end
-  end
-end

data/pkg/webmachine-0.1.0/Gemfile

@@ -1,16 +0,0 @@
-source :rubygems
-
-gemspec
-
-gem 'bundler'
-
-unless ENV['TRAVIS']
-  gem 'guard-rspec'
-  gem 'rb-fsevent'
-  gem 'growl'
-  gem 'growl_notify'
-end
-
-platforms :jruby do
-  gem 'jruby-openssl'
-end

data/pkg/webmachine-0.1.0/Guardfile

@@ -1,11 +0,0 @@
-gemset = ENV['RVM_GEMSET'] || 'webmachine'
-gemset = "@#{gemset}" unless gemset.to_s == ''
-
-rvms = %W[  1.9.2 ].map {|v| "#{v}#{gemset}" }
-
-guard 'rspec', :cli => "--color --profile", :growl => true, :rvm => rvms do
-  watch(%r{^lib/webmachine/locale/.+$}) { "spec" }
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$}){ |m| "spec/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb') { "spec" }
-end

data/pkg/webmachine-0.1.0/README.md

@@ -1,90 +0,0 @@
-# webmachine for Ruby [![travis](https://secure.travis-ci.org/seancribbs/webmachine-ruby.png)](http://travis-ci.org/seancribbs/webmachine-ruby)
-
-webmachine-ruby is a port of
-[Webmachine](https://github.com/basho/webmachine), which is written in
-Erlang.  The goal of both projects is to expose interesting parts of
-the HTTP protocol to your application in a declarative way.  This
-means that you are less concerned with handling requests directly and
-more with describing the behavior of the resources that make up your
-application. Webmachine is not a web framework _per se_, but more of a
-toolkit for building HTTP-friendly applications. For example, it does
-not provide a templating engine or a persistence layer; those choices
-are up to you.
-
-**NOTE**: _Webmachine is NOT compatible with Rack._ This is
-intentional! Rack obscures HTTP in a way that makes it hard for
-Webmachine to do its job properly, and encourages people to add
-middleware that might break Webmachine's behavior. Rack is also built
-on the tradition of CGI, which is nice for backwards compatibility but
-also an antiquated paradigm and should be scuttled (IMHO). _Rack may
-be supported in the future, but only as a shim to support other web
-application servers._
-
-## Getting Started
-
-Webmachine is very young, but it's still easy to construct an
-application for it!
-
-```ruby
-    require 'webmachine'
-    # Require any of the files that contain your resources here
-    require 'my_resource' 
-     
-    # Point all URIs at the MyResource class
-    Webmachine::Dispatcher.add_route(['*'], MyResource)
-     
-    # Start the server, binds to port 3000 using WEBrick
-    Webmachine.run 
-```
-
-Your resource will look something like this:
-
-```ruby
-    class MyResource < Webmachine::Resource
-      def to_html
-        "<html><body>Hello, world!</body></html>"
-      end
-    end
-```
-
-Run the first file and your application is up. That's all there is to
-it! If you want to customize your resource more, look at the available
-callbacks in lib/webmachine/resource/callbacks.rb. For example, you
-might want to enable "gzip" compression on your resource, for which
-you can simply add an `encodings_provided` callback method:
-
-```ruby
-    class MyResource < Webmachine::Resource
-      def encodings_provided
-        {"gzip" => :encode_gzip, "identity" => :encode_identity}
-      end
-      
-      def to_html
-        "<html><body>Hello, world!</body></html>"
-      end
-    end
-```
-
-There are many other HTTP features exposed to your resource through
-callbacks. Give them a try!
-
-## Features
-
-* Handles the hard parts of content negotiation, conditional
-  requests, and response codes for you.
-* Most callbacks can interrupt the decision flow by returning an
-  integer response code. You generally only want to do this when new
-  information comes to light, requiring a modification of the response.
-* Currently supports WEBrick. Other host servers are planned.
-* Streaming/chunked response bodies are permitted as Enumerables or Procs.
-* Unlike the Erlang original, it does real Language negotiation.
-
-## Problems/TODOs
-
-* Support streamed responses as Fibers.
-* Configuration, command-line tools, and general polish.
-* An effort has been made to make the code feel as Ruby-ish as
-  possible, but there is still work to do.
-* Tracing is exposed as an Array of decisions visited on the response
-  object. You should be able to turn this off and on, and visualize
-  the decisions on the sequence diagram.

data/pkg/webmachine-0.1.0/Rakefile

@@ -1,31 +0,0 @@
-require 'rubygems'
-require 'rubygems/package_task'
-
-def gemspec
-  $webmachine_gemspec ||= Gem::Specification.load("webmachine.gemspec")
-end
-
-Gem::PackageTask.new(gemspec) do |pkg|
-  pkg.need_zip = false
-  pkg.need_tar = false
-end
-
-task :gem => :gemspec
-
-desc %{Validate the gemspec file.}
-task :gemspec do
-  gemspec.validate
-end
-
-desc %{Release the gem to RubyGems.org}
-task :release => :gem do
-  system "gem push pkg/#{gemspec.name}-#{gemspec.version}.gem"
-end
-
-require 'rspec/core'
-require 'rspec/core/rake_task'
-
-desc "Run specs"
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec

data/pkg/webmachine-0.1.0/examples/webrick.rb

@@ -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.1.0/lib/webmachine/adapters/webrick.rb

@@ -1,74 +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
-        server = Webmachine::Adapters::WEBrick::Server.new :Port => 3000
-        trap("INT"){ server.shutdown }
-        Thread.new { server.start }.join
-      end
-
-      class Server < ::WEBrick::HTTPServer
-        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
-            response.body.each {|part| wres.body << part }
-          when response.body.respond_to?(:call)
-            wres.body << response.body.call
-          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.1.0/lib/webmachine/adapters.rb

@@ -1,15 +0,0 @@
-require 'webmachine/adapters/webrick'
-
-module Webmachine
-  # Contains classes and modules that connect Webmachine to Ruby
-  # application servers.
-  module Adapters
-  end
-
-  class << self
-    # @return [Symbol] the current webserver adapter
-    attr_accessor :adapter
-  end
-
-  self.adapter = :WEBrick
-end