mustermann 0.2.0 → 0.3.0

data/lib/mustermann/ast/pattern.rb

@@ -2,10 +2,9 @@ require 'mustermann/ast/parser'
 require 'mustermann/ast/compiler'
 require 'mustermann/ast/transformer'
 require 'mustermann/ast/validation'
-
 require 'mustermann/regexp_based'
-require 'mustermann/equality_map'
 require 'mustermann/expander'
+require 'tool/equality_map'
 
 module Mustermann
   # @see Mustermann::AST::Pattern
@@ -62,7 +61,7 @@ module Mustermann
       # Internal AST representation of pattern.
       # @!visibility private
       def to_ast
-        @ast_cache ||= EqualityMap.new
+        @ast_cache ||= Tool::EqualityMap.new
         @ast_cache.fetch(@string) { validate(transform(parse(@string))) }
       end
 

data/lib/mustermann/expander.rb

@@ -93,7 +93,7 @@ module Mustermann
     #
     #   @param [Array<Symbol, Regexp, #===>] type_matchers
     #     To identify key/value pairs to match against.
-    #     Regexps and Symbols match againg key, everything else matches against value.
+    #     Regexps and Symbols match against key, everything else matches against value.
     #
     #   @yield every key/value pair
     #   @yieldparam key [Symbol] omitted if block takes less than 2
@@ -138,7 +138,8 @@ module Mustermann
     # @raise [NotImplementedError] raised if expand is not supported.
     # @raise [Mustermann::ExpandError] raised if a value is missing or unknown
     def expand(behavior = nil, **values)
-      values = caster.cast(values)
+      behavior, values = nil, behavior if behavior.is_a? Hash
+      values = map_values(values)
 
       case behavior || additional_values
       when :raise  then @api_expander.expand(values)
@@ -148,10 +149,38 @@ module Mustermann
       end
     end
 
+    # @see Object#==
+    def ==(other)
+      return false unless other.class == self.class
+      other.patterns == patterns and other.additional_values == additional_values
+    end
+
+    # @see Object#eql?
+    def eql?(other)
+      return false unless other.class == self.class
+      other.patterns.eql? patterns and other.additional_values.eql? additional_values
+    end
+
+    # @see Object#hash
+    def hash
+      patterns.hash + additional_values.hash
+    end
+
+    def expandable?(values)
+      return false unless values
+      expandable, _ = split_values(map_values(values))
+      @api_expander.expandable? expandable
+    end
+
     def with_rest(values)
+      expandable, non_expandable = split_values(values)
+      yield expand(:raise, slice(values, expandable)), slice(values, non_expandable)
+    end
+
+    def split_values(values)
       expandable     = @api_expander.expandable_keys(values.keys)
       non_expandable = values.keys - expandable
-      yield expand(:raise, slice(values, expandable)), slice(values, non_expandable)
+      [expandable, non_expandable]
     end
 
     def slice(hash, keys)
@@ -164,6 +193,12 @@ module Mustermann
       "#{ uri }#{ uri[??]??&:?? }#{ entries.join(?&) }"
     end
 
-    private :with_rest, :slice, :append, :caster
+    def map_values(values)
+      values = values.dup
+      @api_expander.keys.each { |key| values[key] ||= values.delete(key.to_s) if values.include? key.to_s }
+      caster.cast(values)
+    end
+
+    private :with_rest, :slice, :append, :caster, :map_values, :split_values
   end
 end

data/lib/mustermann/mapper.rb

@@ -0,0 +1,94 @@
+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)
+    #
+    #   @example map after options
+    #     require 'mustermann/mapper'
+    #     Mustermann::Mapper.new(type: :rails, "/:foo" => "/:foo.html")
+    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.rb

@@ -1,6 +1,6 @@
 require 'mustermann/error'
 require 'mustermann/simple_match'
-require 'mustermann/equality_map'
+require 'tool/equality_map'
 require 'uri'
 
 module Mustermann
@@ -42,7 +42,7 @@ module Mustermann
         raise ArgumentError, "unsupported option %p for %p" % [unsupported, self] if unsupported
       end
 
-      @map ||= EqualityMap.new
+      @map ||= Tool::EqualityMap.new
       @map.fetch(string, options) { super(string, options) }
     end
 
@@ -56,7 +56,7 @@ module Mustermann
     # @see Mustermann.new
     def initialize(string, uri_decode: true, **options)
       @uri_decode = uri_decode
-      @string     = string.dup
+      @string     = string.to_s.dup
     end
 
     # @return [String] the string representation of the pattern

data/lib/mustermann/regular.rb

@@ -0,0 +1,26 @@
+require 'mustermann/regexp_based'
+
+module Mustermann
+  # Regexp pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/.*', type: :regexp) === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#simple Syntax description in the README
+  class Regular < RegexpBased
+    # @param (see Mustermann::Pattern#initialize)
+    # @return (see Mustermann::Pattern#initialize)
+    # @see (see Mustermann::Pattern#initialize)
+    def initialize(string, **options)
+      string = $1 if string.to_s =~ /\A\(\?\-mix\:(.*)\)\Z/ && string.inspect == "/#$1/"
+      super(string, **options)
+    end
+
+    def compile(**options)
+      /\A#{@string}\Z/
+    end
+
+    private :compile
+  end
+end

