mustermann 3.0.4 → 3.1.0

data/spec/concat_spec.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'mustermann'
-
-describe Mustermann::Concat do
-  describe Mustermann::Concat::Native do
-    context "sinatra + sinatra" do
-      subject(:pattern) { Mustermann.new("/:foo") +  Mustermann.new("/:bar") }
-      its(:class) { should be == Mustermann::Sinatra }
-      its(:to_s)  { should be == "/{foo}/{bar}" }
-    end
-
-    context "sinatra + string" do
-      subject(:pattern) { Mustermann.new("/:foo") +  "/:bar" }
-      its(:class) { should be == Mustermann::Sinatra }
-      its(:to_s)  { should be == "/{foo}/\\:bar" }
-    end
-
-    context "regular + regular" do
-      subject(:pattern) { Mustermann.new(/foo/) +  Mustermann.new(/bar/) }
-      its(:class) { should be == Mustermann::Regular }
-      its(:to_s)  { should be == "foobar" }
-    end
-
-    context "sinatra + rails" do
-      subject(:pattern) { Mustermann.new("/:foo") +  Mustermann.new("/:bar", type: :rails) }
-      its(:class) { should be == Mustermann::Sinatra }
-      its(:to_s)  { should be == "/{foo}/{bar}" }
-    end
-
-    context "sinatra + flask" do
-      subject(:pattern) { Mustermann.new("/:foo") +  Mustermann.new("/<bar>", type: :flask) }
-      its(:class) { should be == Mustermann::Sinatra }
-      its(:to_s)  { should be == "/{foo}/{bar}" }
-    end
-
-    context "sinatra + flask (typed)" do
-      subject(:pattern) { Mustermann.new("/:foo") +  Mustermann.new("/<int:bar>", type: :flask) }
-      its(:class) { should be == Mustermann::Concat }
-      its(:to_s)  { should be == '(sinatra:"/:foo" + flask:"/<int:bar>")' }
-    end
-
-    context "sinatra + sinatra (different options)" do
-      subject(:pattern) { Mustermann.new("/:foo") +  Mustermann.new("/:bar", uri_decode: false) }
-      its(:class) { should be == Mustermann::Concat }
-      its(:to_s)  { should be == '(sinatra:"/:foo" + sinatra:"/:bar")' }
-    end
-
-    context "sinatra + rails (different options)" do
-      subject(:pattern) { Mustermann.new("/:foo") +  Mustermann.new("/:bar", type: :rails, uri_decode: false) }
-      its(:class) { should be == Mustermann::Concat }
-      its(:to_s)  { should be == '(sinatra:"/:foo" + rails:"/:bar")' }
-    end
-
-    context "sinatra + rails (different options) + sinatra" do
-      subject(:pattern) { Mustermann.new("/:foo") +  Mustermann.new("/:bar", type: :rails, uri_decode: false) + Mustermann.new("/:baz") }
-      its(:class) { should be == Mustermann::Concat }
-      its(:to_s)  { should be == '(sinatra:"/:foo" + rails:"/:bar" + sinatra:"/:baz")' }
-    end
-
-    context "sinatra + (sinatra + regular)" do
-      subject(:pattern) { Mustermann.new("/foo") + (Mustermann.new("/bar") + Mustermann.new(/baz/)) }
-      its(:class) { should be == Mustermann::Concat }
-      its(:to_s)  { should be == '(sinatra:"/foo/bar" + regular:"baz")' }
-    end
-
-    context "sinatra + (sinatra + rails (different options) + sinatra)" do
-      subject(:pattern) { Mustermann.new("/foo") + (Mustermann.new("/bar") + Mustermann.new("/baz", type: :rails, uri_decode: false) + Mustermann.new("/boo")) }
-      its(:class) { should be == Mustermann::Concat }
-      its(:to_s)  { should be == '(sinatra:"/foo/bar" + rails:"/baz" + sinatra:"/boo")' }
-    end
-  end
-
-  subject(:pattern) { Mustermann::Concat.new("/:foo", "/:bar") }
-
-  describe :=== do
-    example { (pattern === "/foo/bar")  .should be true  }
-    example { (pattern === "/foo/bar/") .should be false }
-    example { (pattern === "/foo")      .should be false }
-  end
-
-  describe :match do
-    it { should match("/foo/bar").capturing(foo: "foo", bar: "bar") }
-    it { should_not match("/foo/bar/") }
-    it { should_not match("/foo/") }
-  end
-
-  describe :params do
-    example { pattern.params("/foo/bar")  .should be == { "foo" => "foo", "bar" => "bar" }}
-    example { pattern.params("/foo/bar/") .should be_nil }
-    example { pattern.params("/foo")      .should be_nil }
-  end
-
-  describe :peek do
-    example { pattern.peek("/foo/bar/baz")  .should be == "/foo/bar" }
-    example { pattern.peek("/foo")          .should be_nil }
-  end
-
-  describe :peek_params do
-    example { pattern.peek_params("/foo/bar/baz")  .should be == [{ "foo" => "foo", "bar" => "bar" }, 8]}
-    example { pattern.peek_params("/foo")          .should be_nil }
-  end
-
-  describe :peek_match do
-    example { pattern.peek_match("/foo/bar/baz").to_s .should be == "/foo/bar" }
-    example { pattern.peek_match("/foo")              .should be_nil }
-  end
-
-  describe :peek_size do
-    example { pattern.peek_size("/foo/bar/baz")  .should be == 8 }
-    example { pattern.peek_size("/foo")          .should be_nil }
-  end
-
-  describe :expand do
-    it { should expand(foo: :bar, bar: :foo)                    .to('/bar/foo')        }
-    it { should expand(:append, foo: :bar, bar: :foo, baz: 42)  .to('/bar/foo?baz=42') }
-    it { should_not expand(foo: :bar) }
-  end
-
-  describe :to_templates do
-    subject(:pattern) { Mustermann::Concat.new("/:foo|:bar", "(/:baz)?") }
-    it { should generate_template("/{foo}/{baz}") }
-    it { should generate_template("{bar}/{baz}") }
-    it { should generate_template("/{foo}") }
-    it { should generate_template("{bar}") }
-  end
-end

