mustermann 3.0.4 → 4.0.1

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

data/lib/mustermann.rb

@@ -113,21 +113,47 @@ module Mustermann
 
   # @!visibility private
   def self.normalized_type(type)
-    type.to_s.gsub('-', '_').downcase
+    @normalized_types       ||= {}
+    @normalized_types[type] ||= type.to_s.gsub('-', '_').downcase
   end
 
   # @!visibility private
-  def self.extend_object(object)
-    return super unless defined? ::Sinatra::Base and object.is_a? Class and object < ::Sinatra::Base
-    require 'mustermann/extension'
+  def self.dedup(object)
+    return object.freeze unless @dedup
+    # need to check this first because JRuby raises on @dedup.key?(nil)
+    case object
+    when nil, true, false, Integer, Float, Symbol, Module
+      return object
+    end
+
+    canonical = @dedup.getkey(object)
+    return canonical if canonical
+
+    # Build deduplicated copies so callers' arrays and hashes, which may be
+    # frozen or still in use, are never modified.
+    case object
+    when Array
+      object = object.map { |o| dedup(o) }
+      @dedup[object.freeze] = true
+    when Hash
+      object = object.to_h { |k, v| [dedup(k), dedup(v)] }
+      @dedup[object.freeze] = true
+    when String
+      @dedup[-object] = true
+    else
+      @dedup[object.freeze] = true
+    end
+    object
   end
-end
 
-# :nocov:
-begin
-  require 'mustermann/visualizer' if defined?(Pry) or defined?(IRB)
-rescue LoadError => error
-  raise error unless error.path == 'mustermann/visualizer'
-  $stderr.puts(error.message) if caller_locations[1].absolute_path =~ %r{/lib/pry/|/irb/|^\((?:irb|pry)\)$}
+  @dedup = defined?(ObjectSpace::WeakKeyMap) ? ObjectSpace::WeakKeyMap.new : false
+
+  # @!visibility private
+  EMPTY_STRING = dedup(-'')
+
+  # @!visibility private
+  EMPTY_ARRAY = dedup([])
+
+  # @!visibility private
+  EMPTY_HASH = dedup({})
 end
-# :nocov:

metadata

@@ -1,30 +1,24 @@
 --- !ruby/object:Gem::Specification
 name: mustermann
 version: !ruby/object:Gem::Version
-  version: 3.0.4
+  version: 4.0.1
 platform: ruby
 authors:
 - Konstantin Haase
+- Kunpei Sakai
+- Patrik Ragnarsson
+- Jordan Owens
 - Zachary Scott
 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
-description: A library implementing patterns that behave like regular expressions.
+dependencies: []
+description: |
+  Mustermann is your personal string matching expert. As an expert in the field of strings and patterns,
+  Mustermann keeps its runtime dependencies to a minimum and is fully covered with specs and documentation.
+
+  Given a string pattern, Mustermann will turn it into an object that behaves like a regular expression
+  and has comparable performance characteristics.
 email: sinatrarb@googlegroups.com
 executables: []
 extensions: []
@@ -32,15 +26,12 @@ 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
+- lib/mustermann/ast/converters.rb
 - lib/mustermann/ast/expander.rb
+- lib/mustermann/ast/fast_pattern.rb
 - lib/mustermann/ast/node.rb
 - lib/mustermann/ast/param_scanner.rb
 - lib/mustermann/ast/parser.rb
@@ -55,40 +46,35 @@ files:
 - lib/mustermann/equality_map.rb
 - lib/mustermann/error.rb
 - lib/mustermann/expander.rb
-- lib/mustermann/extension.rb
+- lib/mustermann/hybrid.rb
 - lib/mustermann/identity.rb
-- lib/mustermann/mapper.rb
+- lib/mustermann/match.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
-- lib/mustermann/simple_match.rb
+- lib/mustermann/router.rb
+- lib/mustermann/set.rb
+- lib/mustermann/set/cache.rb
+- lib/mustermann/set/linear.rb
+- lib/mustermann/set/match.rb
+- lib/mustermann/set/strict_order.rb
+- lib/mustermann/set/trie.rb
 - lib/mustermann/sinatra.rb
 - lib/mustermann/sinatra/parser.rb
 - lib/mustermann/sinatra/safe_renderer.rb
 - 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
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/sinatra/mustermann/issues
+  changelog_uri: https://github.com/sinatra/mustermann/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/sinatra/mustermann/tree/main/mustermann#readme
+  source_code_uri: https://github.com/sinatra/mustermann/tree/main/mustermann
 rdoc_options: []
 require_paths:
 - lib
