mustermann 3.0.3 → 3.1.1

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

data/spec/regular_spec.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'timeout'
-require 'mustermann/regular'
-
-describe Mustermann::Regular do
-  extend Support::Pattern
-
-  pattern '' do
-    it { should     match('')  }
-    it { should_not match('/') }
-
-    it { should_not respond_to(:expand)       }
-    it { should_not respond_to(:to_templates) }
-  end
-
-  pattern '/' do
-    it { should     match('/')    }
-    it { should_not match('/foo') }
-  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_not match('/foo%2Fbar') }
-    it { should_not match('/foo%2fbar') }
-  end
-
-  pattern '/(?<foo>.*)' do
-    it { should match('/foo')       .capturing foo: 'foo'       }
-    it { should match('/bar')       .capturing foo: 'bar'       }
-    it { should match('/foo.bar')   .capturing foo: 'foo.bar'   }
-    it { should match('/%0Afoo')    .capturing foo: '%0Afoo'    }
-    it { should match('/foo%2Fbar') .capturing foo: 'foo%2Fbar' }
-  end
-
-
-  context 'with Regexp::EXTENDED' do
-    let(:pattern) {
-      %r{
-        \/compare\/ # match any URL beginning with \/compare\/
-        (.+)      # extract the full path (including any directories)
-        \/         # match the final slash
-        ([^.]+)   # match the first SHA1
-        \.{2,3}   # match .. or ...
-        (.+)      # match the second SHA1
-      }x
-    }
-    example { expect { Timeout.timeout(1){ Mustermann::Regular.new(pattern) }}.not_to raise_error }
-    it { expect(Mustermann::Regular.new(pattern)).to match('/compare/foo/bar..baz') }
-  end
-
-  describe :check_achnors do
-    context 'raises on anchors' do
-      example { expect { Mustermann::Regular.new('^foo')        }.to     raise_error(Mustermann::CompileError) }
-      example { expect { Mustermann::Regular.new('foo$')        }.to     raise_error(Mustermann::CompileError) }
-      example { expect { Mustermann::Regular.new('\Afoo')       }.to     raise_error(Mustermann::CompileError) }
-      example { expect { Mustermann::Regular.new('foo\Z')       }.to     raise_error(Mustermann::CompileError) }
-      example { expect { Mustermann::Regular.new('foo\z')       }.to     raise_error(Mustermann::CompileError) }
-      example { expect { Mustermann::Regular.new(/^foo/)        }.to     raise_error(Mustermann::CompileError) }
-      example { expect { Mustermann::Regular.new(/foo$/)        }.to     raise_error(Mustermann::CompileError) }
-      example { expect { Mustermann::Regular.new(/\Afoo/)       }.to     raise_error(Mustermann::CompileError) }
-      example { expect { Mustermann::Regular.new(/foo\Z/)       }.to     raise_error(Mustermann::CompileError) }
-      example { expect { Mustermann::Regular.new(/foo\z/)       }.to     raise_error(Mustermann::CompileError) }
-      example { expect { Mustermann::Regular.new('[^f]')        }.not_to raise_error }
-      example { expect { Mustermann::Regular.new('\\\A')        }.not_to raise_error }
-      example { expect { Mustermann::Regular.new('[[:digit:]]') }.not_to raise_error }
-      example { expect { Mustermann::Regular.new(/[^f]/)        }.not_to raise_error }
-      example { expect { Mustermann::Regular.new(/\\A/)         }.not_to raise_error }
-      example { expect { Mustermann::Regular.new(/[[:digit:]]/) }.not_to raise_error }
-    end
-
-    context 'with check_anchors disabled' do
-      example { expect { Mustermann::Regular.new('^foo',        check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new('foo$',        check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new('\Afoo',       check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new('foo\Z',       check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new('foo\z',       check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new(/^foo/,        check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new(/foo$/,        check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new(/\Afoo/,       check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new(/foo\Z/,       check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new(/foo\z/,       check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new('[^f]',        check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new('\\\A',        check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new('[[:digit:]]', check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new(/[^f]/,        check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new(/\\A/,         check_anchors: false) }.not_to raise_error }
-      example { expect { Mustermann::Regular.new(/[[:digit:]]/, check_anchors: false) }.not_to raise_error }
-    end
-  end
-
-  context "peeking" do
-    subject(:pattern) { Mustermann::Regular.new("(?<name>[^/]+)") }
-
-    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("/foo bar")       .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("/foo bar")             .should be_nil }
-    end
-
-    describe :peek_params do
-      example { pattern.peek_params("foo bar/blah")   .should be == [{"name" => "foo bar"}, "foo bar".size] }
-      example { pattern.peek_params("foo%20bar/blah") .should be == [{"name" => "foo bar"}, "foo%20bar".size] }
-      example { pattern.peek_params("/foo bar")       .should be_nil }
-    end
-  end
-end

data/spec/simple_match_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'mustermann/simple_match'
-
-describe Mustermann::SimpleMatch do
-  subject { Mustermann::SimpleMatch.new('example') }
-  its(:to_s) { should be == 'example' }
-  its(:names) { should be == [] }
-  its(:captures) { should be == [] }
-  example { subject[1].should be == nil }
-end