From: Lucas Kanashiro <kanashiro@ubuntu.com>
Date: Fri, 16 Sep 2022 12:25:51 -0300
Subject: Skip tests which require types included in mustermann-contrib

mustermann-contrib is not shipped, it requires new dependencies. Due to
that the following types does not work:

- rails
- shell
- simple
- template

Forwarded: not-needed

---
 mustermann/spec/composite_spec.rb  |  6 +++---
 mustermann/spec/concat_spec.rb     | 12 ++++++------
 mustermann/spec/expander_spec.rb   | 20 ++++++++++----------
 mustermann/spec/mapper_spec.rb     |  2 +-
 mustermann/spec/mustermann_spec.rb | 22 +++++++++++-----------
 mustermann/spec/pattern_spec.rb    |  6 +++---
 mustermann/spec/to_pattern_spec.rb | 18 +++++++++---------
 7 files changed, 43 insertions(+), 43 deletions(-)

--- a/mustermann/spec/composite_spec.rb
+++ b/mustermann/spec/composite_spec.rb
@@ -56,7 +56,7 @@ describe Mustermann::Composite do
       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
+      xcontext "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) }
@@ -67,7 +67,7 @@ describe Mustermann::Composite do
       example { should respond_to(:to_templates) }
       example { should generate_templates('/foo/{name}', '/{first}/{second}') }
 
-      context "without patterns implementing to_templates" do
+      xcontext "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) }
@@ -150,7 +150,7 @@ describe Mustermann::Composite do
     end
   end
 
-  describe :inspect do
+  xdescribe :inspect do
     let(:sinatra)  { Mustermann.new('x')                  }
     let(:shell)    { Mustermann.new('x', type: :shell)    }
     let(:identity) { Mustermann.new('x', type: :identity) }
--- a/mustermann/spec/concat_spec.rb
+++ b/mustermann/spec/concat_spec.rb
@@ -22,19 +22,19 @@ describe Mustermann::Concat do
       its(:to_s)  { should be == "foobar" }
     end
 
-    context "sinatra + rails" do
+    xcontext "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
+    xcontext "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
+    xcontext "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>")' }
@@ -46,13 +46,13 @@ describe Mustermann::Concat do
       its(:to_s)  { should be == '(sinatra:"/:foo" + sinatra:"/:bar")' }
     end
 
-    context "sinatra + rails (different options)" do
+    xcontext "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
+    xcontext "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")' }
@@ -64,7 +64,7 @@ describe Mustermann::Concat do
       its(:to_s)  { should be == '(sinatra:"/foo/bar" + regular:"baz")' }
     end
 
-    context "sinatra + (sinatra + rails (different options) + sinatra)" do
+    xcontext "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")' }
--- a/mustermann/spec/expander_spec.rb
+++ b/mustermann/spec/expander_spec.rb
@@ -14,13 +14,13 @@ describe Mustermann::Expander do
     expander.expand(foo: 23).should be == "/23"
   end
 
-  it 'supports setting pattern options' do
+  xit '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
+  xit '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"
@@ -96,28 +96,28 @@ describe Mustermann::Expander do
   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) }
+    xexample { Mustermann::Expander.new('/foo', type: :rails) .should     be == Mustermann::Expander.new('/foo', type: :rails) }
+    xexample { 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 }
+    xexample { Mustermann::Expander.new('/foo', type: :rails) .hash.should     be == Mustermann::Expander.new('/foo', type: :rails).hash }
+    xexample { 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) }
+    xexample { Mustermann::Expander.new('/foo', type: :rails) .should     be_eql Mustermann::Expander.new('/foo', type: :rails) }
+    xexample { 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) }
+    xexample { Mustermann::Expander.new('/foo', type: :rails) .should_not be_equal Mustermann::Expander.new('/foo', type: :rails) }
+    xexample { Mustermann::Expander.new('/foo', type: :rails) .should_not be_equal Mustermann::Expander.new('/foo', type: :sinatra) }
   end
 end
--- a/mustermann/spec/mapper_spec.rb
+++ b/mustermann/spec/mapper_spec.rb
@@ -25,7 +25,7 @@ describe Mustermann::Mapper do
       example { mapper['/fox'].should be == '/fox' }
     end
 
-    context 'allows specifying type' do
+    xcontext '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' }
--- a/mustermann/spec/mustermann_spec.rb
+++ b/mustermann/spec/mustermann_spec.rb
@@ -8,11 +8,11 @@ describe Mustermann 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)    }
+      xexample { Mustermann.new('', type: :rails)    .should be_a(Mustermann::Rails)    }
+      xexample { 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) }
+      xexample { Mustermann.new('', type: :simple)   .should be_a(Mustermann::Simple)   }
+      xexample { 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)") }
@@ -21,18 +21,18 @@ describe Mustermann do
     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) }
