mustermann 4.0.0 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1787d2b11e609844ac6a3085ca8943c1b94e9026b14f7efadded04f63f6d299
-  data.tar.gz: f8fb8748dbd82305d12b23cc4a227c210e3f748cd6e23fdb97b1126ea582c62d
+  metadata.gz: 4960bdf923e4b4a21deb051cfaa831122b3db56d38c09441ffd7a52ca650aa81
+  data.tar.gz: 545a7945333b4f25d0525612b50090e0f6562e66d7ff5c56043962f6e720c0b9
 SHA512:
-  metadata.gz: 5a429bddc03f3744c091f8b322c799f71276f35db5e190818ec57890012f52d4d3248c388b1db2997bd7d8c18bdb13fad58808e9961e1cd4accb832d8ddf9251
-  data.tar.gz: ac56fdcb2c30b07578ffa163af51a402190ec9ee75be89378347c2e9954caaadf942340ce15819f291bac4a1139d2e239fab4ff058df35c719777902f521620a
+  metadata.gz: a8900d2b779556e86bd35454418982580b22400229720ee84ada894bd29e6732ec59094214fea478ae00c670a4cb5127870ab8baefce7cf4d323e31961c89858
+  data.tar.gz: f86cf1e9a034c7c4ba117326c7c0b939c705c47a8b9ba1318e4f4b2247d51fcb5d47ee96a0be5f0953d6c1270375904e464503e32d15cf324896d0e1f8d9ba26

data/lib/mustermann/ast/compiler.rb

@@ -28,16 +28,19 @@ module Mustermann
       # Strip `atomic:` from incoming options so a parent's value cannot bleed
       # into siblings; each element's atomicity comes solely from its own context.
       translate(Array) do |atomic: false, **options|
-        greedy = options.fetch(:greedy, true)
-        each_with_index.map do |element, index|
-          next_sibling = self[index + 1]
+        greedy   = options.fetch(:greedy, true)
+        elements = node
+        result   = +''
+        elements.each_with_index do |element, index|
+          next_sibling = elements[index + 1]
           atomic = greedy &&
             element.is_a?(:capture) &&
             !element.is_a?(:splat) &&
             next_sibling&.is_a?(:separator) &&
             next_sibling.payload == '/'
-          t(element, **options, atomic: atomic)
-        end.join
+          result << t(element, **options, atomic: atomic)
+        end
+        result
       end
 
       translate(:node)      { |**o| t(payload, **o)             }
@@ -56,7 +59,7 @@ module Mustermann
 
       translate :with_look_ahead do |atomic: false, **options|
         greedy = options.fetch(:greedy, true)
-        lookahead = each_leaf.inject('') do |ahead, element|
+        lookahead = each_leaf.inject(EMPTY_STRING) do |ahead, element|
           ahead + t(element, skip_optional: true, lookahead: ahead, greedy: false, no_captures: true, **options).to_s
         end
         lookahead << (at_end ? '$' : '/')
@@ -227,9 +230,16 @@ module Mustermann
       def encoded(char, uri_decode: true, space_matches_plus: true, **options)
         return Regexp.escape(char) unless uri_decode
 
-        '(?:%s)' % self.class.char_representations(char, uri_decode:, space_matches_plus:).map { |c|
-          Regexp.escape(c)
-        }.join('|')
+        self.class.encoded_chars[[char, space_matches_plus]] ||= begin
+          representations = self.class.char_representations(char, uri_decode:, space_matches_plus:)
+          ('(?:%s)' % representations.map { |c| Regexp.escape(c) }.join('|')).freeze
+        end
+      end
+
+      # @return [Hash] regular expression source for each URI-encodable character
+      # @!visibility private
+      def self.encoded_chars
+        @encoded_chars ||= {}
       end
 
       # Compiles an AST to a regular expression.

data/lib/mustermann/ast/expander.rb