data/spec/equality_map_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'mustermann/equality_map'
-
-RSpec.describe Mustermann::EqualityMap do
-  before { GC.disable }
-  after { GC.enable }
-
-  describe :fetch do
-    subject { Mustermann::EqualityMap.new }
-    specify 'with existing entry' do
-      next if subject.is_a? Hash
-      subject.fetch("foo") { "foo" }
-      result = subject.fetch("foo") { "bar" }
-      expect(result).to be == "foo"
-    end
-
-    specify 'with GC-removed entry' do
-      next if subject.is_a? Hash
-      subject.fetch(String.new('foo')) { "foo" }
-      expect(subject.map).to receive(:[]).and_return(nil)
-      result = subject.fetch(String.new('foo')) { "bar" }
-      expect(result).to be == "bar"
-    end
-
-    specify 'allows a frozen key and value' do
-      next if subject.is_a? Hash
-      key = "foo".freeze
-      value = "bar".freeze
-      subject.fetch(key) { value }
-      result = subject.fetch("foo".dup) { raise "not executed" }
-      expect(result).to be == value
-      expect(result).not_to equal value
-    end
-
-    specify 'allows only a single argument to be compatible with Hash#fetch' do
-      expect {
-        subject.fetch("foo", "bar", "baz") { "value" }
-      }.to raise_error(ArgumentError)
-    end
-  end
-end