data/lib/mustermann/router/rack.rb

@@ -5,7 +5,7 @@ module Mustermann
     # Simple pattern based router that allows matching paths to a given Rack application.
     #
     # @example config.ru
-    #    router = Mustermann::Rack do
+    #    router = Mustermann::Rack.new do
     #      on '/' do |env|
     #        [200, {'Content-Type' => 'text/plain'}, ['Hello World!']]
     #      end
@@ -23,7 +23,7 @@ module Mustermann
     class Rack < Simple
       def initialize(env_prefix: "mustermann", params_key: "#{env_prefix}.params", pattern_key: "#{env_prefix}.pattern", **options, &block)
         @params_key, @pattern_key = params_key, pattern_key
-        options[:default] ||= [404, {"Content-Type" => "text/plain", "X-Cascade" => "pass"}, ["Not Found"]]
+        options[:default] = [404, {"Content-Type" => "text/plain", "X-Cascade" => "pass"}, ["Not Found"]] unless options.include? :default
         super(**options, &block)
       end
 

data/lib/mustermann/router/simple.rb

@@ -118,7 +118,7 @@ module Mustermann
 
       # Finds the matching callback and calls `call` on it with the given input and the params.
       # @return the callback's return value
-      def call(input, &fallback)
+      def call(input)
         @map.each do |pattern, callback|
           catch(:pass) do
             next unless params = pattern.params(string_for(input))

data/lib/mustermann/sinatra.rb

@@ -10,7 +10,7 @@ module Mustermann
   # @see file:README.md#sinatra Syntax description in the README
   class Sinatra < AST::Pattern
     on(nil, ??, ?)) { |c| unexpected(c) }
-    on(?*)          { |c| node(:splat) }
+    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(/./)) }

data/lib/mustermann/to_pattern.rb

@@ -0,0 +1,45 @@
+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} and {Mustermann::Pattern}.
+  module ToPattern
+    # 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)
+      Mustermann.new(self, **options)
+    end
+
+    append_features String
+    append_features Regexp
+    append_features Mustermann::Pattern
+  end
+end

data/lib/mustermann/version.rb

@@ -1,3 +1,3 @@
 module Mustermann
-  VERSION ||= '0.2.0'
+  VERSION ||= '0.3.0'
 end

data/mustermann.gemspec

@@ -17,7 +17,9 @@ Gem::Specification.new do |s|
   s.require_path          = 'lib'
   s.required_ruby_version = '>= 2.0.0'
 
-  s.add_development_dependency 'rspec'
+  s.add_dependency 'tool', '~> 0.2'
+  s.add_development_dependency 'rspec' #, '~> 2.14'
+  s.add_development_dependency 'rspec-its'
   s.add_development_dependency 'addressable'
   s.add_development_dependency 'sinatra', '~> 1.4'
   s.add_development_dependency 'rack-test'

data/spec/expander_spec.rb

@@ -74,4 +74,32 @@ describe Mustermann::Expander do
       expander.expand(a: "fOo", b: "bAr").should be == "/FOO/bar"
     end
   end
+
+  describe :== do
+    example { Mustermann::Expander.new('/foo')               .should     be == Mustermann::Expander.new('/foo') }
+    example { Mustermann::Expander.new('/foo')               .should_not be == Mustermann::Expander.new('/bar') }
+    example { Mustermann::Expander.new('/foo', type: :rails) .should     be == Mustermann::Expander.new('/foo', type: :rails) }
+    example { Mustermann::Expander.new('/foo', type: :rails) .should_not be == Mustermann::Expander.new('/foo', type: :sinatra) }
+  end
+
+  describe :hash do
+    example { Mustermann::Expander.new('/foo')               .hash.should     be == Mustermann::Expander.new('/foo').hash }
+    example { Mustermann::Expander.new('/foo')               .hash.should_not be == Mustermann::Expander.new('/bar').hash }
+    example { Mustermann::Expander.new('/foo', type: :rails) .hash.should     be == Mustermann::Expander.new('/foo', type: :rails).hash }
+    example { Mustermann::Expander.new('/foo', type: :rails) .hash.should_not be == Mustermann::Expander.new('/foo', type: :sinatra).hash }
+  end
+
+  describe :eql? do
+    example { Mustermann::Expander.new('/foo')               .should     be_eql Mustermann::Expander.new('/foo') }
+    example { Mustermann::Expander.new('/foo')               .should_not be_eql Mustermann::Expander.new('/bar') }
+    example { Mustermann::Expander.new('/foo', type: :rails) .should     be_eql Mustermann::Expander.new('/foo', type: :rails) }
+    example { Mustermann::Expander.new('/foo', type: :rails) .should_not be_eql Mustermann::Expander.new('/foo', type: :sinatra) }
+  end
+
+  describe :equal? do
+    example { Mustermann::Expander.new('/foo')               .should_not be_equal Mustermann::Expander.new('/foo') }
+    example { Mustermann::Expander.new('/foo')               .should_not be_equal Mustermann::Expander.new('/bar') }
+    example { Mustermann::Expander.new('/foo', type: :rails) .should_not be_equal Mustermann::Expander.new('/foo', type: :rails) }
+    example { Mustermann::Expander.new('/foo', type: :rails) .should_not be_equal Mustermann::Expander.new('/foo', type: :sinatra) }
+  end
 end

