mustermann 0.1.0 → 0.2.0

data/lib/mustermann/pattern.rb

@@ -1,5 +1,6 @@
 require 'mustermann/error'
 require 'mustermann/simple_match'
+require 'mustermann/equality_map'
 require 'uri'
 
 module Mustermann
@@ -41,7 +42,8 @@ module Mustermann
         raise ArgumentError, "unsupported option %p for %p" % [unsupported, self] if unsupported
       end
 
-      super(string, options)
+      @map ||= EqualityMap.new
+      @map.fetch(string, options) { super(string, options) }
     end
 
     supported_options :uri_decode, :ignore_unknown_options
@@ -92,7 +94,7 @@ module Mustermann
       {}
     end
 
-    # @return [Hash{String}: Array<Integer>] capture names mapped to capture index.
+    # @return [Hash{String: Array<Integer>}] capture names mapped to capture index.
     # @see http://ruby-doc.org/core-2.0/Regexp.html#method-i-names Regexp#names
     def names
       []
@@ -125,10 +127,11 @@ module Mustermann
     #     warn "does not support expanding"
     #   end
     #
-    # @param [Hash{Symbol: #to_s, Array<#to_s>}] **values values to use for expansion
+    # @param [Hash{Symbol: #to_s, Array<#to_s>}] values values to use for expansion
     # @return [String] expanded string
     # @raise [NotImplementedError] raised if expand is not supported.
-    # @raise [ArgumentError] raised if a value is missing or unknown
+    # @raise [Mustermann::ExpandError] raised if a value is missing or unknown
+    # @see Mustermann::Expander
     def expand(**values)
       raise NotImplementedError, "expanding not supported by #{self.class}"
     end

data/lib/mustermann/regexp_based.rb

@@ -14,14 +14,14 @@ module Mustermann
     # @return (see Mustermann::Pattern#initialize)
     # @see (see Mustermann::Pattern#initialize)
     def initialize(string, **options)
-      @regexp = compile(string, **options)
       super
+      @regexp = compile(**options)
     end
 
     extend Forwardable
     def_delegators :regexp, :===, :=~, :match, :names, :named_captures
 
-    def compile(string, **options)
+    def compile(**options)
       raise NotImplementedError, 'subclass responsibility'
     end
 

data/lib/mustermann/router.rb

@@ -0,0 +1,9 @@
+require 'mustermann/router/simple'
+require 'mustermann/router/rack'
+
+module Mustermann
+  # @see Mustermann::Router::Simple
+  # @see Mustermann::Router::Rack
+  module Router
+  end
+end

data/lib/mustermann/router/rack.rb

@@ -0,0 +1,47 @@
+require 'mustermann/router/simple'
+
+module Mustermann
+  module Router
+    # Simple pattern based router that allows matching paths to a given Rack application.
+    #
+    # @example config.ru
+    #    router = Mustermann::Rack do
+    #      on '/' do |env|
+    #        [200, {'Content-Type' => 'text/plain'}, ['Hello World!']]
+    #      end
+    #
+    #      on '/:name' do |env|
+    #        name = env['mustermann.params']['name']
+    #        [200, {'Content-Type' => 'text/plain'}, ["Hello #{name}!"]]
+    #      end
+    #
+    #      on '/something/*', call: SomeApp
+    #    end
+    #
+    #    # in a config.ru
+    #    run router
+    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"]]
+        super(**options, &block)
+      end
+
+      def invoke(callback, env, params, pattern)
+        params_was, pattern_was             = env[@params_key], env[@pattern_key]
+        env[@params_key], env[@pattern_key] = params, pattern
+        response = callback.call(env)
+        response[1].each { |k,v| throw :pass if k.downcase == 'x-cascade' and v == 'pass' }
+        response
+      ensure
+        env[@params_key], env[@pattern_key] = params_was, pattern_was
+      end
+
+      def string_for(env)
+        env['PATH_INFO']
+      end
+
+      private :invoke, :string_for
+    end
+  end
+end

data/lib/mustermann/router/simple.rb

