mustermann19 0.3.1 → 0.3.1.1

data/lib/mustermann/sinatra.rb

@@ -9,11 +9,25 @@ module Mustermann
   # @see Mustermann::Pattern
   # @see file:README.md#sinatra Syntax description in the README
   class Sinatra < AST::Pattern
-    on(nil, ??, ?)) { |c| unexpected(c) }
-    on(?*)          { |c| scan(/\w+/) ? node(:named_splat, buffer.matched) : node(:splat) }
-    on(?()          { |c| node(:group) { read unless scan(?)) } }
-    on(?:)          { |c| node(:capture) { scan(/\w+/) } }
-    on(?\\)         { |c| node(:char, expect(/./)) }
+    on(nil, ??, ?), ?|) { |c| unexpected(c) }
+
+    on(?*)  { |c| scan(/\w+/) ? node(:named_splat, buffer.matched) : node(:splat) }
+    on(?:)  { |c| node(:capture) { scan(/\w+/) } }
+    on(?\\) { |c| node(:char, expect(/./)) }
+
+    on ?( do |char|
+      groups = []
+      groups << node(:group) { read unless check(?)) or scan(?|) } until scan(?))
+      groups.size == 1 ? groups.first : node(:union, groups)
+    end
+
+    on ?{ do |char|
+      type = scan(?+) ? :named_splat : :capture
+      name = expect(/[\w\.]+/)
+      type = :splat if type == :named_splat and name == 'splat'
+      expect(?})
+      node(type, name)
+    end
 
     suffix ?? do |char, element|
       node(:optional, element)

data/lib/mustermann/string_scanner.rb

