webmachine 0.4.1 → 0.4.2

data/pkg/webmachine-0.3.0/pkg/webmachine-0.1.0/spec/webmachine/dispatcher/route_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Dispatcher::Route do
-  let(:request){ Webmachine::Request.new("GET", URI.parse("http://localhost:8098/"), Webmachine::Headers.new, "") }
-  let(:resource){ Class.new(Webmachine::Resource) }
-
-  matcher :match_route do |*expected|
-    route = described_class.new(expected[0], resource, expected[1] || {})
-    match do |actual|
-      request.uri.path = actual if String === actual
-      route.match?(request)
-    end
-
-    failure_message_for_should do |_|
-      "expected route #{expected[0].inspect} to match path #{request.uri.path}"
-    end
-    failure_message_for_should_not do |_|
-      "expected route #{expected[0].inspect} not to match path #{request.uri.path}"
-    end
-  end
-
-  context "matching a request" do
-    context "on the root path" do
-      subject { "/" }
-      it { should match_route([]) }
-      it { should match_route ['*'] }
-      it { should_not match_route %w{foo} }
-      it { should_not match_route [:id] }
-    end
-
-    context "on a deep path" do
-      subject { "/foo/bar/baz" }
-      it { should match_route %w{foo bar baz} }
-      it { should match_route ['foo', :id, "baz"] }
-      it { should match_route %w{foo *} }
-      it { should match_route [:id, '*'] }
-      it { should_not match_route [] }
-      it { should_not match_route %w{bar *} }
-    end
-  end
-
-  context "applying bindings" do
-    context "on the root path" do
-      subject { described_class.new([], resource) }
-      before { subject.apply(request) }
-
-      it "should assign the dispatched path to the empty string" do
-        request.disp_path.should == ""
-      end
-
-      it "should assign empty bindings" do
-        request.path_info.should == {}
-      end
-
-      it "should assign empty path tokens" do
-        request.path_tokens.should == []
-      end
-
-      context "with extra user-defined bindings" do
-        subject { described_class.new([], resource, "bar" => "baz") }
-
-        it "should assign the user-defined bindings" do
-          request.path_info.should == {"bar" => "baz"}
-        end
-      end
-
-      context "with a splat" do
-        subject { described_class.new(['*'], resource) }
-        
-        it "should assign empty path tokens" do
-          request.path_tokens.should == []
-        end
-      end
-    end
-
-    context "on a deep path" do
-      subject { described_class.new(%w{foo bar baz}, resource) }
-      before { request.uri.path = "/foo/bar/baz"; subject.apply(request) }
-
-      it "should assign the dispatched path as the path past the initial slash" do
-        request.disp_path.should == "foo/bar/baz"
-      end
-
-      it "should assign empty bindings" do
-        request.path_info.should == {}
-      end
-
-      it "should assign empty path tokens" do
-        request.path_tokens.should == []
-      end
-
-      context "with path variables" do
-        subject { described_class.new(['foo', :id, 'baz'], resource) }
-
-        it "should assign the path variables in the bindings" do
-          request.path_info.should == {:id => "bar"}
-        end
-      end
-
-      context "with a splat" do
-        subject { described_class.new(%w{foo *}, resource) }
-
-        it "should capture the path tokens matched by the splat" do
-          request.path_tokens.should == %w{ bar baz }
-        end
-      end
-    end
-  end
-end

