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