@@ -131,14 +131,14 @@ module Mustermann
 
       # Turns a sprintf pattern into our secret internal data structure.
       # @!visibility private
-      def pattern(string = "", *keys, **filters)
+      def pattern(string = EMPTY_STRING, *keys, **filters)
         [[keys, string, filters]]
       end
 
       # Creates the product of two of our secret internal data structures.
       # @!visibility private
       def add_to(list, result)
-        list << [[], ""] if list.empty?
+        list << [[], EMPTY_STRING] if list.empty?
         list.inject([]) { |l, (k1, p1, f1)| l + result.map { |k2, p2, f2| [k1+k2, p1+p2, f1.merge(f2)] } }
       end
     end

data/lib/mustermann/ast/fast_pattern.rb

@@ -14,13 +14,13 @@ module Mustermann
 
       # Regexp fragment for each printable ASCII char, matching the same output
       # as Compiler#encoded with uri_decode: true.
-      ENCODED = (0..127).each_with_object({}) do |byte, h|
+      ENCODED = Mustermann.dedup((0..127).each_with_object({}) do |byte, h|
         c   = byte.chr
         pct = '%%%02X' % byte
         reps = [c, pct, pct.downcase].uniq
         h[c] = reps.size == 1 ? Regexp.escape(reps.first) :
           '(?:%s)' % reps.map { |r| Regexp.escape(r) }.join('|')
-      end.freeze
+      end)
 
       SEGMENT_SCAN = %r{(/)|(:[a-zA-Z_]\w*)|([^/:]+)}
 
@@ -31,7 +31,7 @@ module Mustermann
       def to_ast
         return super unless simple_pattern?
         ast = self.class.ast_cache.fetch(@string) { build_fast_ast }
-        @param_converters ||= {}
+        @param_converters ||= EMPTY_HASH
         ast
       end
 

data/lib/mustermann/ast/param_scanner.rb

@@ -16,7 +16,7 @@ module Mustermann
       translate(:node)             { |o| t(payload, o) }
       translate(:with_look_ahead)  { |o| t(head, o).merge(t(payload, o)) }
       translate(Array)             { |o| map { |e| t(e, o) }.inject(:merge) }
-      translate(Object)            { |o| {} }
+      translate(Object)            { |o| EMPTY_HASH }
 
       class Capture < NodeTranslator
         register :capture
@@ -24,7 +24,7 @@ module Mustermann
         def translate(options)
           return { name => convert } if convert
           _, converter = converter(options[:capture])
-          converter ? { name => converter } : {}
+          converter ? { name => converter } : EMPTY_HASH
         end
 
         def converter(capture)

data/lib/mustermann/ast/pattern.rb

@@ -95,20 +95,21 @@ module Mustermann
       # @!visibility private
       def except_regexp
         return unless except_str = options[:except]
-        @except_regexp ||= Regexp.new("\\A#{compiler.new.translate(parse(except_str), no_captures: true, **options.except(:except))}\\z")
+        @except_regexp ||= begin
+          source = compiler.new.translate(parse(except_str), no_captures: true, **options.except(:except))
+          Mustermann.dedup(Regexp.new("\\A#{source}\\z"))
+        end
       end
 
       # Internal AST representation of pattern.
       # @!visibility private
       def to_ast
-        ast = self.class.ast_cache.fetch([@string, options]) do
+        self.class.ast_cache.fetch([@string, options]) do
           ast   = parse(@string, pattern: self)
           ast &&= transform(ast)
           ast &&= set_boundaries(ast, string: @string)
           validate(ast)
         end
-        @param_converters ||= scan_params(ast, options) if ast
-        ast
       end
 
       # All AST-based pattern implementations support expanding.
@@ -119,7 +120,7 @@ module Mustermann
       # @raise (see Mustermann::Pattern#expand)
       # @see Mustermann::Pattern#expand
       # @see Mustermann::Expander