data/spec/expander_spec.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'mustermann/expander'
-
-describe Mustermann::Expander do
-  it 'expands a pattern' do
-    expander = Mustermann::Expander.new("/:foo.jpg")
-    expander.expand(foo: 42).should be == "/42.jpg"
-  end
-
-  it 'expands multiple patterns' do
-    expander = Mustermann::Expander.new << "/:foo.:ext" << "/:foo"
-    expander.expand(foo: 42, ext: 'jpg').should be == "/42.jpg"
-    expander.expand(foo: 23).should be == "/23"
-  end
-
-  it 'supports setting pattern options' do
-    expander = Mustermann::Expander.new(type: :rails) << "/:foo(.:ext)" << "/:bar"
-    expander.expand(foo: 42, ext: 'jpg').should be == "/42.jpg"
-    expander.expand(foo: 42).should be == "/42"
-  end
-
-  it 'supports combining different pattern styles' do
-    expander = Mustermann::Expander.new << Mustermann.new("/:foo(.:ext)", type: :rails) << Mustermann.new("/:bar", type: :sinatra)
-    expander.expand(foo: 'pony', ext: 'jpg').should be == '/pony.jpg'
-    expander.expand(bar: 23).should be == "/23"
-  end
-
-  it 'ignores nil values' do
-    expander = Mustermann::Expander.new << Mustermann.new("/:foo(.:ext)?")
-    expander.expand(foo: 'pony', ext: nil).should be == '/pony'
-  end
-
-  it 'supports splat' do
-    expander = Mustermann::Expander.new << Mustermann.new("/foo/*/baz")
-    expander.expand(splat: 'bar').should be == '/foo/bar/baz'
-  end
-
-  it 'supports multiple splats' do
-    expander = Mustermann::Expander.new << Mustermann.new("/foo/*/bar/*")
-    expander.expand(splat: [123, 456]).should be == '/foo/123/bar/456'
-  end
-
-  it 'supports identity patterns' do
-    expander = Mustermann::Expander.new('/:foo', type: :identity)
-    expander.expand.should be == '/:foo'
-  end
-
-  describe :additional_values do
-    context "illegal value" do
-      example { expect { Mustermann::Expander.new(additional_values: :foo) }.to raise_error(ArgumentError) }
-      example { expect { Mustermann::Expander.new('/').expand(:foo, a: 10) }.to raise_error(ArgumentError) }
-    end
-
-    context :raise do
-      subject(:expander) { Mustermann::Expander.new('/:a', additional_values: :raise) }
-      example { expander.expand(a: ?a).should be == '/a' }
-      example { expect { expander.expand(a: ?a, b: ?b) }.to raise_error(Mustermann::ExpandError) }
-      example { expect { expander.expand(b: ?b) }.to raise_error(Mustermann::ExpandError) }
-    end
-
-    context :ignore do
-      subject(:expander) { Mustermann::Expander.new('/:a', additional_values: :ignore) }
-      example { expander.expand(a: ?a).should be == '/a' }
-      example { expander.expand(a: ?a, b: ?b).should be == '/a' }
-      example { expect { expander.expand(b: ?b) }.to raise_error(Mustermann::ExpandError) }
-      example { expect { expander.expand(b: ?b, c: []) }.to raise_error(Mustermann::ExpandError) }
-      example { expect { expander.expand(b: ?b, c: [], d: ?d) }.to raise_error(Mustermann::ExpandError) }
-    end
-
-    context :append do
-      subject(:expander) { Mustermann::Expander.new('/:a', additional_values: :append) }
-      example { expander.expand(a: ?a).should be == '/a' }
-      example { expander.expand(a: ?a, b: ?b).should be == '/a?b=b' }
-      example { expect { expander.expand(b: ?b) }.to raise_error(Mustermann::ExpandError) }
-    end
-  end
-
-  describe :cast do
-    subject(:expander) { Mustermann::Expander.new('/:a(/:b)?') }
-
-    example { expander.cast          { "FOOBAR"          }.expand(a: "foo")           .should be == "/FOOBAR"   }
-    example { expander.cast          { |v| v.upcase      }.expand(a: "foo")           .should be == "/FOO"      }
-    example { expander.cast          { |v| v.upcase      }.expand(a: "foo", b: "bar") .should be == "/FOO/BAR"  }
-    example { expander.cast(:a)      { |v| v.upcase      }.expand(a: "foo", b: "bar") .should be == "/FOO/bar"  }
-    example { expander.cast(:a, :b)  { |v| v.upcase      }.expand(a: "foo", b: "bar") .should be == "/FOO/BAR"  }
-    example { expander.cast(Integer) { |k,v| "#{k}_#{v}" }.expand(a: "foo", b: 42)    .should be == "/foo/b_42" }
-
-    example do
-      expander.cast(:a) { |v| v.upcase   }
-      expander.cast(:b) { |v| v.downcase }
-      expander.expand(a: "fOo", b: "bAr").should be == "/FOO/bar"
-    end
-  end
-
-  describe :== do
-    example { Mustermann::Expander.new('/foo')               .should     be == Mustermann::Expander.new('/foo') }
-    example { Mustermann::Expander.new('/foo')               .should_not be == Mustermann::Expander.new('/bar') }
-    example { Mustermann::Expander.new('/foo', type: :rails) .should     be == Mustermann::Expander.new('/foo', type: :rails) }
-    example { Mustermann::Expander.new('/foo', type: :rails) .should_not be == Mustermann::Expander.new('/foo', type: :sinatra) }
-  end
-
-  describe :hash do
-    example { Mustermann::Expander.new('/foo')               .hash.should     be == Mustermann::Expander.new('/foo').hash }
-    example { Mustermann::Expander.new('/foo')               .hash.should_not be == Mustermann::Expander.new('/bar').hash }
-    example { Mustermann::Expander.new('/foo', type: :rails) .hash.should     be == Mustermann::Expander.new('/foo', type: :rails).hash }
-    example { Mustermann::Expander.new('/foo', type: :rails) .hash.should_not be == Mustermann::Expander.new('/foo', type: :sinatra).hash }
-  end
-
-  describe :eql? do
-    example { Mustermann::Expander.new('/foo')               .should     be_eql Mustermann::Expander.new('/foo') }
-    example { Mustermann::Expander.new('/foo')               .should_not be_eql Mustermann::Expander.new('/bar') }
-    example { Mustermann::Expander.new('/foo', type: :rails) .should     be_eql Mustermann::Expander.new('/foo', type: :rails) }
-    example { Mustermann::Expander.new('/foo', type: :rails) .should_not be_eql Mustermann::Expander.new('/foo', type: :sinatra) }
-  end
-
-  describe :equal? do
-    example { Mustermann::Expander.new('/foo')               .should_not be_equal Mustermann::Expander.new('/foo') }
-    example { Mustermann::Expander.new('/foo')               .should_not be_equal Mustermann::Expander.new('/bar') }
-    example { Mustermann::Expander.new('/foo', type: :rails) .should_not be_equal Mustermann::Expander.new('/foo', type: :rails) }
-    example { Mustermann::Expander.new('/foo', type: :rails) .should_not be_equal Mustermann::Expander.new('/foo', type: :sinatra) }
-  end
-end

