mustermann 3.0.4 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffbf76294166044123cd87324aed9709679a8ef4893219bcf75cbefd398d52b7
-  data.tar.gz: 4cbc5a0908b6f0839ad1875543b869da09e59ace62f4be875e259326f3f874f4
+  metadata.gz: e0b15c2c5c75d712dde03df8b83d4f0b646455aa892eb59365f1b09ce01bfa7c
+  data.tar.gz: 358ce50be0eb8638e47ea8bb3cd65512f57e10eb65b93600098145214a2f6d39
 SHA512:
-  metadata.gz: 88f278df75556096c65cf7148a7a543a2d4620b86568bb58c0bd649e6383caf6257a2417e2d9e6d260c5ac042c54eb91545120301a9d3262d9e9e134857d13f3
-  data.tar.gz: 8052170d96e904511af77ca90d966735b51338186ec9be0e61d10def3e2974a08fdfc62f6dbc9414ae92ffa35fd2102bf546bd0a98c67e53bc91abb1c0a0e1c9
+  metadata.gz: 3360ad1465989d2179b97d67c64261d7a68cf22ca1cea2a02f2450bd5b0894948efd4d99581b7d7609dc7698d4ed0595d85613b67d79dce3ce79b84d08e614ff
+  data.tar.gz: 8c32fae7ff72697598dacf54c1ddae95ea80a48814fa887c61d91e18bca6a0a1c79768a981fba0cd4d60d986db76c0961a3f6dae5c5a7a8b8276978428fb105e

data/lib/mustermann/ast/expander.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require 'mustermann/ast/translator'
 require 'mustermann/ast/compiler'
-require 'ruby2_keywords'
 
 module Mustermann
   module AST
@@ -12,11 +11,11 @@ module Mustermann
     class Expander < Translator
       raises ExpandError
 
-      translate(Array, &-> (*args) do
+      translate Array do |*args, **options|
         inject(t.pattern) do |pattern, element|
-          t.add_to(pattern, t(element, *args))
+          t.add_to(pattern, t(element, *args, **options))
         end
-      end.ruby2_keywords)
+      end
 
       translate :capture do |**options|
         t.for_capture(node, **options)
@@ -123,7 +122,7 @@ module Mustermann
 
       # @see Mustermann::AST::Translator#expand
       # @!visibility private
-      ruby2_keywords def escape(string, *args)
+      def escape(string, *args, **options)
         return super unless string.respond_to?(:=~)
 
         # URI::Parser is pretty slow, let's not send every string to it, even if it's unnecessary

data/lib/mustermann/ast/parser.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require 'mustermann/ast/node'
 require 'forwardable'
-require 'ruby2_keywords'
 require 'strscan'
 
 module Mustermann
@@ -65,10 +64,10 @@ module Mustermann
       # @param [Symbol] type node type
       # @return [Mustermann::AST::Node]
       # @!visibility private
-      ruby2_keywords def node(type, *args, &block)
+      def node(type, *args, **options, &block)
         type  = Node[type] unless type.respond_to? :new
         start = pos
-        node  = block ? type.parse(*args, &block) : type.new(*args)
+        node  = block ? type.parse(*args, **options, &block) : type.new(*args, **options)
         min_size(start, pos, node)
       end
 

data/lib/mustermann/ast/translator.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require 'mustermann/ast/node'
 require 'mustermann/error'
-require 'ruby2_keywords'
 require 'delegate'
 
 module Mustermann
@@ -40,9 +39,9 @@ module Mustermann
 
         # shorthand for translating a nested object
         # @!visibility private
-        ruby2_keywords def t(*args, &block)
+        def t(*args, **options, &block)
           return translator unless args.any?
-          translator.translate(*args, &block)
+          translator.translate(*args, **options, &block)
         end
 
         # @!visibility private
@@ -113,8 +112,8 @@ module Mustermann
 
       # Start the translation dance for a (sub)tree.
       # @!visibility private
-      ruby2_keywords def translate(node, *args, &block)
-        result = decorator_for(node).translate(*args, &block)
+      def translate(node, *args, **options, &block)
+        result = decorator_for(node).translate(*args, **options, &block)
         result = result.node while result.is_a? NodeTranslator
         result
       end