-      def expand(behavior = nil, values = {})
+      def expand(behavior = nil, values = EMPTY_HASH)
         @expander ||= Mustermann::Expander.new(self)
         @expander.expand(behavior, values)
       end
@@ -131,7 +132,7 @@ module Mustermann
       # @return (see Mustermann::Pattern#to_templates)
       # @see Mustermann::Pattern#to_templates
       def to_templates
-        @to_templates ||= generate_templates(to_ast)
+        @to_templates ||= Mustermann.dedup(generate_templates(to_ast))
       end
 
       # @!visibility private
@@ -144,7 +145,7 @@ module Mustermann
 
       # @!visibility private
       def param_converters
-        @param_converters ||= scan_params(to_ast, options)
+        @param_converters ||= Mustermann.dedup(scan_params(to_ast, options))
       end
 
       # @api private

data/lib/mustermann/ast/template_generator.rb

@@ -13,10 +13,10 @@ module Mustermann
       end
 
       # translate(:expression) is not needed, since template patterns simply call to_s
-      translate(:root, :group)        { t(payload) || [""]            }
+      translate(:root, :group)        { t(payload) || [EMPTY_STRING]  }
       translate(:separator, :char)    { t.escape(payload)             }
       translate(:capture)             { "{#{name}}"                   }
-      translate(:optional)            { [t(payload), ""]              }
+      translate(:optional)            { [t(payload), EMPTY_STRING]    }
       translate(:named_splat, :splat) { "{+#{name}}"                  }
       translate(:with_look_ahead)     { t([head, payload])            }
       translate(:union)               { payload.flat_map { |e| t(e) } }

data/lib/mustermann/ast/translator.rb

@@ -38,11 +38,15 @@ module Mustermann
         attr_reader :translator
 
         # shorthand for translating a nested object
+        #
+        # Keywords pass through without being collected into a new hash, as
+        # this runs for every node of every pattern.
         # @!visibility private
-        def t(*args, **options, &block)
+        def t(*args, &block)
           return translator unless args.any?
-          translator.translate(*args, **options, &block)
+          translator.translate(*args, &block)
         end
+        ruby2_keywords :t
 
         # @!visibility private
         alias_method :node, :__getobj__
@@ -117,11 +121,12 @@ module Mustermann
 
       # Start the translation dance for a (sub)tree.
       # @!visibility private
-      def translate(node, *args, **options, &block)
-        result = decorator_for(node).translate(*args, **options, &block)
+      def translate(node, *args, &block)
+        result = decorator_for(node).translate(*args, &block)
         result = result.node while result.is_a? NodeTranslator
         result
       end
+      ruby2_keywords :translate
 
       # @return [String] escaped character
       # @!visibility private

data/lib/mustermann/ast/validation.rb

@@ -27,7 +27,7 @@ module Mustermann
 
       # @raise [Mustermann::CompileError] if name is not acceptable
       # @!visibility private
-      def check_name(name, forbidden: [])
+      def check_name(name, forbidden: EMPTY_ARRAY)
         raise CompileError, "capture name can't be empty" if name.nil? or name.empty?
         raise CompileError, "capture name must start with underscore or lower case letter" unless name =~ /^[a-z_]/
         raise CompileError, "capture name can't be #{name}" if Array(forbidden).include? name

data/lib/mustermann/composite.rb

@@ -31,7 +31,7 @@ module Mustermann
 
     # @see Mustermann::Pattern#names
     def names
-      @names ||= patterns.flat_map { |p| p.respond_to?(:names) ? p.names : [] }.uniq
+      @names ||= Mustermann.dedup(patterns.flat_map { |p| p.respond_to?(:names) ? p.names : EMPTY_ARRAY }.uniq)
     end
 
     # @see Mustermann::Pattern#==
@@ -71,7 +71,7 @@ module Mustermann
     end
 
     # (see Mustermann::Pattern#expand)