@@ -96,14 +82,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.3.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.20
 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/lib/mustermann/extension.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-fail "Mustermann extension for Sinatra has been extracted into its own gem. More information at https://github.com/sinatra/mustermann-sinatra-extension"

data/lib/mustermann/mapper.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-require 'mustermann'
-require 'mustermann/expander'
-
-module Mustermann
-  # A mapper allows mapping one string to another based on pattern parsing and expanding.
-  #
-  # @example
-  #   require 'mustermann/mapper'
-  #   mapper = Mustermann::Mapper.new("/:foo" => "/:foo.html")
-  #   mapper['/example'] # => "/example.html"
-  class Mapper
-    # Creates a new mapper.
-    #
-    # @overload initialize(**options)
-    #   @param options [Hash] options The options hash
-    #   @yield block for generating mappings as a hash
-    #   @yieldreturn [Hash] see {#update}
-    #
-    #   @example
-    #     require 'mustermann/mapper'
-    #     Mustermann::Mapper.new(type: :rails) {{
-    #       "/:foo" => ["/:foo.html", "/:foo.:format"]
-    #     }}
-    #
-    # @overload initialize(**options)
-    #   @param  options [Hash] options The options hash
-    #   @yield block for generating mappings as a hash
-    #   @yieldparam mapper [Mustermann::Mapper] the mapper instance
-    #
-    #   @example
-    #     require 'mustermann/mapper'
-    #     Mustermann::Mapper.new(type: :rails) do |mapper|
-    #       mapper["/:foo"] = ["/:foo.html", "/:foo.:format"]
-    #     end
-    #
-    # @overload initialize(map = {}, **options)
-    #   @param map [Hash] see {#update}
-    #   @param [Hash] options The options hash
-    #
-    #   @example map before options
-    #     require 'mustermann/mapper'
-    #     Mustermann::Mapper.new({"/:foo" => "/:foo.html"}, type: :rails)
-    def initialize(map = {}, additional_values: :ignore, **options, &block)
-      @map               = []
-      @options           = options
-      @additional_values = additional_values
-      block.arity == 0 ? update(yield) : yield(self) if block
-      update(map) if map
-    end
-
-    # Add multiple mappings.
-    #
-    # @param map [Hash{String, Pattern: String, Pattern, Arry<String, Pattern>, Expander}] the mapping
-    def update(map)
-      map.to_h.each_pair do |input, output|
-        input  = Mustermann.new(input, **@options)
-        output = Expander.new(*output, additional_values: @additional_values, **@options) unless output.is_a? Expander
-        @map << [input, output]
-      end
-    end
-
-    # @return [Hash{Patttern: Expander}] Hash version of the mapper.
-    def to_h
-      Hash[@map]
-    end
-
-    # Convert a string according to mappings. You can pass in additional params.
-    #
-    # @example mapping with and without additional parameters
-    #   mapper = Mustermann::Mapper.new("/:example" => "(/:prefix)?/:example.html")
-    #
-    def convert(input, values = {})
-      @map.inject(input) do |current, (pattern, expander)|
-        params = pattern.params(current)
-        params &&= Hash[values.merge(params).map { |k,v| [k.to_s, v] }]
-        expander.expandable?(params) ? expander.expand(params) : current
-      end
-    end
-
-    # Add a single mapping.
-    #
-    # @param key [String, Pattern] format of the input string
-    # @param value [String, Pattern, Arry<String, Pattern>, Expander] format of the output string
-    def []=(key, value)
-      update key => value
-    end
-
-    alias_method :[], :convert
-  end
-end

