mustermann 0.4.0 → 1.0.0.beta2

data/lib/mustermann/sinatra/safe_renderer.rb

@@ -0,0 +1,26 @@
+module Mustermann
+  class Sinatra < AST::Pattern
+    # Generates a string that can safely be concatenated with other strings
+    # without chaning its semantics
+    # @see #safe_string
+    # @!visibility private
+    SafeRenderer = AST::Translator.create do
+      translate(:splat, :named_splat) { "{+#{name}}"                           }
+      translate(:char, :separator)    { Sinatra.escape(payload)                }
+      translate(:root)                { t(payload)                             }
+      translate(:group)               { "(#{t(payload)})"                      }
+      translate(:union)               { "(#{t(payload, join: ?|)})"            }
+      translate(:optional)            { "#{t(payload)}?"                       }
+      translate(Array)                { |join: ""| map { |e| t(e) }.join(join) }
+
+      translate(:capture) do
+        raise Mustermann::Error, 'cannot render variables'      if node.is_a? :variable
+        raise Mustermann::Error, 'cannot translate constraints' if constraint or qualifier or convert
+        prefix = node.is_a?(:splat) ? "+" : ""
+        "{#{prefix}#{name}}"
+      end
+    end
+
+    private_constant :SafeRenderer
+  end
+end

data/lib/mustermann/sinatra/try_convert.rb

@@ -0,0 +1,48 @@
+module Mustermann
+  class Sinatra < AST::Pattern
+    # Tries to translate objects to Sinatra patterns.
+    # @!visibility private
+    class TryConvert < AST::Translator
+      # @return [Mustermann::Sinatra, nil]
+      # @!visibility private
+      def self.convert(input, **options)
+        new(options).translate(input)
+      end
+
+      # Expected options for the resulting pattern.
+      # @!visibility private
+      attr_reader :options
+
+      # @!visibility private
+      def initialize(options)
+        @options = options
+      end
+
+      # @return [Mustermann::Sinatra]
+      # @!visibility private
+      def new(input, escape = false)
+        input = Mustermann::Sinatra.escape(input) if escape
+        Mustermann::Sinatra.new(input, **options)
+      end
+
+      # @return [true, false] whether or not expected pattern should have uri_decode option set
+      # @!visibility private
+      def uri_decode
+        options.fetch(:uri_decode, true)
+      end
+
+      translate(Object) { nil               }
+      translate(String) { t.new(self, true) }
+
+      translate(Identity) { t.new(self, true) if uri_decode == t.uri_decode }
+      translate(Sinatra)  { node              if options    == t.options    }
+
+      translate AST::Pattern do
+        next unless options == t.options
+        t.new(SafeRenderer.translate(to_ast)) rescue nil
+      end
+    end
+
+    private_constant :TryConvert
+  end
+end

data/lib/mustermann/version.rb

@@ -1,3 +1,3 @@
 module Mustermann
-  VERSION ||= '0.4.0'
+  VERSION ||= '1.0.0.beta2'
 end

data/mustermann.gemspec

@@ -10,9 +10,8 @@ Gem::Specification.new do |s|
   s.summary               = %q{use patterns like regular expressions}
   s.description           = %q{library implementing patterns that behave like regular expressions}
   s.license               = 'MIT'
-  s.required_ruby_version = '>= 2.1.0'
+  s.required_ruby_version = '>= 2.2.0'
   s.files                 = `git ls-files`.split("\n")
   s.test_files            = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables           = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.add_dependency 'tool', '~> 0.2'
 end

data/spec/composite_spec.rb

@@ -12,6 +12,14 @@ describe Mustermann::Composite 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
@@ -64,6 +72,13 @@ describe Mustermann::Composite do
         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
@@ -136,12 +151,12 @@ describe Mustermann::Composite do
 
   describe :inspect do
     let(:sinatra)  { Mustermann.new('x')                  }
-    let(:rails)    { Mustermann.new('x', type: :rails)    }
+    let(:shell)    { Mustermann.new('x', type: :shell)    }
     let(:identity) { Mustermann.new('x', type: :identity) }
 
-    example { (sinatra | rails)            .inspect.should include('(sinatra:"x" | rails:"x")')                  }
-    example { (sinatra ^ rails)            .inspect.should include('(sinatra:"x" ^ rails:"x")')                  }
-    example { (sinatra | rails | identity) .inspect.should include('(sinatra:"x" | rails:"x" | identity:"x")')   }
-    example { (sinatra | rails & identity) .inspect.should include('(sinatra:"x" | (rails:"x" & identity:"x"))') }
+    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

@@ -0,0 +1,114 @@
+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
+  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

@@ -0,0 +1,25 @@
+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("foo") { "foo" }
+      expect(subject.map).to receive(:[]).and_return(nil)
+      result = subject.fetch("foo") { "bar" }
+      expect(result).to be == "bar"
+    end
+  end
+end

data/spec/mustermann_spec.rb

@@ -37,11 +37,14 @@ describe Mustermann do
     end
 
     context "multiple arguments" do