-    def expand(behavior = nil, values = {})
+    def expand(behavior = nil, values = EMPTY_HASH)
       raise NotImplementedError, 'expanding not supported' unless respond_to? :expand
       @expander ||= Mustermann::Expander.new(*patterns)
       @expander.expand(behavior, values)

data/lib/mustermann/concat.rb

@@ -107,7 +107,7 @@ module Mustermann
     # (see Mustermann::Pattern#to_templates)
     def to_templates
       raise NotImplementedError, 'template generation not supported' unless respond_to? :to_templates
-      @to_templates ||= patterns.inject(['']) { |list, pattern| list.product(pattern.to_templates).map(&:join) }.uniq
+      @to_templates ||= patterns.inject([EMPTY_STRING]) { |list, pattern| list.product(pattern.to_templates).map(&:join) }.uniq
     end
 
     # @!visibility private

data/lib/mustermann/expander.rb

@@ -27,7 +27,7 @@ module Mustermann
       @patterns          = []
       @api_expander      = AST::Expander.new
       @additional_values = additional_values
-      @options           = options
+      @options           = Mustermann.dedup(options)
       @caster            = Caster.new
       add(*patterns, &block)
     end
@@ -147,7 +147,7 @@ module Mustermann
     # @return [String] expanded string
     # @raise [NotImplementedError] raised if expand is not supported.
     # @raise [Mustermann::ExpandError] raised if a value is missing or unknown
-    def expand(behavior = nil, values = {})
+    def expand(behavior = nil, values = EMPTY_HASH)
       behavior, values = nil, behavior if behavior.is_a? Hash
       values = map_values(values)
 

data/lib/mustermann/identity.rb

@@ -65,7 +65,7 @@ module Mustermann
     # @raise (see Mustermann::Pattern#expand)
     # @see Mustermann::Pattern#expand
     # @see Mustermann::Expander
-    def expand(behavior = nil, values = {})
+    def expand(behavior = nil, values = EMPTY_HASH)
       return to_s if values.empty? or behavior == :ignore
       raise ExpandError,    "cannot expand with keys %p" % values.keys.sort if behavior == :raise
       raise ArgumentError,  "unknown behavior %p"        % behavior         if behavior != :append

data/lib/mustermann/match.rb

@@ -60,10 +60,10 @@ module Mustermann
       end
 
       @pattern        = pattern        || match&.pattern
-      @string         = string         || match&.string         || ''
-      @params         = params         || match&.params         || {}
-      @post_match     = post_match     || match&.post_match     || ''
-      @pre_match      = pre_match      || match&.pre_match      || ''
+      @string         = string         || match&.string         || EMPTY_STRING
+      @params         = params         || match&.params         || EMPTY_HASH
+      @post_match     = post_match     || match&.post_match     || EMPTY_STRING
+      @pre_match      = pre_match      || match&.pre_match      || EMPTY_STRING
       @captures       = captures       || match&.captures       || @params.values
       @named_captures = named_captures || match&.named_captures || @params
       @matched        = matched        || match&.to_s           || @string

data/lib/mustermann/pattern.rb

@@ -74,8 +74,8 @@ module Mustermann
     # @see Mustermann.new
     def initialize(string, uri_decode: true, **options)
       @uri_decode = uri_decode
-      @string     = string.to_s.dup
-      @options    = yield.freeze if block_given?
+      @string     = Mustermann.dedup(string)
+      @options    = Mustermann.dedup(yield) if block_given?
     end
 
     # @return [String] the string representation of the pattern
@@ -91,7 +91,7 @@ module Mustermann
     end
 
     # @return [Array<String>] list of named captures in the pattern
-    def names = []
+    def names = EMPTY_ARRAY
 
     # @param [String] string The string to match against
     # @return [Integer, nil] nil if pattern does not match the string, zero if it does.
@@ -168,7 +168,7 @@ module Mustermann
     # @see #peek_params
     def peek_match(string)
       matched = peek(string)