@@ -0,0 +1,142 @@
+require 'mustermann'
+
+module Mustermann
+  module Router
+    # Simple pattern based router that allows matching a string to a given callback.
+    #
+    # @example
+    #   require 'mustermann/router/simple'
+    #
+    #   router = Mustermann::Router::Simple.new do
+    #     on ':name/:sub' do |string, params|
+    #       params['sub']
+    #     end
+    #
+    #     on 'foo' do
+    #       "bar"
+    #     end
+    #   end
+    #
+    #   router.call("foo") # => "bar"
+    #   router.call("a/b") # => "b"
+    #   router.call("bar") # => nil
+    class Simple
+      # Default value for when no pattern matches
+      attr_accessor :default
+
+      # @example with a default value
+      #   require 'mustermann/router/simple'
+      #
+      #   router = Mustermann::Router::Simple.new(default: 42)
+      #   router.on(':name', capture: :digit) { |string| string.to_i }
+      #   router.call("23")      # => 23
+      #   router.call("example") # => 42
+      #
+      # @example block with implicit receiver
+      #   require 'mustermann/router/simple'
+      #
+      #   router = Mustermann::Router::Simple.new do
+      #     on('/foo') { 'foo' }
+      #     on('/bar') { 'bar' }
+      #   end
+      #
+      # @example block with explicit receiver
+      #   require 'mustermann/router/simple'
+      #
+      #   router = Mustermann::Router::Simple.new(type: :rails) do |r|
+      #     r.on('/foo') { 'foo' }
+      #     r.on('/bar') { 'bar' }
+      #   end
+      #
+      # @param default value to be returned if nothing matches
+      # @param options [Hash] pattern options
+      # @return [Mustermann::Router::Simple] new router instance
+      def initialize(default: nil, **options, &block)
+        @options = options
+        @map     = []
+        @default = default
+
+        block.arity == 0 ? instance_eval(&block) : yield(self) if block
+      end
+
+      # @example
+      #   require 'mustermann/router/simple'
+      #
+      #   router = Mustermann::Router::Simple.new
+      #   router.on(':a/:b') { 42 }
+      #   router['foo/bar'] # => <#Proc:...>
+      #   router['foo_bar'] # => nil
+      #
+      # @return [#call, nil] callback for given string, if a pattern matches
+      def [](string)
+        string = string_for(string) unless string.is_a? String
+        @map.detect { |p,v| p === string }[1]
+      end
+
+      # @example
+      #   require 'mustermann/router/simple'
+      #
+      #   router = Mustermann::Router::Simple.new
+      #   router['/:name'] = proc { |string, params| params['name'] }
+      #   router.call('/foo') # => "foo"
+      #
+      # @param pattern [String, Mustermann::Pattern] matcher
+      # @param callback [#call] callback to call on match
+      # @see #on
+      def []=(pattern, callback)
+        on(pattern, call: callback)
+      end
+
+      # @example with block
+      #   require 'mustermann/router/simple'
+      #
+      #   router = Mustermann::Router::Simple.new
+      #
+      #   router.on(':a/:b') { 42 }
+      #   router.call('foo/bar') # => 42
+      #   router.call('foo_bar') # => nil
+      #
+      # @example with callback option
+      #   require 'mustermann/router/simple'
+      #
+      #   callback = proc { 42 }
+      #   router   = Mustermann::Router::Simple.new
+      #
+      #   router.on(':a/:b', call: callback)
+      #   router.call('foo/bar') # => 42
+      #   router.call('foo_bar') # => nil
+      #
+      # @param patterns [Array<String, Pattern>]
+      # @param call [#call] callback object, need to hand in block if missing
+      # @param options [Hash] pattern options
+      def on(*patterns, call: Proc.new, **options)
+        patterns.each do |pattern|
+          pattern = Mustermann.new(pattern.to_str, **options, **@options) if pattern.respond_to? :to_str
+          @map << [pattern, call]
+        end
+      end
+
+      # 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)
+        @map.each do |pattern, callback|
+          catch(:pass) do
+            next unless params = pattern.params(string_for(input))
+            return invoke(callback, input, params, pattern)
+          end
+        end
+        @default
+      end
+
+      def invoke(callback, input, params, pattern)
+        callback.call(input, params)
+      end
+
+      def string_for(input)
+        input.to_str
+      end
+
+      private :invoke, :string_for
+    end
+  end
+end

data/lib/mustermann/shell.rb

@@ -10,13 +10,20 @@ module Mustermann
   # @see Mustermann::Pattern
   # @see file:README.md#shell Syntax description in the README
   class Shell < Pattern