@@ -0,0 +1,314 @@
+require 'mustermann'
+require 'mustermann/pattern_cache'
+require 'delegate'
+
+module Mustermann
+  # Class inspired by Ruby's StringScanner to scan an input string using multiple patterns.
+  #
+  # @example
+  #   require 'mustermann/string_scanner'
+  #   scanner = Mustermann::StringScanner.new("here is our example string")
+  #
+  #   scanner.scan("here") # => "here"
+  #   scanner.getch        # => " "
+  #
+  #   if scanner.scan(":verb our")
+  #     scanner.scan(:noun, capture: :word)
+  #     scanner[:verb]  # => "is"
+  #     scanner[:nound] # => "example"
+  #   end
+  #
+  #   scanner.rest # => "string"
+  #
+  # @note
+  #   This structure is not thread-safe, you should not scan on the same StringScanner instance concurrently.
+  #   Even if it was thread-safe, scanning concurrently would probably lead to unwanted behaviour.
+  class StringScanner
+    # Exception raised if scan/unscan operation cannot be performed.
+    ScanError     = Class.new(::StringScanner::Error)
+    PATTERN_CACHE = PatternCache.new
+    #private_constant :PATTERN_CACHE
+
+    # Patterns created by {#scan} will be globally cached, since we assume that there is a finite number
+    # of different patterns used and that they are more likely to be reused than not.
+    # This method allows clearing the cache.
+    #
+    # @see Mustermann::PatternCache
+    def self.clear_cache
+      PATTERN_CACHE.clear
+    end
+
+    # @return [Integer] number of cached patterns
+    # @see clear_cache
+    # @api private
+    def self.cache_size
+      PATTERN_CACHE.size
+    end
+
+    # Encapsulates return values for {StringScanner#scan}, {StringScanner#check}, and friends.
+    # Behaves like a String (the substring which matched the pattern), but also exposes its position
+    # in the main string and any params parsed from it.
+    class ScanResult < DelegateClass(String)
+      # The scanner this result came from.
+      # @example
+      #   require 'mustermann/string_scanner'
+      #   scanner = Mustermann::StringScanner.new('foo/bar')
+      #   scanner.scan(:name).scanner == scanner # => true
+      attr_reader :scanner
+
+      # @example
+      #   require 'mustermann/string_scanner'
+      #   scanner = Mustermann::StringScanner.new('foo/bar')
+      #   scanner.scan(:name).position # => 0
+      #   scanner.getch.position       # => 3
+      #   scanner.scan(:name).position # => 4
+      #
+      # @return [Integer] position the substring starts at
+      attr_reader :position
+      alias_method :pos, :position
+
+      # @example
+      #   require 'mustermann/string_scanner'
+      #   scanner = Mustermann::StringScanner.new('foo/bar')
+      #   scanner.scan(:name).length # => 3
+      #   scanner.getch.length       # => 1
+      #   scanner.scan(:name).length # => 3
+      #
+      # @return [Integer] length of the substring
+      attr_reader :length
+
+      # Params parsed from the substring.
+      # Will not include params from previous scan results.
+      #
+      # @example
+      #   require 'mustermann/string_scanner'
+      #   scanner = Mustermann::StringScanner.new('foo/bar')
+      #   scanner.scan(:name).params # => { "name" => "foo" }
+      #   scanner.getch.params       # => {}
+      #   scanner.scan(:name).params # => { "name" => "bar" }
+      #
+      # @see Mustermann::StringScanner#params
+      # @see Mustermann::StringScanner#[]
+      #
+      # @return [Hash] params parsed from the substring
+      attr_reader :params
+
+      # @api private
+      def initialize(scanner, position, length, params = {})
+        @scanner, @position, @length, @params = scanner, position, length, params
+      end
+
+      # @api private
+      # @!visibility private
+      def __getobj__
+        @__getobj__ ||= scanner.to_s[position, length]
+      end
+    end
+
+    # @return [Hash] default pattern options used for {#scan} and similar methods
+    # @see #initialize
+    attr_reader :pattern_options
+
+    # Params from all previous matches from {#scan} and {#scan_until},
+    # but not from {#check} and {#check_until}. Changes can be reverted
+    # with {#unscan} and it can be completely cleared via {#reset}.
+    #
+    # @return [Hash] current params
+    attr_reader :params
+
+    # @return [Integer] current scan position on the input string
+    attr_accessor :position
+    alias_method :pos, :position
+    alias_method :pos=, :position=
+
+    # @example with different default type
+    #   require 'mustermann/string_scanner'
+    #   scanner = Mustermann::StringScanner.new("foo/bar/baz", type: :shell)
+    #   scanner.scan('*')     # => "foo"
+    #   scanner.scan('**/*')  # => "/bar/baz"
+    #
+    # @param [String] string the string to scan
+    # @param [Hash] pattern_options default options used for {#scan}
+    def initialize(string = "", pattern_options = {})
+      pattern_options, string = string, {} if string.kind_of?(Hash)
+      @pattern_options = pattern_options
+      @string          = String(string).dup
+      reset
+    end
+
+    # Resets the {#position} to the start and clears all {#params}.
+    # @return [Mustermann::StringScanner] the scanner itself
+    def reset
+      @position = 0
+      @params   = {}
+      @history  = []
+      self
+    end
+
+    # Moves the position to the end of the input string.
+    # @return [Mustermann::StringScanner] the scanner itself
+    def terminate
+      track_result ScanResult.new(self, @position, size - @position)
+      self
+    end
+
+    # Checks if the given pattern matches any substring starting at the current position.
+    #
+    # If it does, it will advance the current {#position} to the end of the substring and merges any params parsed
+    # from the substring into {#params}.
+    #
+    # @param (see Mustermann.new)
+    # @return [Mustermann::StringScanner::ScanResult, nil] the matched substring, nil if it didn't match
+    def scan(pattern, options = {})
+      track_result check(pattern, options)
+    end
+
+    # Checks if the given pattern matches any substring starting at any position after the current position.
+    #
+    # If it does, it will advance the current {#position} to the end of the substring and merges any params parsed
+    # from the substring into {#params}.
+    #
+    # @param (see Mustermann.new)
+    # @return [Mustermann::StringScanner::ScanResult, nil] the matched substring, nil if it didn't match
+    def scan_until(pattern, options = {})
+      result, prefix = check_until_with_prefix(pattern, options)
+      track_result(prefix, result)
+    end
+
+    # Reverts the last operation that advanced the position.
+    #
+    # Operations advancing the position: {#terminate}, {#scan}, {#scan_until}, {#getch}.
+    # @return [Mustermann::StringScanner] the scanner itself
+    def unscan
+      raise ScanError, 'unscan failed: previous match record not exist' if @history.empty?
+      previous = @history[0..-2]
+      reset
+      previous.each { |r| track_result(*r) }
+      self
+    end
+
+    # Checks if the given pattern matches any substring starting at the current position.
+    #
+    # Does not affect {#position} or {#params}.
+    #
+    # @param (see Mustermann.new)
+    # @return [Mustermann::StringScanner::ScanResult, nil] the matched substring, nil if it didn't match
+    def check(pattern, options = {})
+      params, length = create_pattern(pattern, options).peek_params(rest)
+      ScanResult.new(self, @position, length, params) if params
+    end
+
+    # Checks if the given pattern matches any substring starting at any position after the current position.
+    #
+    # Does not affect {#position} or {#params}.
+    #
+    # @param (see Mustermann.new)
+    # @return [Mustermann::StringScanner::ScanResult, nil] the matched substring, nil if it didn't match
+    def check_until(pattern, options = {})
+      check_until_with_prefix(pattern, options).first
+    end
+
+    def check_until_with_prefix(pattern, options = {})
+      start      = @position
+      @position += 1 until eos? or result = check(pattern, options)
+      prefix     = ScanResult.new(self, start, @position - start) if result
+      [result, prefix]
+    ensure
+      @position  = start
+    end
+
+    # Reads a single character and advances the {#position} by one.
+    # @return [Mustermann::StringScanner::ScanResult, nil] the character, nil if at end of string
+    def getch
+      track_result ScanResult.new(self, @position, 1) unless eos?
+    end
+
+    # Appends the given string to the string being scanned
+    #
+    # @example
+    #   require 'mustermann/string_scanner'
+    #   scanner = Mustermann::StringScanner.new
+    #   scanner << "foo"
+    #   scanner.scan(/.+/) # => "foo"
+    #
+    # @param [String] string will be appended
+    # @return [Mustermann::StringScanner] the scanner itself
+    def <<(string)
+      @string << string
+      self
+    end
+
+    # @return [true, false] whether or not the end of the string has been reached
+    def eos?
+      @position >= @string.size
+    end
+
+    # @return [true, false] whether or not the current position is at the start of a line
+    def beginning_of_line?
+      @position == 0 or @string[@position - 1] == "\n"
+    end
+
+    # @return [String] outstanding string not yet matched, empty string at end of input string
+    def rest
+      @string[@position..-1] || ""
+    end
+
+    # @return [Integer] number of character remaining to be scanned
+    def rest_size
+      @position > size ? 0 : size - @position
+    end
+
+    # Allows to peek at a number of still unscanned characters without advacing the {#position}.
+    #
+    # @param [Integer] length how many characters to look at
+    # @return [String] the substring
+    def peek(length = 1)
+      @string[@position, length]
+    end
+
+    # Shorthand for accessing {#params}. Accepts symbols as keys.
+    def [](key)
+      params[key.to_s]
+    end
+
+    # (see #params)
+    def to_h
+      params.dup
+    end
+
+    # @return [String] the input string
+    # @see #initialize
+    # @see #<<
+    def to_s
+      @string.dup
+    end
+
+    # @return [Integer] size of the input string
+    def size
+      @string.size
+    end
+
+    # @!visibility private
+    def inspect
+      "#<%p %d/%d @ %p>" % [ self.class, @position, @string.size, @string ]
+    end
+
+    # @!visibility private
+    def create_pattern(pattern, options = {})
+      PATTERN_CACHE.create_pattern(pattern, pattern_options.merge(options))
+    end
+
+    # @!visibility private
+    def track_result(*results)
+      results.compact!
+      @history << results if results.any?
+      results.each do |result|
+        @params.merge! result.params
+        @position += result.length
+      end
+      results.last
+    end
+
+    private :create_pattern, :track_result, :check_until_with_prefix
+  end
+end