+      xexample { 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) }
+      xexample { 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) }
+      xexample { Mustermann.new(pattern, type: :rails) .should be_a(Mustermann::Rails) }
       example { Mustermann.new(pattern).to_s.should be == 'foo' }
     end
 
@@ -56,11 +56,11 @@ describe Mustermann do
 
   describe :[] do
     example { Mustermann[:identity] .should be == Mustermann::Identity }
-    example { Mustermann[:rails]    .should be == Mustermann::Rails    }
-    example { Mustermann[:shell]    .should be == Mustermann::Shell    }
+    xexample { Mustermann[:rails]    .should be == Mustermann::Rails    }
+    xexample { 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 }
+    xexample { Mustermann[:simple]   .should be == Mustermann::Simple   }
+    xexample { 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") }
--- a/mustermann/spec/pattern_spec.rb
+++ b/mustermann/spec/pattern_spec.rb
@@ -34,20 +34,20 @@ describe Mustermann::Pattern 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') }
+    xexample { 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') }
+    xexample { 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') }
+    xexample { Mustermann::Rails.new('/foo')   .should_not be_equal Mustermann::Sinatra.new('/foo') }
   end
 end
--- a/mustermann/spec/to_pattern_spec.rb
+++ b/mustermann/spec/to_pattern_spec.rb
@@ -6,28 +6,28 @@ require 'delegate'
 describe Mustermann::ToPattern do
   context String do
     example { "".to_pattern               .should be_a(Mustermann::Sinatra) }
-    example { "".to_pattern(type: :rails) .should be_a(Mustermann::Rails)   }
+    xexample { "".to_pattern(type: :rails) .should be_a(Mustermann::Rails)   }
   end
 
   context Regexp do
     example { //.to_pattern               .should be_a(Mustermann::Regular) }
-    example { //.to_pattern(type: :rails) .should be_a(Mustermann::Regular) }
+    xexample { //.to_pattern(type: :rails) .should be_a(Mustermann::Regular) }
   end
 
   context Symbol do
     example { :foo.to_pattern               .should be_a(Mustermann::Sinatra) }
-    example { :foo.to_pattern(type: :rails) .should be_a(Mustermann::Sinatra) }
+    xexample { :foo.to_pattern(type: :rails) .should be_a(Mustermann::Sinatra) }
   end
 
   context Array do
     example { [:foo, :bar].to_pattern               .should be_a(Mustermann::Composite) }
-    example { [:foo, :bar].to_pattern(type: :rails) .should be_a(Mustermann::Composite) }
+    xexample { [:foo, :bar].to_pattern(type: :rails) .should be_a(Mustermann::Composite) }
   end
 
   context Mustermann::Pattern do
     subject(:pattern) { Mustermann.new('') }
     example { pattern.to_pattern.should be == pattern }
-    example { pattern.to_pattern(type: :rails).should be_a(Mustermann::Sinatra) }
+    xexample { pattern.to_pattern(type: :rails).should be_a(Mustermann::Sinatra) }
   end
 
   context 'custom class' do
@@ -41,9 +41,9 @@ describe Mustermann::ToPattern do
     end
 
     example { example_class.new.to_pattern                    .should be_a(Mustermann::Sinatra) }
-    example { example_class.new.to_pattern(type: :rails)      .should be_a(Mustermann::Rails)   }
+    xexample { example_class.new.to_pattern(type: :rails)      .should be_a(Mustermann::Rails)   }
     example { Mustermann.new(example_class.new)               .should be_a(Mustermann::Sinatra) }
-    example { Mustermann.new(example_class.new, type: :rails) .should be_a(Mustermann::Rails)   }
+    xexample { Mustermann.new(example_class.new, type: :rails) .should be_a(Mustermann::Rails)   }
   end
 
   context 'primitive delegate' do
@@ -54,7 +54,7 @@ describe Mustermann::ToPattern do
     end
 
     example { example_class.new([:foo, :bar]).to_pattern               .should be_a(Mustermann::Composite) }
-    example { example_class.new([:foo, :bar]).to_pattern(type: :rails) .should be_a(Mustermann::Composite) }
+    xexample { example_class.new([:foo, :bar]).to_pattern(type: :rails) .should be_a(Mustermann::Composite) }
   end
 
   context 'primitive subclass' do
@@ -65,6 +65,6 @@ describe Mustermann::ToPattern do
     end
 
     example { example_class.new([:foo, :bar]).to_pattern               .should be_a(Mustermann::Composite) }
-    example { example_class.new([:foo, :bar]).to_pattern(type: :rails) .should be_a(Mustermann::Composite) }
+    xexample { example_class.new([:foo, :bar]).to_pattern(type: :rails) .should be_a(Mustermann::Composite) }
   end
 end