-    FLAGS ||= File::FNM_PATHNAME | File::FNM_DOTMATCH | File::FNM_EXTGLOB
+    # @param (see Mustermann::Pattern#initialize)
+    # @return (see Mustermann::Pattern#initialize)
+    # @see (see Mustermann::Pattern#initialize)
+    def initialize(string, **options)
+      @flags = File::FNM_PATHNAME | File::FNM_DOTMATCH
+      @flags |= File::FNM_EXTGLOB if defined? File::FNM_EXTGLOB
+      super(string, **options)
+    end
 
     # @param (see Mustermann::Pattern#===)
     # @return (see Mustermann::Pattern#===)
     # @see (see Mustermann::Pattern#===)
     def ===(string)
-      File.fnmatch? @string, unescape(string), FLAGS
+      File.fnmatch? @string, unescape(string), @flags
     end
   end
 end

data/lib/mustermann/simple.rb

@@ -11,8 +11,8 @@ module Mustermann
   class Simple < RegexpBased
     supported_options :greedy, :space_matches_plus
 
-    def compile(string, greedy: true, uri_decode: true, space_matches_plus: true, **options)
-      pattern = string.gsub(/[^\?\%\\\/\:\*\w]/) { |c| encoded(c, uri_decode, space_matches_plus) }
+    def compile(greedy: true, uri_decode: true, space_matches_plus: true, **options)
+      pattern = @string.gsub(/[^\?\%\\\/\:\*\w]/) { |c| encoded(c, uri_decode, space_matches_plus) }
       pattern.gsub!(/((:\w+)|\*)/) do |match|
         match == "*" ? "(?<splat>.*?)" : "(?<#{$2[1..-1]}>[^/?#]+#{?? unless greedy})"
       end

data/lib/mustermann/version.rb

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

data/mustermann.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 2.0.0'
 
   s.add_development_dependency 'rspec'
+  s.add_development_dependency 'addressable'
   s.add_development_dependency 'sinatra', '~> 1.4'
   s.add_development_dependency 'rack-test'
   s.add_development_dependency 'rake'

data/spec/expander_spec.rb

@@ -0,0 +1,77 @@
+require 'support'
+require 'mustermann/expander'
+
+describe Mustermann::Expander do
+  it 'expands a pattern' do
+    expander = Mustermann::Expander.new("/:foo.jpg")
+    expander.expand(foo: 42).should be == "/42.jpg"
+  end
+
+  it 'expands multiple patterns' do
+    expander = Mustermann::Expander.new << "/:foo.:ext" << "/:foo"
+    expander.expand(foo: 42, ext: 'jpg').should be == "/42.jpg"
+    expander.expand(foo: 23).should be == "/23"
+  end
+
+  it 'supports setting pattern options' do
+    expander = Mustermann::Expander.new(type: :rails) << "/:foo(.:ext)" << "/:bar"
+    expander.expand(foo: 42, ext: 'jpg').should be == "/42.jpg"
+    expander.expand(foo: 42).should be == "/42"
+  end
+
+  it 'supports combining different pattern styles' do
+    expander = Mustermann::Expander.new << Mustermann.new("/:foo(.:ext)", type: :rails) << Mustermann.new("/:bar", type: :sinatra)
+    expander.expand(foo: 'pony', ext: 'jpg').should be == '/pony.jpg'
+    expander.expand(bar: 23).should be == "/23"
+  end
+
+  it 'ignores nil values' do
+    expander = Mustermann::Expander.new << Mustermann.new("/:foo(.:ext)?")
+    expander.expand(foo: 'pony', ext: nil).should be == '/pony'
+  end
+
+  describe :additional_values do
+    context "illegal value" do
+      example { expect { Mustermann::Expander.new(additional_values: :foo) }.to raise_error(ArgumentError) }
+      example { expect { Mustermann::Expander.new('/').expand(:foo, a: 10) }.to raise_error(ArgumentError) }
+    end
+
+    context :raise do
+      subject(:expander) { Mustermann::Expander.new('/:a', additional_values: :raise) }
+      example { expander.expand(a: ?a).should be == '/a' }
+      example { expect { expander.expand(a: ?a, b: ?b) }.to raise_error(Mustermann::ExpandError) }
+      example { expect { expander.expand(b: ?b) }.to raise_error(Mustermann::ExpandError) }
+    end
+
+    context :ignore do
+      subject(:expander) { Mustermann::Expander.new('/:a', additional_values: :ignore) }
+      example { expander.expand(a: ?a).should be == '/a' }
+      example { expander.expand(a: ?a, b: ?b).should be == '/a' }
+      example { expect { expander.expand(b: ?b) }.to raise_error(Mustermann::ExpandError) }
+    end
+
+    context :append do
+      subject(:expander) { Mustermann::Expander.new('/:a', additional_values: :append) }
+      example { expander.expand(a: ?a).should be == '/a' }
+      example { expander.expand(a: ?a, b: ?b).should be == '/a?b=b' }
+      example { expect { expander.expand(b: ?b) }.to raise_error(Mustermann::ExpandError) }
+    end
+  end
+
+  describe :cast do
+    subject(:expander) { Mustermann::Expander.new('/:a(/:b)?') }
+
+    example { expander.cast          { "FOOBAR"          }.expand(a: "foo")           .should be == "/FOOBAR"   }
+    example { expander.cast          { |v| v.upcase      }.expand(a: "foo")           .should be == "/FOO"      }
+    example { expander.cast          { |v| v.upcase      }.expand(a: "foo", b: "bar") .should be == "/FOO/BAR"  }
+    example { expander.cast(:a)      { |v| v.upcase      }.expand(a: "foo", b: "bar") .should be == "/FOO/bar"  }
+    example { expander.cast(:a, :b)  { |v| v.upcase      }.expand(a: "foo", b: "bar") .should be == "/FOO/BAR"  }
+    example { expander.cast(Integer) { |k,v| "#{k}_#{v}" }.expand(a: "foo", b: 42)    .should be == "/foo/b_42" }
+
+    example do
+      expander.cast(:a) { |v| v.upcase   }
+      expander.cast(:b) { |v| v.downcase }
+      expander.expand(a: "fOo", b: "bAr").should be == "/FOO/bar"
+    end
+  end
+end