data/spec/mapper_spec.rb

@@ -0,0 +1,83 @@
+require 'support'
+require 'mustermann/mapper'
+
+describe Mustermann::Mapper do
+  describe :initialize do
+    context 'accepts a block with no arguments, using the return value' do
+      subject(:mapper) { Mustermann::Mapper.new(additional_values: :raise) {{ "/foo" => "/bar" }}}
+      its(:to_h) { should be == { Mustermann.new("/foo") => Mustermann::Expander.new("/bar") } }
+      example { mapper['/foo'].should be == '/bar' }
+      example { mapper['/fox'].should be == '/fox' }
+    end
+
+    context 'accepts a block with argument, passes instance to it' do
+      subject(:mapper) { Mustermann::Mapper.new(additional_values: :raise) { |m| m["/foo"] = "/bar" }}
+      its(:to_h) { should be == { Mustermann.new("/foo") => Mustermann::Expander.new("/bar") } }
+      example { mapper['/foo'].should be == '/bar' }
+      example { mapper['/fox'].should be == '/fox' }
+    end
+
+    context 'accepts mappings followed by options' do
+      subject(:mapper) { Mustermann::Mapper.new("/foo" => "/bar", additional_values: :raise) }
+      its(:to_h) { should be == { Mustermann.new("/foo") => Mustermann::Expander.new("/bar") } }
+      example { mapper['/foo'].should be == '/bar' }
+      example { mapper['/fox'].should be == '/fox' }
+    end
+
+    context 'accepts options followed by mappings' do
+      subject(:mapper) { Mustermann::Mapper.new(additional_values: :raise, "/foo" => "/bar") }
+      its(:to_h) { should be == { Mustermann.new("/foo") => Mustermann::Expander.new("/bar") } }
+      example { mapper['/foo'].should be == '/bar' }
+      example { mapper['/fox'].should be == '/fox' }
+    end
+
+    context 'allows specifying type' do
+      subject(:mapper) { Mustermann::Mapper.new(additional_values: :raise, type: :rails, "/foo" => "/bar") }
+      its(:to_h) { should be == { Mustermann.new("/foo", type: :rails) => Mustermann::Expander.new("/bar", type: :rails) } }
+      example { mapper['/foo'].should be == '/bar' }
+      example { mapper['/fox'].should be == '/fox' }
+    end
+  end
+
+  describe :convert do
+    subject(:mapper) { Mustermann::Mapper.new }
+
+    context 'it maps params' do
+      before { mapper["/:a"] = "/:a.html" }
+      example { mapper["/foo"]      .should be == "/foo.html" }
+      example { mapper["/foo/bar"]  .should be == "/foo/bar"  }
+    end
+
+    context 'it supports named splats' do
+      before { mapper["/*a"] = "/*a.html" }
+      example { mapper["/foo"]      .should be == "/foo.html"     }
+      example { mapper["/foo/bar"]  .should be == "/foo/bar.html" }
+    end
+
+    context 'can map from patterns' do
+      before { mapper[Mustermann.new("/:a")] = "/:a.html" }
+      example { mapper["/foo"]      .should be == "/foo.html" }
+      example { mapper["/foo/bar"]  .should be == "/foo/bar"  }
+    end
+
+    context 'can map to patterns' do
+      before { mapper[Mustermann.new("/:a")] = Mustermann.new("/:a.html") }
+      example { mapper["/foo"]      .should be == "/foo.html" }
+      example { mapper["/foo/bar"]  .should be == "/foo/bar"  }
+    end
+
+    context 'can map to expanders' do
+      before { mapper[Mustermann.new("/:a")] = Mustermann::Expander.new("/:a.html") }
+      example { mapper["/foo"]      .should be == "/foo.html" }
+      example { mapper["/foo/bar"]  .should be == "/foo/bar"  }
+    end
+
+    context 'can map to array' do
+      before { mapper["/:a"] = ["/:a.html", "/:a.:f"] }
+      example { mapper["/foo"]             .should be == "/foo.html" }
+      example { mapper["/foo", "f" => 'x'] .should be == "/foo.x"    }
+      example { mapper["/foo", f: 'x']     .should be == "/foo.x"    }
+      example { mapper["/foo/bar"]         .should be == "/foo/bar"  }
+    end
+  end
+end