data/spec/identity_spec.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'mustermann/identity'
-
-describe Mustermann::Identity do
-  extend Support::Pattern
-
-  pattern '' do
-    it { should     match('')  }
-    it { should_not match('/') }
-
-    it { should respond_to(:expand)       }
-    it { should respond_to(:to_templates) }
-
-
-    it { should     generate_template('')              }
-    it { should     expand.to('')                      }
-    it { should     expand(:ignore, a: 10).to('')      }
-    it { should     expand(:append, a: 10).to('?a=10') }
-    it { should_not expand(:raise,  a: 10)             }
-    it { should_not expand(a: 10)                      }
-
-    example do
-      pattern.match('').inspect.should be == '#<Mustermann::SimpleMatch "">'
-    end
-  end
-
-  pattern '/' do
-    it { should     match('/')    }
-    it { should_not match('/foo') }
-
-    example { pattern.params('/').should be == {} }
-    example { pattern.params('').should be_nil }
-
-    it { should generate_template('/') }
-    it { should expand.to('/')         }
-  end
-
-  pattern '/foo' do
-    it { should     match('/foo')     }
-    it { should_not match('/bar')     }
-    it { should_not match('/foo.bar') }
-  end
-
-  pattern '/foo/bar' do
-    it { should match('/foo/bar')   }
-    it { should match('/foo%2Fbar') }
-    it { should match('/foo%2fbar') }
-  end
-
-  pattern '/:foo' do
-    it { should     match('/:foo')    }
-    it { should     match('/%3Afoo')  }
-    it { should_not match('/foo')     }
-    it { should_not match('/foo?')    }
-    it { should_not match('/foo/bar') }
-    it { should_not match('/')        }
-    it { should_not match('/foo/')    }
-
-    it { should generate_template('/:foo') }
-    it { should expand.to('/:foo')         }
-  end
-
-  pattern '/föö' do
-    it { should match("/f%C3%B6%C3%B6") }
-  end
-
-  pattern '/test$/' do
-    it { should match('/test$/') }
-  end
-
-  pattern '/te+st/' do
-    it { should     match('/te+st/') }
-    it { should_not match('/test/')  }
-    it { should_not match('/teest/') }
-  end
-
-  pattern "/path with spaces" do
-    it { should     match('/path%20with%20spaces') }
-    it { should_not match('/path%2Bwith%2Bspaces') }
-    it { should_not match('/path+with+spaces')     }
-    it { should generate_template('/path%20with%20spaces') }
-  end
-
-  pattern '/foo&bar' do
-    it { should match('/foo&bar') }
-  end
-
-  pattern '/test.bar' do
-    it { should     match('/test.bar') }
-    it { should_not match('/test0bar') }
-  end
-
-  pattern '/foo/bar', uri_decode: false do
-    it { should     match('/foo/bar')   }
-    it { should_not match('/foo%2Fbar') }
-    it { should_not match('/foo%2fbar') }
-  end
-
-  pattern "/path with spaces", uri_decode: false do
-    it { should_not match('/path%20with%20spaces') }
-    it { should_not match('/path%2Bwith%2Bspaces') }
-    it { should_not match('/path+with+spaces')     }
-  end
-
-  context "peeking" do
-    subject(:pattern) { Mustermann::Identity.new("foo bar") }
-
-    describe :peek_size do
-      example { pattern.peek_size("foo bar blah")   .should be == "foo bar".size }
-      example { pattern.peek_size("foo%20bar blah") .should be == "foo%20bar".size }
-      example { pattern.peek_size("foobar")         .should be_nil }
-    end
-
-    describe :peek_match do
-      example { pattern.peek_match("foo bar blah").to_s   .should be == "foo bar" }
-      example { pattern.peek_match("foo%20bar blah").to_s .should be == "foo%20bar" }
-      example { pattern.peek_match("foobar")              .should be_nil }
-    end
-
-    describe :peek_params do
-      example { pattern.peek_params("foo bar blah")   .should be == [{}, "foo bar".size] }
-      example { pattern.peek_params("foo%20bar blah") .should be == [{}, "foo%20bar".size] }
-      example { pattern.peek_params("foobar")         .should be_nil }
-    end
-  end
-end