data/lib/mustermann/template.rb

@@ -43,6 +43,16 @@ module Mustermann
       @split_params.include? key
     end
 
+    # Identity patterns support generating templates (the logic is quite complex, though).
+    #
+    # @example (see Mustermann::Pattern#to_templates)
+    # @param (see Mustermann::Pattern#to_templates)
+    # @return (see Mustermann::Pattern#to_templates)
+    # @see Mustermann::Pattern#to_templates
+    def to_templates
+      [to_s]
+    end
+
     private :compile, :map_param, :always_array?
   end
 end

data/lib/mustermann/to_pattern.rb

@@ -16,8 +16,11 @@ module Mustermann
   #
   #   Foo.new.to_pattern # => #<Mustermann::Sinatra:":foo/:bar">
   #
-  # By default included into {String}, {Symbol}, {Regexp} and {Mustermann::Pattern}.
+  # 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
@@ -30,16 +33,18 @@ module Mustermann
     #   /.*/.to_pattern # => #<Mustermann::Regular:".*">
     #
     # @example converting a pattern
-    #  Mustermann.new("foo").to_pattern # => #<Mustermann::Sinatra:"foo">
+    #   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 = {})
-      Mustermann.new(self, options)
+      input   = self if PRIMITIVES.any? { |p| self.is_a? p }
+      input ||= __getobj__ if respond_to?(:__getobj__)
+      Mustermann.new(input || to_s, options)
     end
 
-    append_features String
-    append_features Regexp
-    append_features Mustermann::Pattern
+    PRIMITIVES.each do |klass|
+      append_features(klass)
+    end
   end
 end

data/lib/mustermann/version.rb

@@ -1,3 +1,3 @@
 module Mustermann
-  VERSION ||= '0.3.1'
+  VERSION ||= '0.3.1.1'
 end

data/lib/mustermann.rb

@@ -1,22 +1,71 @@
 require 'mustermann/pattern'
+require 'mustermann/composite'
 
 # Namespace and main entry point for the Mustermann library.
 #
 # Under normal circumstances the only external API entry point you should be using is {Mustermann.new}.
 module Mustermann