data/lib/mustermann/expander.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+require 'mustermann'
 require 'mustermann/ast/expander'
 require 'mustermann/caster'
-require 'mustermann'
 
 module Mustermann
   # Allows fine-grained control over pattern expansion.

data/lib/mustermann/rails.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require 'mustermann'
+require 'mustermann/ast/pattern'
+require 'mustermann/versions'
+
+module Mustermann
+  # Rails style pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/:foo', type: :rails) === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#rails Syntax description in the README
+  class Rails < AST::Pattern
+    extend Versions
+    register :rails
+
+    # first parser, no optional parts
+    version('2.3') do
+      on(nil) { |c| unexpected(c) }
+      on(?*)  { |c| node(:named_splat) { scan(/\w+/) } }
+      on(?:)  { |c| node(:capture) { scan(/\w+/) } }
+    end
+
+    # rack-mount
+    version('3.0', '3.1') do
+      on(?))  { |c| unexpected(c) }
+      on(?()  { |c| node(:optional, node(:group) { read unless scan(?)) }) }
+      on(?\\) { |c| node(:char, expect(/./)) }
+    end
+
+    # stand-alone journey
+    version('3.2') do
+      on(?|)  { |c| raise ParseError, "the implementation of | is broken in ActionDispatch, cannot compile compatible pattern" }
+      on(?\\) { |c| node(:char, c) }
+    end
+
+    # embedded journey, broken (ignored) escapes
+    version('4.0', '4.1') { on(?\\) { |c| read } }
+
+    # escapes got fixed in 4.2
+    version('4.2') { on(?\\) { |c| node(:char, expect(/./)) } }
+
+    # Rails 5.0 fixes |
+    version('5.0') { on(?|) { |c| node(:or) }}
+  end
+end

data/lib/mustermann/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Mustermann
-  VERSION ||= '3.0.4'
+  VERSION ||= '3.1.0'
 end

data/lib/mustermann/versions.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module Mustermann
+  # Mixin that adds support for multiple versions of the same type.
+  # @see Mustermann::Rails
+  # @!visibility private
+  module Versions
+    # Checks if class has mulitple versions available and picks one that matches the version option.
+    # @!visibility private
+    def new(*args, version: nil, **options)
+      return super(*args, **options) unless versions.any?
+      self[version].new(*args, **options)
+    end
+
+    # @return [Hash] version to subclass mapping.
+    # @!visibility private
+    def versions
+      @versions ||= {}
+    end
+
+    # Defines a new version.
+    # @!visibility private
+    def version(*list, inherit_from: nil, &block)
+      superclass = self[inherit_from] || self
+      subclass   = Class.new(superclass, &block)
+      list.each { |v| versions[v] = subclass }
+    end
+
+    # Resolve a subclass for a given version string.
+    # @!visibility private
+    def [](version)
+      return versions.values.last unless version
+      detected = versions.detect { |v,_| version.start_with?(v) }
+      raise ArgumentError, 'unsupported version %p' % version unless detected
+      detected.last
+    end
+
+    # @!visibility private
+    def name
+      super || superclass.name
+    end
+
+    # @!visibility private
+    def inspect
+      name
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mustermann
 version: !ruby/object:Gem::Version
-  version: 3.0.4
+  version: 3.1.0
 platform: ruby
 authors:
 - Konstantin Haase
@@ -9,21 +9,7 @@ authors:
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: ruby2_keywords
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.0.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.0.1
+dependencies: []
 description: A library implementing patterns that behave like regular expressions.
 email: sinatrarb@googlegroups.com
 executables: []
@@ -32,11 +18,6 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
-- bench/capturing.rb
-- bench/regexp.rb
-- bench/simple_vs_sinatra.rb
-- bench/template_vs_addressable.rb
-- bench/uri_parser_object.rb
 - lib/mustermann.rb
 - lib/mustermann/ast/boundaries.rb
 - lib/mustermann/ast/compiler.rb
@@ -60,6 +41,7 @@ files:
 - lib/mustermann/mapper.rb
 - lib/mustermann/pattern.rb
 - lib/mustermann/pattern_cache.rb