data/spec/mapper_spec.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'mustermann/mapper'
-
-describe Mustermann::Mapper do
-  describe :initialize do
-    context 'accepts a block with no arguments, using the return value' do
-      subject(:mapper) { Mustermann::Mapper.new(additional_values: :raise) {{ "/foo" => "/bar" }}}
-      its(:to_h) { should be == { Mustermann.new("/foo") => Mustermann::Expander.new("/bar") } }
-      example { mapper['/foo'].should be == '/bar' }
-      example { mapper['/fox'].should be == '/fox' }
-    end
-
-    context 'accepts a block with argument, passes instance to it' do
-      subject(:mapper) { Mustermann::Mapper.new(additional_values: :raise) { |m| m["/foo"] = "/bar" }}
-      its(:to_h) { should be == { Mustermann.new("/foo") => Mustermann::Expander.new("/bar") } }
-      example { mapper['/foo'].should be == '/bar' }
-      example { mapper['/fox'].should be == '/fox' }
-    end
-
-    context 'accepts mappings followed by options' do
-      subject(:mapper) { Mustermann::Mapper.new({ "/foo" => "/bar" }, additional_values: :raise) }
-      its(:to_h) { should be == { Mustermann.new("/foo") => Mustermann::Expander.new("/bar") } }
-      example { mapper['/foo'].should be == '/bar' }
-      example { mapper['/fox'].should be == '/fox' }
-    end
-
-    context 'allows specifying type' do
-      subject(:mapper) { Mustermann::Mapper.new({ "/foo" => "/bar" }, additional_values: :raise, type: :rails) }
-      its(:to_h) { should be == { Mustermann.new("/foo", type: :rails) => Mustermann::Expander.new("/bar", type: :rails) } }
-      example { mapper['/foo'].should be == '/bar' }
-      example { mapper['/fox'].should be == '/fox' }
-    end
-  end
-
-  describe :convert do
-    subject(:mapper) { Mustermann::Mapper.new }
-
-    context 'it maps params' do
-      before { mapper["/:a"] = "/:a.html" }
-      example { mapper["/foo"]      .should be == "/foo.html" }
-      example { mapper["/foo/bar"]  .should be == "/foo/bar"  }
-    end
-
-    context 'it supports named splats' do
-      before { mapper["/*a"] = "/*a.html" }
-      example { mapper["/foo"]      .should be == "/foo.html"     }
-      example { mapper["/foo/bar"]  .should be == "/foo/bar.html" }
-    end
-
-    context 'can map from patterns' do
-      before { mapper[Mustermann.new("/:a")] = "/:a.html" }
-      example { mapper["/foo"]      .should be == "/foo.html" }
-      example { mapper["/foo/bar"]  .should be == "/foo/bar"  }
-    end
-
-    context 'can map to patterns' do
-      before { mapper[Mustermann.new("/:a")] = Mustermann.new("/:a.html") }
-      example { mapper["/foo"]      .should be == "/foo.html" }
-      example { mapper["/foo/bar"]  .should be == "/foo/bar"  }
-    end
-
-    context 'can map to expanders' do
-      before { mapper[Mustermann.new("/:a")] = Mustermann::Expander.new("/:a.html") }
-      example { mapper["/foo"]      .should be == "/foo.html" }
-      example { mapper["/foo/bar"]  .should be == "/foo/bar"  }
-    end
-
-    context 'can map to array' do
-      before { mapper["/:a"] = ["/:a.html", "/:a.:f"] }
-      example { mapper["/foo"]             .should be == "/foo.html" }
-      example { mapper["/foo", "f" => 'x'] .should be == "/foo.x"    }
-      example { mapper["/foo", f: 'x']     .should be == "/foo.x"    }
-      example { mapper["/foo/bar"]         .should be == "/foo/bar"  }
-    end
-  end
-end