data/spec/router/rack_spec.rb

@@ -0,0 +1,39 @@
+require 'mustermann/router/rack'
+
+describe Mustermann::Router::Rack do
+  include Rack::Test::Methods
+  subject(:app) { described_class.new }
+
+  context 'matching' do
+    before { app.on('/foo') { [418, {'Content-Type' => 'text/plain'}, 'bar'] } }
+    example { get('/foo').status.should be == 418 }
+    example { get('/bar').status.should be == 404 }
+  end
+
+  context "params" do
+    before { app.on('/:name') { |e| [200, {'Content-Type' => 'text/plain'}, e['mustermann.params']['name']] } }
+    example { get('/foo').body.should be == 'foo' }
+    example { get('/bar').body.should be == 'bar' }
+  end
+
+  context 'X-Cascade: pass' do
+    before do
+      app.on('/') { [200, { 'X-Cascade'    => 'pass'       }, ['a']] }
+      app.on('/') { [200, { 'x-cascade'    => 'pass'       }, ['b']] }
+      app.on('/') { [200, { 'Content-Type' => 'text/plain' }, ['c']] }
+      app.on('/') { [200, { 'Content-Type' => 'text/plain' }, ['d']] }
+    end
+
+    example { get('/').body.should be == 'c' }
+  end
+
+  context 'throw :pass' do
+    before do
+      app.on('/') { throw :pass }
+      app.on('/') { [200, { 'Content-Type' => 'text/plain' }, ['b']] }
+      app.on('/') { [200, { 'Content-Type' => 'text/plain' }, ['c']] }
+    end
+
+    example { get('/').body.should be == 'b' }
+  end
+end

data/spec/router/simple_spec.rb

@@ -0,0 +1,30 @@
+require 'mustermann/router/simple'
+
+describe Mustermann::Router::Simple do
+  describe :initialize do
+    context "with implicit receiver" do
+      subject(:router) { described_class.new { on('/foo') { 'bar' } } }
+      example { router.call('/foo').should be == 'bar' }
+    end
+
+    context "with explicit receiver" do
+      subject(:router) { described_class.new { |r| r.on('/foo') { 'bar' } } }
+      example { router.call('/foo').should be == 'bar' }
+    end
+
+    context "with default" do
+      subject(:router) { described_class.new(default: 'bar') }
+      example { router.call('/foo').should be == 'bar' }
+    end
+  end
+
+  describe :[]= do
+    before { subject['/:name'] = proc { |*a| a } }
+    example { subject.call('/foo').should be == ['/foo', "name" => 'foo'] }
+  end
+
+  describe :[] do
+    before { subject.on('/x') { 42 } }
+    example { subject['/x'].call.should be == 42 }
+  end
+end