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.2.0/spec/webmachine/decision/helpers_spec.rb DELETED Viewed

@@ -1,105 +0,0 @@
-require 'spec_helper'
-describe Webmachine::Decision::Helpers do
-  subject { Webmachine::Decision::FSM.new(resource, request, response) }
-  let(:method) { 'GET' }
-  let(:uri) { URI.parse('http://localhost/') }
-  let(:headers) { Webmachine::Headers.new }
-  let(:body) { '' }
-  let(:request) { Webmachine::Request.new(method, uri, headers, body) }
-  let(:response) { Webmachine::Response.new }
-  def resource_with(&block)
-    klass = Class.new(Webmachine::Resource) do
-      def to_html; "test resource"; end
-    end
-    klass.module_eval(&block) if block_given?
-    klass.new(request, response)
-  end
-  let(:resource) { resource_with }
-  describe "accepting request bodies" do
-    let(:resource) do
-      resource_with do
-        def initialize
-          @accepted, @result = [], true
-        end
-        attr_accessor :accepted, :result
-        def content_types_accepted
-          (accepted || []).map {|t| Array === t ? t : [t, :accept_doc] }
-        end
-        def accept_doc; result; end
-      end
-    end
-    it "should return 415 when no types are accepted" do
-      subject.accept_helper.should == 415
-    end
-    it "should return 415 when the posted type is not acceptable" do
-      resource.accepted = %W{application/json}
-      headers['Content-Type'] = "text/xml"
-      subject.accept_helper.should == 415
-    end
-    it "should call the method for the first acceptable type, taking into account params" do
-      resource.accepted = ["application/json;v=3", ["application/json", :other]]
-      resource.should_receive(:other).and_return(true)
-      headers['Content-Type'] = 'application/json;v=2'
-      subject.accept_helper.should be_true
-    end
-  end
-  describe "#encode_body" do
-    before { subject.run }
-    context "with a String body" do
-      before { response.body = '<body></body>' }
-      it "does not modify the response body" do
-        subject.encode_body
-        String.should === response.body
-      end
-      it "sets the Content-Length header in the response" do
-        subject.encode_body
-        response.headers['Content-Length'].should == response.body.bytesize.to_s
-      end
-    end
-    shared_examples_for "a non-String body" do
-      it "does not set the Content-Length header in the response" do
-        subject.encode_body
-        response.headers.should_not have_key('Content-Length')
-      end
-      it "sets the Transfer-Encoding response header to chunked" do
-        subject.encode_body
-        response.headers['Transfer-Encoding'].should == 'chunked'
-      end
-    end
-    context "with an Enumerable body" do
-      before { response.body = ['one', 'two'] }
-      it "wraps the response body in an EnumerableEncoder" do
-        subject.encode_body
-        Webmachine::EnumerableEncoder.should === response.body
-      end
-      it_should_behave_like "a non-String body"
-    end
-    context "with a callable body" do
-      before { response.body = Proc.new { 'proc' } }
-      it "wraps the response body in a CallableEncoder" do
-        subject.encode_body
-        Webmachine::CallableEncoder.should === response.body
-      end
-      it_should_behave_like "a non-String body"
-    end
-  end
-end

data/pkg/webmachine-0.2.0/spec/webmachine/dispatcher/route_spec.rb DELETED Viewed

@@ -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.2.0/spec/webmachine/dispatcher_spec.rb DELETED Viewed

@@ -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.2.0/spec/webmachine/errors_spec.rb DELETED Viewed

@@ -1,13 +0,0 @@
-require 'spec_helper'
-describe "Webmachine errors" do
-  describe ".render_error" do
-    it "sets the given response code on the response object" do
-      req = double('request', :method => 'GET').as_null_object
-      res = Webmachine::Response.new
-      Webmachine.render_error(404, req, res)
-      res.code.should be(404)
-    end
-  end
-end

data/pkg/webmachine-0.2.0/spec/webmachine/headers_spec.rb DELETED Viewed