-      Match.new(self, string, matched:, params: {}, post_match: string[matched.size..-1]) if matched
+      Match.new(self, string, matched:, params: EMPTY_HASH, post_match: string[matched.size..-1]) if matched
     end
 
     # Tries to match the pattern against the beginning of the string (as opposed to the full string).
@@ -217,7 +217,7 @@ module Mustermann
     # @raise [NotImplementedError] raised if expand is not supported.
     # @raise [Mustermann::ExpandError] raised if a value is missing or unknown
     # @see Mustermann::Expander
-    def expand(behavior = nil, values = {})
+    def expand(behavior = nil, values = EMPTY_HASH)
       raise NotImplementedError, "expanding not supported by #{self.class}"
     end
 

data/lib/mustermann/regexp_based.rb

@@ -22,8 +22,8 @@ module Mustermann
 
       super
       regexp           = compile(**options)
-      @peek_regexp     = /\A#{regexp}/
-      @regexp          = /\A#{regexp}\Z/
+      @peek_regexp     = Mustermann.dedup(/\A#{regexp}/)
+      @regexp          = Mustermann.dedup(/\A#{regexp}\Z/)
       @simple_captures = @regexp.named_captures.none? { |name, positions| positions.size > 1 || always_array?(name) }
 
       cache_class = ObjectSpace::WeakKeyMap if defined?(ObjectSpace::WeakKeyMap)

data/lib/mustermann/regular.rb

@@ -21,7 +21,7 @@ module Mustermann
     # @see (see Mustermann::Pattern#initialize)
     def initialize(string, check_anchors: true, **options)
       string = $1 if string.to_s =~ /\A\(\?\-mix\:(.*)\)\Z/ && string.inspect == "/#$1/"
-      string = string.source.gsub!(/(?<!\\)(?:\s|#.*$)/, '') if extended_regexp?(string)
+      string = string.source.gsub!(/(?<!\\)(?:\s|#.*$)/, EMPTY_STRING) if extended_regexp?(string)
       @check_anchors = check_anchors
       super(string, **options)
     end

data/lib/mustermann/router.rb

@@ -92,7 +92,7 @@ module Mustermann
     # @param app [#call] The Rack application or middleware for which to generate the path.
     # @param (see Mustermann::Expander#expand)
     # @return [String] The generated path.
-    def path_for(app, behavior = nil, params = {})
+    def path_for(app, behavior = nil, params = EMPTY_HASH)
       set = @sets.values.find { |s| s.has_value?(app) } || @sets[VERBS.first]
       set.expand(app, behavior, params)
     end

data/lib/mustermann/set/cache.rb

@@ -5,7 +5,6 @@ module Mustermann
   class Set
     class Cache
       PLACEHOLDER = Object.new.freeze
-      EMPTY_ARRAY = [].freeze
 
       def self.new(matcher) = defined?(ObjectSpace::WeakKeyMap) ? super : matcher
 

data/lib/mustermann/set/trie.rb

@@ -12,8 +12,12 @@ module Mustermann
         translate(:root) do |trie, **options|
           leaves = t(payload, trie, **options)
           if leaves.is_a? Array
-            leaves.each { |leaf| leaf.patterns << t.pattern }
+            leaves.each do |leaf|
+              leaf.patterns ||= []
+              leaf.patterns << t.pattern
+            end
           else
+            leaves.patterns ||= []
             leaves.patterns << t.pattern
           end
           leaves
@@ -64,24 +68,28 @@ module Mustermann
         def compile(node, **options) = /\G#{@compiler.translate(node, **@options, **options)}/
       end
 
-      attr_reader :patterns, :set, :static, :dynamic
+      attr_accessor :patterns, :set, :static, :dynamic
 
-      def initialize(set, patterns = [])
+      def initialize(set, patterns = nil)
         @set             = set
-        @patterns        = []
-        @dynamic         = {}
-        @static          = {}
+        @patterns        = nil
+        @dynamic         = nil
+        @static          = nil
         @stride          = nil
         @fast_static     = nil
         @byte_lookup     = nil
         @dynamic_entries = nil
-        patterns.each { |pattern| add(pattern) }
+        patterns&.each { |pattern| add(pattern) }
       end
 
       def [](key)
-        case key
-        when String then @static[key] ||= Trie.new(@set)
-        when Regexp then @dynamic[key] ||= Trie.new(@set)
+        case key = Mustermann.dedup(key)
+        when String
+          @static      ||= {}
+          @static[key] ||= Trie.new(@set)
+        when Regexp
+          @dynamic      ||= {}
+          @dynamic[key] ||= Trie.new(@set)
         end
       end
 
@@ -107,8 +115,7 @@ module Mustermann
           end
         end
 
-        unless @dynamic_entries.empty?
-          anchored    = nil
+        if @dynamic_entries&.any?
           base_params = all ? params : nil
           @dynamic_entries.each do |matcher, node, capture_names, fast_name|
             if fast_name
@@ -127,8 +134,8 @@ module Mustermann
             # Non-greedy patterns (e.g. splat .*?) can match 0 chars on non-empty input, making
             # no progress. Retry with an end-of-string anchor so they consume the full remainder.
             if regexp_match && regexp_match.end(0) == position
-              anchored ||= {}
-              anchored_matcher = anchored[matcher] ||= Regexp.new(matcher.source + '\z')
+              @@anchored ||= {}
+              anchored_matcher = @@anchored[matcher] ||= Mustermann.dedup(Regexp.new(matcher.source + '\z'))
               regexp_match = anchored_matcher.match(string, position)
             end
             next unless regexp_match
@@ -148,7 +155,7 @@ module Mustermann
         end
 
         if peek
-          matches = build_matches(string, params, all:, matched_length: position, post_match: string[position..], pre_match: '')
+          matches = build_matches(string, params, all:, matched_length: position, post_match: string[position..], pre_match: EMPTY_STRING)
           return matches unless all
           result.concat(matches)
         end
@@ -158,11 +165,11 @@ module Mustermann
 
       NIL_VALUES = [nil].freeze
 
-      def build_matches(string, params, all: false, matched_length: string.size, post_match: '', pre_match: '')
+      def build_matches(string, params, all: false, matched_length: string.size, post_match: EMPTY_STRING, pre_match: EMPTY_STRING)
         result = [] if all
         matched = string[0, matched_length]
 
-        @patterns.each do |pattern|
+        @patterns&.each do |pattern|
           next if pattern.except_regexp&.match?(matched)
 
           pattern_params = build_pattern_params(pattern, params)
@@ -213,7 +220,7 @@ module Mustermann
           @byte_lookup = nil
           @stride      = depth
           @fast_static.each_value(&:optimize!)
-        elsif @static.empty?
+        elsif !@static&.any?
           @fast_static = nil
           @byte_lookup = nil
           @stride      = 1
@@ -221,12 +228,13 @@ module Mustermann
         else
           @fast_static = nil
           @byte_lookup = Array.new(256)
-          @static.each { |k, v| @byte_lookup[k.getbyte(0)] = v }
           @stride      = 1
-          @static.each_value(&:optimize!)
+          @static&.each { |k, v| @byte_lookup[k.getbyte(0)] = v }
+          @static&.each_value(&:optimize!)
         end
-        @dynamic.each_value(&:optimize!)
-        @dynamic_entries = @dynamic.map do |matcher, node|
+
+        @dynamic&.each_value(&:optimize!)
+        @dynamic_entries = @dynamic&.map do |matcher, node|
           names = matcher.names.each(&:freeze)
           # Detect unconstrained single-segment captures: can use fast string.index instead of regex.
           # Two conditions: (1) the edge is a bare capture (source starts with \G(?<name>), no leading
@@ -237,6 +245,10 @@ module Mustermann
           end
           [matcher, node, names, fast]
         end
+
+        @fast_static     = Mustermann.dedup(@fast_static)
+        @dynamic_entries = Mustermann.dedup(@dynamic_entries)
+        @byte_lookup     = Mustermann.dedup(@byte_lookup)
       end
 
       protected
@@ -245,9 +257,9 @@ module Mustermann
       # all possible paths, before encountering a dynamic edge, a terminal pattern,
       # or an empty node. Branching is allowed; only the minimum depth matters.
       def min_static_depth
-        return 0 if @dynamic.any?
-        return 0 if @patterns.any?
-        return 0 if @static.empty?
+        return 0 if @dynamic&.any?
+        return 0 if @patterns&.any?
+        return 0 if @static&.empty?
         1 + @static.values.map { |node| node.min_static_depth }.min
       end
 
@@ -256,7 +268,7 @@ module Mustermann
       # Builds a hash whose keys are +stride+-character strings and whose values are
       # the trie nodes reached after consuming exactly those characters.
       def build_stride_hash(stride)
-        stride.times.reduce({ "" => self }) do |frontier, _|
+        stride.times.reduce({ EMPTY_STRING => self }) do |frontier, _|
           frontier.each_with_object({}) do |(prefix, node), nxt|
             node.static.each { |char, child| nxt[prefix + char] = child }
           end

data/lib/mustermann/set.rb

@@ -104,6 +104,8 @@ module Mustermann
         end
       end
 
+      @options = Mustermann.dedup(@options)
+
       update(mapping)
 
       block.arity == 0 ? update(yield) : yield(self) if block
@@ -328,7 +330,7 @@ module Mustermann
     # @return [Mustermann::Expander]
     def expander(value = self)
       @expanders[value] ||= begin
-        patterns = value == self ? @mapping.keys : @reverse_mapping[value] || []
+        patterns = value == self ? @mapping.keys : @reverse_mapping[value] || EMPTY_ARRAY
         Mustermann::Expander.new(patterns, additional_values: @additional_values, **options)
       end
     end
@@ -373,7 +375,7 @@ module Mustermann
         values = value
         value  = self unless @reverse_mapping.key? values
       end
-      expander(value).expand(behavior || @additional_values, values || {})
+      expander(value).expand(behavior || @additional_values, values || EMPTY_HASH)
     end
 
     # @return [Boolean] whether the set contains any pattern associated with the given value

data/lib/mustermann/sinatra/try_convert.rb

@@ -23,7 +23,7 @@ module Mustermann
       attr_reader :type
 
       # @!visibility private
-      def initialize(type, names: [], **options)
+      def initialize(type, names: EMPTY_ARRAY, **options)
         @names   = names
         @options = options
         @type    = type

data/lib/mustermann/sinatra.rb

@@ -89,7 +89,7 @@ module Mustermann
     def normalize_capture(pattern)
       case capture = pattern.options[:capture]
       when Hash then capture.slice(*pattern.names.map(&:to_sym))
-      when nil  then {}
+      when nil  then EMPTY_HASH
       else pattern.names.to_h { |name| [name.to_sym, capture] }
       end
     end

data/lib/mustermann/version.rb

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

data/lib/mustermann.rb

@@ -113,6 +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.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
+
+  @dedup = defined?(ObjectSpace::WeakKeyMap) ? ObjectSpace::WeakKeyMap.new : false
+
+  # @!visibility private
+  EMPTY_STRING = dedup(-'')
+
+  # @!visibility private
+  EMPTY_ARRAY = dedup([])
+
+  # @!visibility private
+  EMPTY_HASH = dedup({})
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mustermann
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.0.1
 platform: ruby
 authors:
 - Konstantin Haase
@@ -89,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Your personal string matching expert.
 test_files: []