-      example { Mustermann.new('', '')                        .should be_a(Mustermann::Composite) }
-      example { Mustermann.new('', '').patterns.first         .should be_a(Mustermann::Sinatra)   }
-      example { Mustermann.new('', '').operator               .should be == :|                    }
-      example { Mustermann.new('', '', operator: :&).operator .should be == :&                    }
-      example { Mustermann.new('', '', greedy: true)          .should be_a(Mustermann::Composite) }
+      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

data/spec/regular_spec.rb

@@ -37,6 +37,46 @@ describe Mustermann::Regular do
     it { should match('/foo%2Fbar') .capturing foo: 'foo%2Fbar' }
   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>[^/]+)") }
 

data/spec/sinatra_spec.rb

@@ -463,6 +463,40 @@ describe Mustermann::Sinatra do
     it { should_not expand(a: 'foo', b: 'bar', c: 'baz')   }
   end
 
+  pattern "/:a/:b|:c" do
+    it { should match("foo")      .capturing c: 'foo'           }
+    it { should match("/foo/bar") .capturing a: 'foo', b: 'bar' }
+
+    it { should generate_template('/{a}/{b}') }
+    it { should generate_template('{c}')      }
+
+    it { should expand(a: 'foo', b: 'bar') .to('/foo/bar') }
+    it { should expand(c: 'foo')           .to('foo')      }
+    it { should_not expand(a: 'foo', b: 'bar', c: 'baz')   }
+  end
+
+  pattern "/({foo}|{bar})", capture: { foo: /\d+/, bar: /\w+/ } do
+    it { should match("/a")    .capturing foo: nil,    bar: 'a' }
+    it { should match("/1234") .capturing foo: "1234", bar: nil }
+
+    it { should_not match("/a/b") }
+  end
+
+  pattern "/{foo|bar}", capture: { foo: /\d+/, bar: /\w+/ } do
+    it { should match("/a")    .capturing foo: nil,    bar: 'a' }
+    it { should match("/1234") .capturing foo: "1234", bar: nil }
+
+    it { should_not match("/a/b") }
+  end
+
+  pattern "/{foo|bar|baz}", capture: { foo: /\d+/, bar: /[ab]+/, baz: /[cde]+/ } do
+    it { should match("/ab")     .capturing foo: nil,    bar: 'ab', baz: nil }
+    it { should match("/1234")   .capturing foo: "1234", bar: nil, baz: nil }
+    it { should match("/ccddee") .capturing foo: nil,    bar: nil, baz: "ccddee" }
+
+    it { should_not match("/a/b") }
+  end
+
   pattern '/:foo', capture: /\d+/ do
     it { should match('/1')   .capturing foo: '1'   }
     it { should match('/123') .capturing foo: '123' }
@@ -648,11 +682,6 @@ describe Mustermann::Sinatra do
         to raise_error(Mustermann::ParseError, 'unexpected ? while parsing "foo??bar"')
     end
 
-    example '| outside of group' do
-      expect { Mustermann::Sinatra.new('foo|bar') }.
-        to raise_error(Mustermann::ParseError, 'unexpected | while parsing "foo|bar"')
-    end
-
     example 'dangling escape' do
       expect { Mustermann::Sinatra.new('foo\\') }.
         to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "foo\\\\"')
@@ -745,4 +774,55 @@ describe Mustermann::Sinatra do
       example { pattern.peek_params("/foo bar")       .should be_nil }
     end
   end
+
+  describe :| do
+    let(:first)  { Mustermann.new("a") }
+    let(:second) { Mustermann.new("b") }
+    subject(:composite) { first | second }
+
+    context "with no capture names" do
+      its(:class) { should be == Mustermann::Sinatra }
+      its(:to_s)  { should be == "a|b"               }
+    end
+
+    context "only first has captures" do
+      let(:first) { Mustermann.new(":a") }
+      its(:class) { should be == Mustermann::Sinatra }
+      its(:to_s)  { should be == "{a}|b"             }
+    end
+
+    context "only second has captures" do
+      let(:second) { Mustermann.new(":b") }
+      its(:class)  { should be == Mustermann::Sinatra }
+      its(:to_s)   { should be == "a|{b}"             }
+    end
+
+    context "both have captures" do
+      let(:first)  { Mustermann.new(":a") }
+      let(:second) { Mustermann.new(":b") }
+      its(:class)  { should be == Mustermann::Composite }
+    end
+
+    context "options mismatch" do
+      let(:second) { Mustermann.new(":b", greedy: false) }
+      its(:class)  { should be == Mustermann::Composite  }
+    end
+
+    context "argument is a string" do
+      let(:second) { ":b" }
+      its(:class)  { should be == Mustermann::Sinatra }
+      its(:to_s)   { should be == "a|\\:b"            }
+    end
+
+    context "argument is an identity pattern" do
+      let(:second) { Mustermann::Identity.new(":b")   }
+      its(:class)  { should be == Mustermann::Sinatra }
+      its(:to_s)   { should be == "a|\\:b"            }
+    end
+
+    context "argument is an identity pattern, but options mismatch" do
+      let(:second) { Mustermann::Identity.new(":b", uri_decode: false) }
+      its(:class)  { should be == Mustermann::Composite                }
+    end
+  end
 end