data/spec/mustermann_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'mustermann'
-require 'sinatra/base'
-
-describe Mustermann do
-  describe :new do
-    context "string argument" do
-      example { Mustermann.new('')                  .should be_a(Mustermann::Sinatra)  }
-      example { Mustermann.new('', type: :identity) .should be_a(Mustermann::Identity) }
-      example { Mustermann.new('', type: :rails)    .should be_a(Mustermann::Rails)    }
-      example { Mustermann.new('', type: :shell)    .should be_a(Mustermann::Shell)    }
-      example { Mustermann.new('', type: :sinatra)  .should be_a(Mustermann::Sinatra)  }
-      example { Mustermann.new('', type: :simple)   .should be_a(Mustermann::Simple)   }
-      example { Mustermann.new('', type: :template) .should be_a(Mustermann::Template) }
-
-      example { expect { Mustermann.new('', foo:  :bar) }.to raise_error(ArgumentError, "unsupported option :foo for Mustermann::Sinatra") }
-      example { expect { Mustermann.new('', type: :ast) }.to raise_error(ArgumentError, "unsupported type :ast (cannot load such file -- mustermann/ast)") }
-    end
-
-    context "pattern argument" do
-      subject(:pattern) { Mustermann.new('') }
-      example { Mustermann.new(pattern).should be == pattern }
-      example { Mustermann.new(pattern, type: :rails).should be_a(Mustermann::Sinatra) }
-    end
-
-    context "regexp argument" do
-      example { Mustermann.new(//)               .should be_a(Mustermann::Regular) }
-      example { Mustermann.new(//, type: :rails) .should be_a(Mustermann::Regular) }
-    end
-
-    context "argument implementing #to_pattern" do
-      subject(:pattern) { Class.new { def to_pattern(**o) Mustermann.new('foo', **o) end }.new }
-      example { Mustermann.new(pattern)               .should be_a(Mustermann::Sinatra) }
-      example { Mustermann.new(pattern, type: :rails) .should be_a(Mustermann::Rails) }
-      example { Mustermann.new(pattern).to_s.should be == 'foo' }
-    end
-
-    context "multiple arguments" do
-      example { Mustermann.new(':a', ':b/:a')                        .should be_a(Mustermann::Composite) }
-      example { Mustermann.new(':a', ':b/:a').patterns.first         .should be_a(Mustermann::Sinatra)   }
-      example { Mustermann.new(':a', ':b/:a').operator               .should be == :|                    }
-      example { Mustermann.new(':a', ':b/:a', operator: :&).operator .should be == :&                    }
-      example { Mustermann.new(':a', ':b/:a', greedy: true)          .should be_a(Mustermann::Composite) }
-
-      example { Mustermann.new('/foo', ':bar')      .should be_a(Mustermann::Sinatra) }
-      example { Mustermann.new('/foo', ':bar').to_s .should be == "/foo|{bar}"        }
-    end
-
-    context "invalid arguments" do
-      it "raise a TypeError for unsupported types" do
-        expect { Mustermann.new(10) }.to raise_error(TypeError, /(Integer|Fixnum) can't be coerced into Mustermann::Pattern/)
-      end
-    end
-  end
-
-  describe :[] do
-    example { Mustermann[:identity] .should be == Mustermann::Identity }
-    example { Mustermann[:rails]    .should be == Mustermann::Rails    }
-    example { Mustermann[:shell]    .should be == Mustermann::Shell    }
-    example { Mustermann[:sinatra]  .should be == Mustermann::Sinatra  }
-    example { Mustermann[:simple]   .should be == Mustermann::Simple   }
-    example { Mustermann[:template] .should be == Mustermann::Template }
-
-    example { expect { Mustermann[:ast]      }.to raise_error(ArgumentError, "unsupported type :ast (cannot load such file -- mustermann/ast)") }
-    example { expect { Mustermann[:expander] }.to raise_error(ArgumentError, "unsupported type :expander") }
-  end
-
-  describe :extend_object do
-    context 'special behavior for Sinatra only' do
-      example { Object  .new.extend(Mustermann).should     be_a(Mustermann)            }
-      example { Class   .new.extend(Mustermann).should     be_a(Mustermann)            }
-
-      example { expect { Sinatra.new.extend(Mustermann) }.to raise_error(RuntimeError, "Mustermann extension for Sinatra has been extracted into its own gem. More information at https://github.com/sinatra/mustermann-sinatra-extension") }
-    end
-  end
-
-  describe :=== do
-    example { Mustermann.should be === Mustermann.new("") }
-  end
-end

data/spec/pattern_spec.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'mustermann/pattern'
-require 'mustermann/sinatra'
-require 'mustermann/rails'
-
-describe Mustermann::Pattern do
-  describe :=== do
-    it 'raises a NotImplementedError when used directly' do
-      expect { Mustermann::Pattern.new("") === "" }.to raise_error(NotImplementedError)
-    end
-  end
-
-  describe :initialize do
-    it 'raises an ArgumentError for unknown options' do
-      expect { Mustermann::Pattern.new("", foo: :bar) }.to raise_error(ArgumentError)
-    end
-
-    it 'does not complain about unknown options if ignore_unknown_options is enabled' do
-      expect { Mustermann::Pattern.new("", foo: :bar, ignore_unknown_options: true) }.not_to raise_error
-    end
-  end
-
-  describe :respond_to? do
-    subject(:pattern) { Mustermann::Pattern.new("") }
-
-    it { should_not respond_to(:expand)       }
-    it { should_not respond_to(:to_templates) }
-
-    it { expect { pattern.expand }       .to raise_error(NotImplementedError) }
-    it { expect { pattern.to_templates } .to raise_error(NotImplementedError) }
-  end
-
-  describe :== do
-    example { Mustermann::Pattern.new('/foo') .should     be == Mustermann::Pattern.new('/foo') }
-    example { Mustermann::Pattern.new('/foo') .should_not be == Mustermann::Pattern.new('/bar') }
-    example { Mustermann::Sinatra.new('/foo') .should     be == Mustermann::Sinatra.new('/foo') }
-    example { Mustermann::Rails.new('/foo')   .should_not be == Mustermann::Sinatra.new('/foo') }
-  end
-
-  describe :eql? do
-    example { Mustermann::Pattern.new('/foo') .should     be_eql Mustermann::Pattern.new('/foo') }
-    example { Mustermann::Pattern.new('/foo') .should_not be_eql Mustermann::Pattern.new('/bar') }
-    example { Mustermann::Sinatra.new('/foo') .should     be_eql Mustermann::Sinatra.new('/foo') }
-    example { Mustermann::Rails.new('/foo')   .should_not be_eql Mustermann::Sinatra.new('/foo') }
-  end
-
-  describe :equal? do
-    example { Mustermann::Pattern.new('/foo') .should     be_equal Mustermann::Pattern.new('/foo') }
-    example { Mustermann::Pattern.new('/foo') .should_not be_equal Mustermann::Pattern.new('/bar') }
-    example { Mustermann::Sinatra.new('/foo') .should     be_equal Mustermann::Sinatra.new('/foo') }
-    example { Mustermann::Rails.new('/foo')   .should_not be_equal Mustermann::Sinatra.new('/foo') }
-  end
-end

data/spec/regexp_based_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'mustermann/regexp_based'
-
-describe Mustermann::RegexpBased do
-  it 'raises a NotImplementedError when used directly' do
-    expect { Mustermann::RegexpBased.new("") === "" }.to raise_error(NotImplementedError)
-  end
-end