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

@@ -1,116 +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
-    context "with a Fiber body" do
-      before { response.body = Fiber.new { Fiber.yield "foo" } }
-      it "wraps the response body in a FiberEncoder" do
-        subject.encode_body
-        Webmachine::FiberEncoder.should === response.body
-      end
-      it_should_behave_like "a non-String body"
-    end
-  end
-end

data/pkg/webmachine-0.3.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.3.0/spec/webmachine/dispatcher_spec.rb DELETED Viewed

@@ -1,47 +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 from a block" do
-    _resource = resource
-    Webmachine.routes do
-      add ['*'], _resource
-    end.should == Webmachine
-    dispatcher.instance_variable_get(:@routes).should have(1).item
-  end
-  it "should add routes" do
-    expect {
-      dispatcher.add_route ['*'], resource
-    }.should_not raise_error
-  end
-  it "should have add_route return the newly created route" do
-    route = dispatcher.add_route ['*'], resource
-    route.should be_instance_of Webmachine::Dispatcher::Route
-  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/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.3.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.3.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.3.0/spec/webmachine/request_spec.rb DELETED Viewed

@@ -1,29 +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
-  it "should treat '+' characters in query parameters as spaces" do
-    subject.uri.query = "a%20b=foo+bar&c+d=baz%20quux"
-    subject.query.should == {"a b" => "foo bar", "c d" => "baz quux"}
-  end
-end

data/pkg/webmachine-0.3.0/spec/webmachine/resource/authentication_spec.rb DELETED Viewed

@@ -1,68 +0,0 @@
-require 'spec_helper'
-describe Webmachine::Resource::Authentication 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
-  describe "Basic authentication" do
-    let(:resource) do
-      resource_with do
-        include Webmachine::Resource::Authentication
-        attr_accessor :realm
-        def is_authorized?(auth)
-          basic_auth(auth, @realm || "Webmachine") {|u,p| u == "webmachine" && p == "http" }
-        end
-      end
-    end
-    context "when no authorization is sent by the client" do
-      it "should reply with a 401 Unauthorized and a WWW-Authenticate header using Basic" do
-        subject.run
-        response.code.should == 401
-        response.headers['WWW-Authenticate'].should == 'Basic realm="Webmachine"'
-      end
-      it "should use the specified realm in the WWW-Authenticate header" do
-        resource.realm = "My App"
-        subject.run
-        response.headers['WWW-Authenticate'].should == 'Basic realm="My App"'
-      end
-    end
-    context "when the client sends invalid authorization" do
-      before do
-        headers['Authorization'] = "Basic " + ["invalid:auth"].pack('m*').chomp
-      end
-      it "should reply with a 401 Unauthorized and a WWW-Authenticate header using Basic" do
-        subject.run
-        response.code.should == 401
-        response.headers['WWW-Authenticate'].should == 'Basic realm="Webmachine"'
-      end
-    end
-    context "when the client sends valid authorization" do
-      before do
-        headers['Authorization'] = "Basic " + ["webmachine:http"].pack('m*').chomp
-      end
-      it "should not reply with 401 Unauthorized" do
-        subject.run
-        response.code.should_not == 401
-      end
-    end
-  end
-end

data/pkg/webmachine-0.3.0/webmachine.gemspec DELETED Viewed

@@ -1,50 +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.7.3"])
-      gem.add_development_dependency(%q<rake>)
-      gem.add_development_dependency(%q<mongrel>, ['~>1.2.beta'])
-      gem.add_development_dependency(%q<rack>)
-    else
-      gem.add_dependency(%q<i18n>, [">= 0.4.0"])
-      gem.add_dependency(%q<rspec>, ["~> 2.6.0"])
-      gem.add_dependency(%q<yard>, ["~> 0.7.3"])
-      gem.add_dependency(%q<rake>)
-      gem.add_dependency(%q<mongrel>, ['~>1.2.beta'])
-      gem.add_dependency(%q<rack>)
-    end
-  else
-    gem.add_dependency(%q<i18n>, [">= 0.4.0"])
-    gem.add_dependency(%q<rspec>, ["~> 2.6.0"])
-    gem.add_dependency(%q<yard>, ["~> 0.7.3"])
-    gem.add_dependency(%q<rake>)
-    gem.add_dependency(%q<mongrel>, ['~>1.2.beta'])
-    gem.add_dependency(%q<rack>)
-  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.gem DELETED Viewed

Binary file

data/pkg/webmachine-0.4.0/Gemfile DELETED Viewed

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

data/pkg/webmachine-0.4.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 1.9.3 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