-  # @param [String, Pattern, Regexp, #to_pattern] input The representation of the new pattern
+  # Creates a new pattern based on input.
+  #
+  # * From {Mustermann::Pattern}: returns given pattern.
+  # * From String: creates a pattern from the string, depending on type option (defaults to {Mustermann::Sinatra})
+  # * From Regexp: creates a {Mustermann::Regular} pattern.
+  # * From Symbol: creates a {Mustermann::Sinatra} pattern with a single named capture named after the input.
+  # * From an Array or multiple inputs: creates a new pattern from each element, combines them to a {Mustermann::Composite}.
+  # * From anything else: Will try to call to_pattern on it or raise a TypeError.
+  #
+  # Note that if the input is a {Mustermann::Pattern}, Regexp or Symbol, the type option is ignored and if to_pattern is
+  # called on the object, the type will be handed on but might be ignored by the input object.
+  #
+  # If you want to enforce the pattern type, you should create them via their expected class.
+  #
+  # @example creating patterns
+  #   require 'mustermann'
+  #
+  #   Mustermann.new("/:name")                    # => #<Mustermann::Sinatra:"/example">
+  #   Mustermann.new("/{name}", type: :template)  # => #<Mustermann::Template:"/{name}">
+  #   Mustermann.new(/.*/)                        # => #<Mustermann::Regular:".*">
+  #   Mustermann.new(:name, capture: :word)       # => #<Mustermann::Sinatra:":name">
+  #   Mustermann.new("/", "/*.jpg", type: :shell) # => #<Mustermann::Composite:(shell:"/" | shell:"/*.jpg")>
+  #
+  # @example using custom #to_pattern
+  #   require 'mustermann'
+  #
+  #   class MyObject
+  #     def to_pattern(**options)
+  #       Mustermann.new("/:name", **options)
+  #     end
+  #   end
+  #
+  #   Mustermann.new(MyObject.new, type: :rails) # => #<Mustermann::Rails:"/:name">
+  #
+  # @example enforcing type
+  #   require 'mustermann/sinatra'
+  #
+  #   Mustermann::Sinatra.new("/:name")
+  #
+  # @param [String, Pattern, Regexp, Symbol, #to_pattern, Array<String, Pattern, Regexp, Symbol, #to_pattern>]
+  #   input The representation of the pattern
   # @param [Hash] options The options hash
   # @return [Mustermann::Pattern] pattern corresponding to string.
   # @raise (see [])
   # @raise (see Mustermann::Pattern.new)
+  # @raise [TypeError] if the passed object cannot be converted to a pattern
   # @see file:README.md#Types_and_Options "Types and Options" in the README
-  def self.new(input, options = {})
+  def self.new(*input)
+    options = input.last.kind_of?(Hash) ? input.pop : {}
     type = options.delete(:type) || :sinatra
+    input = input.first if input.size < 2
     case input
     when Pattern then input
     when Regexp  then self[:regexp].new(input, options)
     when String  then self[type].new(input, options)
-    else input.to_pattern(options.merge(type: type))
+    when Array   then Composite.new(input, options.merge(:type => type))
+    when Symbol  then self[:sinatra].new(input.inspect, options)
+    else
+      pattern = input.to_pattern(options.merge(:type => type)) if input.respond_to? :to_pattern
+      raise TypeError, "#{input.class} can't be coerced into Mustermann::Pattern" if pattern.nil?
+      pattern
     end
   end
 

data/mustermann.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   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.extra_rdoc_files      = %w[README.md internals.md]
+  s.extra_rdoc_files      = %w[README.md]
   s.require_path          = 'lib'
   s.required_ruby_version = '>= 1.9.2'
 

data/spec/composite_spec.rb

@@ -0,0 +1,147 @@
+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
+  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
+  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(:rails)    { Mustermann.new('x', type: :rails)    }
+    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"))') }
+  end
+end

data/spec/expander_spec.rb

@@ -30,6 +30,21 @@ describe Mustermann::Expander do
     expander.expand(foo: 'pony', ext: nil).should be == '/pony'
   end
 
+  it 'supports splat' do
+    expander = Mustermann::Expander.new << Mustermann.new("/foo/*/baz")
+    expander.expand(splat: 'bar').should be == '/foo/bar/baz'
+  end
+
+  it 'supports multiple splats' do
+    expander = Mustermann::Expander.new << Mustermann.new("/foo/*/bar/*")
+    expander.expand(splat: [123, 456]).should be == '/foo/123/bar/456'
+  end
+
+  it 'supports identity patterns' do
+    expander = Mustermann::Expander.new('/:foo', type: :identity)
+    expander.expand.should be == '/:foo'
+  end
+
   describe :additional_values do
     context "illegal value" do
       example { expect { Mustermann::Expander.new(additional_values: :foo) }.to raise_error(ArgumentError) }