@@ -1,20 +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'
-    subject.delete('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.2.0/spec/webmachine/media_type_spec.rb DELETED Viewed

@@ -1,78 +0,0 @@
-require 'spec_helper'
-describe Webmachine::MediaType do
-  let(:raw_type){ "application/xml;charset=UTF-8" }
-  subject { described_class.new("application/xml", {"charset" => "UTF-8"}) }
-  context "equivalence" do
-    it { should == raw_type }
-    it { should == described_class.parse(raw_type) }
-  end
-  context "when it is the wildcard type" do
-    subject { described_class.new("*/*") }
-    it { should be_matches_all }
-  end
-  context "parsing a type" do
-    it "should return MediaTypes untouched" do
-      described_class.parse(subject).should equal(subject)
-    end
-    it "should parse a String" do
-      type = described_class.parse(raw_type)
-      type.should be_kind_of(described_class)
-      type.type.should == "application/xml"
-      type.params.should == {"charset" => "UTF-8"}
-    end
-    it "should parse a type/params pair" do
-      type = described_class.parse(["application/xml", {"charset" => "UTF-8"}])
-      type.should be_kind_of(described_class)
-      type.type.should == "application/xml"
-      type.params.should ==  {"charset" => "UTF-8"}
-    end
-    it "should parse a type/params pair where the type has some params in the string" do
-      type = described_class.parse(["application/xml;version=1",  {"charset" => "UTF-8"}])
-      type.should be_kind_of(described_class)
-      type.type.should == "application/xml"
-      type.params.should ==  {"charset" => "UTF-8", "version" => "1"}
-    end
-    it "should parse a type/params pair with params and whitespace in the string" do
-      type = described_class.parse(["multipart/form-data; boundary=----------------------------2c46a7bec2b9", {"charset" => "UTF-8"}])
-      type.should be_kind_of(described_class)
-      type.type.should == "multipart/form-data"
-      type.params.should ==  {"boundary" => "----------------------------2c46a7bec2b9", "charset" => "UTF-8"}
-    end
-    it "should raise an error when given an invalid type/params pair" do
-      expect {
-        described_class.parse([false, "blah"])
-      }.to raise_error(ArgumentError)
-    end
-  end
-  describe "matching a requested type" do
-    it { should     be_exact_match("application/xml;charset=UTF-8") }
-    it { should     be_exact_match("application/*;charset=UTF-8") }
-    it { should     be_exact_match("*/*;charset=UTF-8") }
-    it { should     be_exact_match("*;charset=UTF-8") }
-    it { should_not be_exact_match("text/xml") }
-    it { should_not be_exact_match("application/xml") }
-    it { should_not be_exact_match("application/xml;version=1") }
-    it { should     be_type_matches("application/xml") }
-    it { should     be_type_matches("application/*") }
-    it { should     be_type_matches("*/*") }
-    it { should     be_type_matches("*") }
-    it { should_not be_type_matches("text/xml") }
-    it { should_not be_type_matches("text/*") }
-    it { should     be_params_match({}) }
-    it { should     be_params_match({"charset" => "UTF-8"}) }
-    it { should_not be_params_match({"charset" => "Windows-1252"}) }
-    it { should_not be_params_match({"version" => "3"}) }
-  end
-end

data/pkg/webmachine-0.2.0/spec/webmachine/request_spec.rb DELETED Viewed

@@ -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.2.0/webmachine.gemspec DELETED Viewed

@@ -1,47 +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>)
-      gem.add_development_dependency(%q<mongrel>, ['~>1.2.beta'])
-    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>)
-      gem.add_dependency(%q<mongrel>, ['~>1.2.beta'])
-    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>)
-    gem.add_dependency(%q<mongrel>, ['~>1.2.beta'])
-  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.2.0.gem DELETED Viewed

Binary file

data/pkg/webmachine-0.3.0/Gemfile DELETED Viewed

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

data/pkg/webmachine-0.3.0/Guardfile DELETED Viewed

@@ -1,11 +0,0 @@
-gemset = ENV['RVM_GEMSET'] || 'webmachine'
-gemset = "@#{gemset}" unless gemset.to_s == ''
-rvms = %W[ 1.8.7 1.9.2 jruby rbx ].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/README.md DELETED Viewed

@@ -1,169 +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.
-## A Note about Rack
-Webmachine has a Rack adapter -- thanks to Jamis Buck -- but when
-using it, we recommend you ensure that NO middleware is used.  The
-behaviors that are encapsulated in Webmachine could be broken by
-middlewares that sit above it, and there is no way to detect them at
-runtime. _Caveat emptor_. That said, Webmachine should behave properly
-when given a clear stack.
-## 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 8080 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
-{Webmachine::Resource::Callbacks}. Give them a try!
-### Configurator
-There's a configurator that allows you to set the ip address and port
-bindings as well as a different webserver adapter.  You can also add
-your routes in a block. Both of these call return the `Webmachine`
-module, so you could chain them if you like.
-```ruby
-require 'webmachine'
-require 'my_resource'
-Webmachine.routes do
-  add ['*'], MyResource
-end
-Webmachine.configure do |config|
-  config.ip = '127.0.0.1'
-  config.port = 3000
-  config.adapter = :Mongrel
-end
-# Start the server.
-Webmachine.run
-```
-## 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+), and a Rack shim. Other host
-  servers are being investigated.
-* Streaming/chunked response bodies are permitted as Enumerables,
-  Procs, or Fibers!
-* Unlike the Erlang original, it does real Language negotiation.
-## Problems/TODOs
-* 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.3.0 November 9, 2011
-0.3.0 introduces some new features, refactorings, and now has 100%
-documentation coverage! Among the new features are minimal Rack
-compatibility, streaming responses via Fibers and a friendlier route
-definition syntax. Added Jamis Buck as a committer. Thank you for your
-contributions!
-* Chunked bodies are now wrapped in a way that works on webservers
-  that don't automatically produce them.
-* HTTP Basic Authentication is easy to add to resources, just include
-  `Webmachine::Resource::Authentication`.
-* Routes are a little less painful to add, you can now specify them
-  with `Webmachine.routes` which will be evaled into the `Dispatcher`.
-* The new default port is 8080.
-* Rack is minimally supported as a host server. _Don't put middleware
-  above Webmachine!_
-* Fibers can be used as streamed response bodies.
-* `Dispatcher#add_route` will now return the added `Route` instance.
-* The header-conversion code for CGI-style servers has been extracted
-  into `Webmachine::Headers`.
-* `Route#path_spec` is now public so that applications can inspect
-  existing routes, perhaps for URL generation.
-* `Request#query` now uses `CGI.unescape` so '+' characters are
-  correctly parsed.
-* YARD documentation has 100% coverage.
-### 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.