mustermann 3.0.4 → 3.1.1

data/spec/composite_spec.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'mustermann'
-
-describe Mustermann::Composite do
-  describe :new do
-    example 'with no argument' do
-      expect { Mustermann::Composite.new }.
-        to raise_error(ArgumentError, 'cannot create empty composite pattern')
-    end
-
-    example 'with one argument' do
-      pattern = Mustermann.new('/foo')
-      Mustermann::Composite.new(pattern).should be == pattern
-    end
-
-    example 'with supported type specific arguments' do
-      Mustermann::Composite.new("/a", "/b", greedy: true)
-    end
-
-    example 'with unsupported type specific arguments' do
-      expect { Mustermann::Composite.new("/a", "/b", greedy: true, type: :identity) }.to raise_error(ArgumentError)
-    end
-  end
-
-  context :| do
-    subject(:pattern) { Mustermann.new('/foo/:name', '/:first/:second') }
-
-    describe :== do
-      example { subject.should     be == subject                                                       }
-      example { subject.should     be == Mustermann.new('/foo/:name', '/:first/:second')               }
-      example { subject.should_not be == Mustermann.new('/foo/:name')                                  }
-      example { subject.should_not be == Mustermann.new('/foo/:name', '/:first/:second', operator: :&) }
-    end
-
-    describe :=== do
-      example { subject.should     be === "/foo/bar" }
-      example { subject.should     be === "/fox/bar" }
-      example { subject.should_not be === "/foo"     }
-    end
-
-    describe :params do
-      example { subject.params("/foo/bar") .should be == { "name"  => "bar" }                    }
-      example { subject.params("/fox/bar") .should be == { "first" => "fox", "second" => "bar" } }
-      example { subject.params("/foo")     .should be_nil                                        }
-    end
-
-    describe :=== do
-      example { subject.should     match("/foo/bar") }
-      example { subject.should     match("/fox/bar") }
-      example { subject.should_not match("/foo")     }
-    end
-
-    describe :expand do
-      example { subject.should respond_to(:expand) }
-      example { subject.expand(name: 'bar')                 .should be == '/foo/bar' }
-      example { subject.expand(first: 'fox', second: 'bar') .should be == '/fox/bar' }
-
-      context "without expandable patterns" do
-        subject(:pattern) { Mustermann.new('/foo/:name', '/:first/:second', type: :simple) }
-        example { subject.should_not respond_to(:expand) }
-        example { expect { subject.expand(name: 'bar') }.to raise_error(NotImplementedError) }
-      end
-    end
-
-    describe :to_templates do
-      example { should respond_to(:to_templates) }
-      example { should generate_templates('/foo/{name}', '/{first}/{second}') }
-
-      context "without patterns implementing to_templates" do
-        subject(:pattern) { Mustermann.new('/foo/:name', '/:first/:second', type: :simple) }
-        example { should_not respond_to(:to_templates) }
-        example { expect { subject.to_templates }.to raise_error(NotImplementedError) }
-      end
-    end
-
-    describe :eql? do
-      example { should     be_eql(pattern)                                                       }
-      example { should     be_eql(Mustermann.new('/foo/:name', '/:first/:second', operator: :|)) }
-      example { should_not be_eql(Mustermann.new('/bar/:name', '/:first/:second', operator: :|)) }
-      example { should_not be_eql(Mustermann.new('/foo/:name', '/:first/:second', operator: :&)) }
-    end
-  end
-
-  context :& do
-    subject(:pattern) { Mustermann.new('/foo/:name', '/:first/:second', operator: :&) }
-
-    describe :== do
-      example { subject.should     be == subject                                                       }
-      example { subject.should     be == Mustermann.new('/foo/:name', '/:first/:second', operator: :&) }
-      example { subject.should_not be == Mustermann.new('/foo/:name')                                  }
-      example { subject.should_not be == Mustermann.new('/foo/:name', '/:first/:second')               }
-    end
-
-    describe :=== do
-      example { subject.should     be === "/foo/bar" }
-      example { subject.should_not be === "/fox/bar" }
-      example { subject.should_not be === "/foo"     }
-    end
-
-    describe :params do
-      example { subject.params("/foo/bar") .should be == { "name"  => "bar" } }
-      example { subject.params("/fox/bar") .should be_nil                     }
-      example { subject.params("/foo")     .should be_nil                     }
-    end
-
-    describe :match do
-      example { subject.should     match("/foo/bar") }
-      example { subject.should_not match("/fox/bar") }
-      example { subject.should_not match("/foo")     }
-    end
-
-    describe :expand do
-      example { subject.should_not respond_to(:expand) }
-      example { expect { subject.expand(name: 'bar') }.to raise_error(NotImplementedError) }
-    end
-  end
-
-  context :^ do
-    subject(:pattern) { Mustermann.new('/foo/:name', '/:first/:second', operator: :^) }
-
-    describe :== do
-      example { subject.should     be == subject                                                       }
-      example { subject.should_not be == Mustermann.new('/foo/:name', '/:first/:second')               }
-      example { subject.should_not be == Mustermann.new('/foo/:name')                                  }
-      example { subject.should_not be == Mustermann.new('/foo/:name', '/:first/:second', operator: :&) }
-    end
-
-    describe :=== do
-      example { subject.should_not be === "/foo/bar" }
-      example { subject.should     be === "/fox/bar" }
-      example { subject.should_not be === "/foo"     }
-    end
-
-    describe :params do
-      example { subject.params("/foo/bar") .should be_nil                                        }
-      example { subject.params("/fox/bar") .should be == { "first" => "fox", "second" => "bar" } }
-      example { subject.params("/foo")     .should be_nil                                        }
-    end
-
-    describe :match do
-      example { subject.should_not match("/foo/bar") }
-      example { subject.should     match("/fox/bar") }
-      example { subject.should_not match("/foo")     }
-    end
-
-    describe :expand do
-      example { subject.should_not respond_to(:expand) }
-      example { expect { subject.expand(name: 'bar') }.to raise_error(NotImplementedError) }
-    end
-  end
-
-  describe :inspect do
-    let(:sinatra)  { Mustermann.new('x')                  }
-    let(:shell)    { Mustermann.new('x', type: :shell)    }
-    let(:identity) { Mustermann.new('x', type: :identity) }
-
-    example { (sinatra | shell)            .inspect.should include('(sinatra:"x" | shell:"x")')                  }
-    example { (sinatra ^ shell)            .inspect.should include('(sinatra:"x" ^ shell:"x")')                  }
-    example { (sinatra | shell | identity) .inspect.should include('(sinatra:"x" | shell:"x" | identity:"x")')   }
-    example { (sinatra | shell & identity) .inspect.should include('(sinatra:"x" | (shell:"x" & identity:"x"))') }
-  end
-end

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