+- lib/mustermann/rails.rb
 - lib/mustermann/regexp.rb
 - lib/mustermann/regexp_based.rb
 - lib/mustermann/regular.rb
@@ -70,21 +52,7 @@ files:
 - lib/mustermann/sinatra/try_convert.rb
 - lib/mustermann/to_pattern.rb
 - lib/mustermann/version.rb
-- mustermann.gemspec
-- spec/ast_spec.rb
-- spec/composite_spec.rb
-- spec/concat_spec.rb
-- spec/equality_map_spec.rb
-- spec/expander_spec.rb
-- spec/identity_spec.rb
-- spec/mapper_spec.rb
-- spec/mustermann_spec.rb
-- spec/pattern_spec.rb
-- spec/regexp_based_spec.rb
-- spec/regular_spec.rb
-- spec/simple_match_spec.rb
-- spec/sinatra_spec.rb
-- spec/to_pattern_spec.rb
+- lib/mustermann/versions.rb
 homepage: https://github.com/sinatra/mustermann
 licenses:
 - MIT
@@ -96,14 +64,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Your personal string matching expert.
 test_files: []

data/bench/capturing.rb

@@ -1,57 +0,0 @@
-$:.unshift File.expand_path('../lib', __dir__)
-
-require 'benchmark'
-require 'mustermann'
-require 'mustermann/regexp_based'
-require 'addressable/template'
-
-
-Mustermann.register(:regexp, Class.new(Mustermann::RegexpBased) {
-  def compile(**options)
-    Regexp.new(@string)
-  end
-}, load: false)
-
-Mustermann.register(:addressable, Class.new(Mustermann::RegexpBased) {
-  def compile(**options)
-    Addressable::Template.new(@string)
-  end
-}, load: false)
-
-list = [
-  [:sinatra,     '/*/:name'                                ],
-  [:rails,       '/*prefix/:name'                          ],
-  [:simple,      '/*/:name'                                ],
-  [:template,    '{/prefix*}/{name}'                       ],
-  [:regexp,      '\A\/(?<splat>.*?)\/(?<name>[^\/\?#]+)\Z' ],
-  [:addressable, '{/prefix*}/{name}'                       ]
-]
-
-def self.assert(value)
-  fail unless value
-end
-
-string = '/a/b/c/d'
-name   = 'd'
-
-GC.disable
-
-puts "Compilation:"
-Benchmark.bmbm do |x|
-  list.each do |type, pattern|
-    x.report(type) { 1_000.times { Mustermann.new(pattern, type: type) } }
-  end
-end
-
-puts "", "Matching with two captures (one splat, one normal):"
-Benchmark.bmbm do |x|
-  list.each do |type, pattern|
-    pattern = Mustermann.new(pattern, type: type)
-    x.report type do
-      10_000.times do
-        match = pattern.match(string)
-        assert match[:name] == name
-      end
-    end
-  end
-end

data/bench/regexp.rb