data/lib/mustermann/pattern_cache.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-require 'set'
-require 'thread'
-require 'mustermann'
-
-module Mustermann
-  # A simple, persistent cache for creating repositories.
-  #
-  # @example
-  #   require 'mustermann/pattern_cache'
-  #   cache = Mustermann::PatternCache.new
-  #
-  #   # use this instead of Mustermann.new
-  #   pattern = cache.create_pattern("/:name", type: :rails)
-  #
-  # @note
-  #   {Mustermann::Pattern.new} (which is used by {Mustermann.new}) will reuse instances that have
-  #   not yet been garbage collected. You only need an extra cache if you do not keep a reference to
-  #   the patterns around.
-  #
-  # @api private
-  class PatternCache
-    # @param [Hash] pattern_options default options used for {#create_pattern}
-    def initialize(**pattern_options)
-      @cached          = Set.new
-      @mutex           = Mutex.new
-      @pattern_options = pattern_options
-    end
-
-    # @param (see Mustermann.new)
-    # @return (see Mustermann.new)
-    # @raise (see Mustermann.new)
-    # @see Mustermann.new
-    def create_pattern(string, **pattern_options)
-      pattern = Mustermann.new(string, **pattern_options, **@pattern_options)
-      @mutex.synchronize { @cached.add(pattern) } unless @cached.include? pattern
-      pattern
-    end
-
-    # Removes all pattern instances from the cache.
-    def clear
-      @mutex.synchronize { @cached.clear }
-    end
-
-    # @return [Integer] number of currently cached patterns
-    def size
-      @mutex.synchronize { @cached.size }
-    end
-  end
-end

data/lib/mustermann/simple_match.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-module Mustermann
-  # Fakes MatchData for patterns that do not support capturing.
-  # @see http://ruby-doc.org/core-2.0/MatchData.html MatchData
-  class SimpleMatch
-    # @api private
-    def initialize(string = "", names: [], captures: [])
-      @string   = string.dup
-      @names    = names
-      @captures = captures
-    end
-
-    # @return [String] the string that was matched against
-    def to_s
-      @string.dup
-    end
-
-    # @return [Array<String>] empty array for imitating MatchData interface
-    def names
-      @names.dup
-    end
-
-    # @return [Array<String>] empty array for imitating MatchData interface
-    def captures
-      @captures.dup
-    end
-
-    # @return [nil] imitates MatchData interface
-    def [](*args)
-      args.map! do |arg|
-        next arg unless arg.is_a? Symbol or arg.is_a? String
-        names.index(arg.to_s)
-      end
-      @captures[*args]
-    end
-
-    # @!visibility private
-    def +(other)
-      SimpleMatch.new(@string + other.to_s,
-          names:    @names    + other.names,
-          captures: @captures + other.captures)
-    end
-
-    # @return [String] string representation
-    def inspect
-      "#<%p %p>" % [self.class, @string]
-    end
-  end
-end

data/lib/mustermann/to_pattern.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-require 'mustermann'
-
-module Mustermann
-  # Mixin for adding {#to_pattern} ducktyping to objects.
-  #
-  # @example
-  #   require 'mustermann/to_pattern'
-  #
-  #   class Foo
-  #     include Mustermann::ToPattern
-  #
-  #     def to_s
-  #       ":foo/:bar"
-  #     end
-  #   end
-  #
-  #   Foo.new.to_pattern # => #<Mustermann::Sinatra:":foo/:bar">
-  #
-  # By default included into String, Symbol, Regexp, Array and {Mustermann::Pattern}.
-  module ToPattern
-    PRIMITIVES = [String, Symbol, Array, Regexp, Mustermann::Pattern]
-    private_constant :PRIMITIVES
-
-    # Converts the object into a {Mustermann::Pattern}.
-    #
-    # @example converting a string
-    #   ":name.png".to_pattern # => #<Mustermann::Sinatra:":name.png">
-    #
-    # @example converting a string with options
-    #   "/*path".to_pattern(type: :rails) # => #<Mustermann::Rails:"/*path">
-    #
-    # @example converting a regexp
-    #   /.*/.to_pattern # => #<Mustermann::Regular:".*">
-    #
-    # @example converting a pattern
-    #   Mustermann.new("foo").to_pattern # => #<Mustermann::Sinatra:"foo">
-    #
-    # @param [Hash] options The options hash.
-    # @return [Mustermann::Pattern] pattern corresponding to object.
-    def to_pattern(**options)
-      input   = self if PRIMITIVES.any? { |p| self.is_a? p }
-      input ||= __getobj__ if respond_to?(:__getobj__)
-      Mustermann.new(input || to_s, **options)
-    end
-
-    PRIMITIVES.each do |klass|
-      append_features(klass)
-    end
-  end
-end

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