data/pkg/webmachine-0.3.0/pkg/webmachine-0.1.0/spec/webmachine/dispatcher_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Dispatcher do
-  let(:dispatcher) { described_class }
-  let(:request) { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/"), Webmachine::Headers["accept" => "*/*"], "") }
-  let(:response) { Webmachine::Response.new }
-  let(:resource) do
-    Class.new(Webmachine::Resource) do
-      def to_html; "hello world!"; end
-    end
-  end
-  let(:resource2) do
-    Class.new(Webmachine::Resource) do
-      def to_html; "goodbye, cruel world"; end
-    end
-  end
-  let(:fsm){ mock }
-  
-  before { dispatcher.reset }
-  
-  it "should add routes" do
-    expect {
-      dispatcher.add_route ['*'], resource
-    }.should_not raise_error
-  end
-
-  it "should route to the proper resource" do
-    dispatcher.add_route ["goodbye"], resource2
-    dispatcher.add_route ['*'], resource    
-    Webmachine::Decision::FSM.should_receive(:new).with(instance_of(resource), request, response).and_return(fsm)
-    fsm.should_receive(:run)
-    dispatcher.dispatch(request, response)
-  end
-end

data/pkg/webmachine-0.3.0/pkg/webmachine-0.1.0/spec/webmachine/headers_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Headers do
-  it "should set and access values insensitive to case" do
-    subject['Content-TYPE'] = "text/plain"
-    subject['CONTENT-TYPE'].should == 'text/plain'
-  end
-
-  context "filtering with #grep" do
-    subject { described_class["content-type" => "text/plain", "etag" => '"abcdef1234567890"'] }
-    it "should filter keys by the given pattern" do
-      subject.grep(/content/i).should include("content-type")
-    end
-
-    it "should return a Headers instance" do
-      subject.grep(/etag/i).should be_instance_of(described_class)
-    end
-  end
-end

data/pkg/webmachine-0.3.0/pkg/webmachine-0.1.0/spec/webmachine/request_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Request do
-  subject { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/some/resource"), Webmachine::Headers.new, "") }
-  it "should provide access to the headers via brackets" do
-    subject.headers['Accept'] = "*/*"
-    subject["accept"].should == "*/*"
-  end
-
-  it "should provide access to the headers via underscored methods" do
-    subject.headers["Accept-Encoding"] = "identity"
-    subject.accept_encoding.should == "identity"
-    subject.content_md5.should be_nil
-  end
-
-  it "should calculate a base URI" do
-    subject.base_uri.should == URI.parse("http://localhost:8080/")
-  end
-
-  it "should provide a hash of query parameters" do
-    subject.uri.query = "foo=bar&baz=bam"
-    subject.query.should == {"foo" => "bar", "baz" => "bam"}
-  end
-end

data/pkg/webmachine-0.3.0/pkg/webmachine-0.1.0/webmachine.gemspec

@@ -1,44 +0,0 @@
-$:.push File.expand_path("../lib", __FILE__)
-require 'webmachine/version'
-
-Gem::Specification.new do |gem|
-  gem.name = "webmachine"
-  gem.version = Webmachine::VERSION
-  gem.date = File.mtime("lib/webmachine/version.rb")
-  gem.summary = %Q{webmachine is a toolkit for building HTTP applications,}
-  gem.description = <<-DESC.gsub(/\s+/, ' ')
-    webmachine is a toolkit for building HTTP applications in a declarative fashion, that avoids
-    the confusion of going through a CGI-style interface like Rack. It is strongly influenced
-    by the original Erlang project of the same name and shares its opinionated nature about HTTP.
-  DESC
-  gem.homepage = "http://github.com/seancribbs/webmachine-ruby"
-  gem.authors = ["Sean Cribbs"]
-  gem.email = ["sean@basho.com"]
-
-  if gem.respond_to? :specification_version then
-    gem.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      gem.add_runtime_dependency(%q<i18n>, [">= 0.4.0"])
-      gem.add_development_dependency(%q<rspec>, ["~> 2.6.0"])
-      gem.add_development_dependency(%q<yard>, ["~> 0.6.7"])
-      gem.add_development_dependency(%q<rake>)
-    else
-      gem.add_dependency(%q<i18n>, [">= 0.4.0"])
-      gem.add_dependency(%q<rspec>, ["~> 2.6.0"])
-      gem.add_dependency(%q<yard>, ["~> 0.6.7"])
-      gem.add_dependency(%q<rake>)
-    end
-  else
-    gem.add_dependency(%q<i18n>, [">= 0.4.0"])
-    gem.add_dependency(%q<rspec>, ["~> 2.6.0"])
-    gem.add_dependency(%q<yard>, ["~> 0.6.7"])
-    gem.add_dependency(%q<rake>)
-  end
-
-  ignores = File.read(".gitignore").split(/\r?\n/).reject{ |f| f =~ /^(#.+|\s*)$/ }.map {|f| Dir[f] }.flatten
-  gem.files = (Dir['**/*','.gitignore'] - ignores).reject {|f| !File.file?(f) }
-  gem.test_files = (Dir['spec/**/*','features/**/*','.gitignore'] - ignores).reject {|f| !File.file?(f) }
-  gem.executables   = Dir['bin/*'].map { |f| File.basename(f) }
-  gem.require_paths = ['lib']
-end

data/pkg/webmachine-0.3.0/pkg/webmachine-0.2.0/Gemfile

@@ -1,24 +0,0 @@
-require 'rbconfig'
-
-source :rubygems
-
-gemspec
-
-gem 'bundler'
-
-unless ENV['TRAVIS']
-  gem 'guard-rspec'
-
-  case RbConfig::CONFIG['host_os']
-  when /darwin/
-    gem 'rb-fsevent'
-    gem 'growl_notify'
-  when /linux/
-    gem 'rb-inotify'
-    gem 'libnotify'
-  end
-end
-
-platforms :jruby do
-  gem 'jruby-openssl'
-end

data/pkg/webmachine-0.3.0/pkg/webmachine-0.2.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.3.0/pkg/webmachine-0.2.0/README.md

@@ -1,117 +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.
-* Supports WEBrick and Mongrel (1.2pre+). Other host servers are being
-  investigated.
-* 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.
-* Command-line tools, and general polish.
-* 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.
-
-## Changelog
-
-### 0.2.0 September 11, 2011
-
-0.2.0 includes an adapter for Mongrel and a central place for
-configuration as well as numerous bugfixes. Added Ian Plosker and
-Bernd Ahlers as committers. Thank you for your contributions!
-
-* Acceptable media types are matched less strictly, which has
-  implications on both responses and PUT requests. See the
-  [discussion on the commit](https://github.com/seancribbs/webmachine-ruby/commit/3686d0d9ff77fc98aff59f89478e9c6c18844ca1).
-* Resources now receive a callback after the language has been
-  negotiated, so they can decide what to do with it.
-* Added `Webmachine::Configuration` so we can more easily support more
-  than one host server/adapter.
-* Added Mongrel adapter, supporting 1.2pre+.
-* Media type headers are more lax about whitespace following
-  semicolons.
-* Fix some problems with callable response bodies.
-* Make sure String response bodies get a Content-Length header added
-  and streaming responses get chunked encoding.
-* Numerous refactorings, including extracting `MediaType` into its own
-  top-level class.
-
-### 0.1.0 August 25, 2011
-
-This is the initial release. Most things work, but only WEBrick is supported.

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

@@ -1,84 +0,0 @@
-require 'mongrel'
-require 'webmachine/version'
-require 'webmachine/headers'
-require 'webmachine/request'
-require 'webmachine/response'
-require 'webmachine/dispatcher'
-
-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
-
-      class Handler < ::Mongrel::HttpHandler
-        def process(wreq, wres)
-          header = http_headers(wreq.params, Webmachine::Headers.new)
-
-          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
-              response.body.each { |part|
-                wres.write part
-                wres.socket.flush
-              }
-            else
-              if response.body.respond_to?(:call)
-                wres.write part
-                wres.socket.flush
-              end
-            end
-          ensure
-            response.body.close if response.body.respond_to? :close
-          end
-        end
-
-        def http_headers(env, headers)
-          env.inject(headers) do |h,(k,v)|
-            if k =~ /^HTTP_(\w+)$/
-              h[$1.tr("_", "-")] = v
-            end
-            h
-          end
-        end
-      end
-    end
-  end
-end

data/pkg/webmachine-0.3.0/pkg/webmachine-0.2.0/lib/webmachine/adapters/webrick.rb

@@ -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/pkg/webmachine-0.2.0/lib/webmachine/adapters.rb

@@ -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/pkg/webmachine-0.2.0/lib/webmachine/configuration.rb

@@ -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
-