@@ -1,21 +0,0 @@
-require 'benchmark'
-
-puts " atomic vs normal segments ".center(52, '=')
-
-types = {
-  normal: /\A\/(?:a|%61)\/(?<b>[^\/\?#]+)(?:\/(?<c>[^\/\?#]+))?\Z/,
-  atomic: /\A\/(?:a|%61)\/(?<b>(?>[^\/\?#]+))(?:\/(?<c>(?>[^\/\?#]+)))?\Z/
-}
-
-Benchmark.bmbm do |x|
-  types.each do |name, regexp|
-    string = "/a/" << ?a * 10000 << "/" << ?a * 5000
-    fail unless regexp.match(string)
-    string << "/"
-    fail if regexp.match(string)
-
-    x.report name.to_s do
-      100.times { regexp.match(string) }
-    end
-  end
-end

data/bench/simple_vs_sinatra.rb

@@ -1,23 +0,0 @@
-$:.unshift File.expand_path('../lib', __dir__)
-
-require 'benchmark'
-require 'mustermann/simple'
-require 'mustermann/sinatra'
-
-[Mustermann::Simple, Mustermann::Sinatra].each do |klass|
-  puts "", " #{klass} ".center(64, '=')
-  Benchmark.bmbm do |x|
-    no_capture = klass.new("/simple")
-    x.report("no captures, match") { 1_000.times { no_capture.match('/simple') } }
-    x.report("no captures, miss") { 1_000.times { no_capture.match('/miss') } }
-
-    simple = klass.new("/:name")
-    x.report("simple, match") { 1_000.times { simple.match('/simple').captures } }
-    x.report("simple, miss") { 1_000.times { simple.match('/mi/ss') } }
-
-    splat = klass.new("/*")
-    x.report("splat, match") { 1_000.times { splat.match("/a/b/c").captures } }
-    x.report("splat, miss") { 1_000.times { splat.match("/a/b/c.miss") } }
-  end
-  puts
-end

data/bench/template_vs_addressable.rb

@@ -1,26 +0,0 @@
-$:.unshift File.expand_path('../lib', __dir__)
-
-require 'benchmark'
-require 'mustermann/template'
-require 'addressable/template'
-
-[Mustermann::Template, Addressable::Template].each do |klass|
-  puts "", " #{klass} ".center(64, '=')
-  Benchmark.bmbm do |x|
-    no_capture = klass.new("/simple")
-    x.report("no captures, match") { 1_000.times { no_capture.match('/simple') } }
-    x.report("no captures, miss") { 1_000.times { no_capture.match('/miss') } }
-
-    simple = klass.new("/{match}")
-    x.report("simple, match") { 1_000.times { simple.match('/simple').captures } }
-    x.report("simple, miss") { 1_000.times { simple.match('/mi/ss') } }
-
-    explode = klass.new("{/segments*}")
-    x.report("explode, match") { 1_000.times { explode.match("/a/b/c").captures } }
-    x.report("explode, miss") { 1_000.times { explode.match("/a/b/c.miss") } }
-
-    expand = klass.new("/prefix/{foo}/something/{bar}")
-    x.report("expand") { 100.times { expand.expand(foo: 'foo', bar: 'bar').to_s } }
-  end
-  puts
-end

data/bench/uri_parser_object.rb

@@ -1,16 +0,0 @@
-require "objspace"
-require "uri"
-require_relative "../lib/mustermann/ast/translator"
-
-translator = Mustermann::AST::Translator.new
-translator.escape("foo")
-
-h1 = ObjectSpace.each_object.inject(Hash.new 0) { |h, o| h[o.class] += 1; h }
-
-100.times do
-  translator.escape("foo")
-end
-
-h2 = ObjectSpace.each_object.inject(Hash.new 0) { |h, o| h[o.class] += 1; h }
-
-raise if (h2[URI::RFC2396_Parser] - h1[URI::RFC2396_Parser] != 0)

data/mustermann.gemspec

@@ -1,18 +0,0 @@
-$:.unshift File.expand_path("../lib", __FILE__)
-require "mustermann/version"
-
-Gem::Specification.new do |s|
-  s.name                  = "mustermann"
-  s.version               = Mustermann::VERSION
-  s.authors               = ["Konstantin Haase", "Zachary Scott"]
-  s.email                 = "sinatrarb@googlegroups.com"
-  s.homepage              = "https://github.com/sinatra/mustermann"
-  s.summary               = %q{Your personal string matching expert.}
-  s.description           = %q{A library implementing patterns that behave like regular expressions.}
-  s.license               = 'MIT'
-  s.required_ruby_version = '>= 2.6.0'
-  s.files                 = `git ls-files`.split("\n")
-  s.test_files            = `git ls-files -- {test,spec,features}/*`.split("\n")
-
-  s.add_runtime_dependency('ruby2_keywords', '~> 0.0.1')
-end

data/spec/ast_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'mustermann/ast/node'
-
-describe Mustermann::AST do
-  describe :type do
-    example { Mustermann::AST::Node[:char].type     .should be == :char }
-    example { Mustermann::AST::Node[:char].new.type .should be == :char }
-  end
-
-  describe :min_size do
-    example { Mustermann::AST::Node[:char].new.min_size.should be == 1 }
-    example { Mustermann::AST::Node[:node].new.min_size.should be == 0 }
-  end
-end

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