mustermann 0.0.1 → 0.1.0

data/lib/mustermann/regexp_based.rb

@@ -3,16 +3,16 @@ require 'forwardable'
 
 module Mustermann
   # Superclass for patterns that internally compile to a regular expression.
-  # @see Pattern
+  # @see Mustermann::Pattern
   # @abstract
   class RegexpBased < Pattern
     # @return [Regexp] regular expression equivalent to the pattern.
     attr_reader :regexp
     alias_method :to_regexp, :regexp
 
-    # @param (see Pattern#initialize)
-    # @return (see Pattern#initialize)
-    # @see (see Pattern#initialize)
+    # @param (see Mustermann::Pattern#initialize)
+    # @return (see Mustermann::Pattern#initialize)
+    # @see (see Mustermann::Pattern#initialize)
     def initialize(string, **options)
       @regexp = compile(string, **options)
       super

data/lib/mustermann/shell.rb

@@ -7,14 +7,14 @@ module Mustermann
   # @example
   #   Mustermann.new('/*.*', type: :shell) === '/bar' # => false
   #
-  # @see Pattern
+  # @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 Pattern#===)
-    # @return (see Pattern#===)
-    # @see (see Pattern#===)
+    # @param (see Mustermann::Pattern#===)
+    # @return (see Mustermann::Pattern#===)
+    # @see (see Mustermann::Pattern#===)
     def ===(string)
       File.fnmatch? @string, unescape(string), FLAGS
     end

data/lib/mustermann/simple.rb

@@ -6,7 +6,7 @@ module Mustermann
   # @example
   #   Mustermann.new('/:foo', type: :simple) === '/bar' # => true
   #
-  # @see Pattern
+  # @see Mustermann::Pattern
   # @see file:README.md#simple Syntax description in the README
   class Simple < RegexpBased
     supported_options :greedy, :space_matches_plus

data/lib/mustermann/simple_match.rb

@@ -12,12 +12,12 @@ module Mustermann
       @string.dup
     end
 
-    # @return [Array<String>] empty array for immitating MatchData interface
+    # @return [Array<String>] empty array for imitating MatchData interface
     def names
       []
     end
 
-    # @return [Array<String>] empty array for immitating MatchData interface
+    # @return [Array<String>] empty array for imitating MatchData interface
     def captures
       []
     end

data/lib/mustermann/sinatra.rb

@@ -1,4 +1,4 @@
-require 'mustermann/ast'
+require 'mustermann/ast/pattern'
 
 module Mustermann
   # Sinatra 2.0 style pattern implementation.
@@ -6,27 +6,17 @@ module Mustermann
   # @example
   #   Mustermann.new('/:foo') === '/bar' # => true
   #
-  # @see Pattern
+  # @see Mustermann::Pattern
   # @see file:README.md#sinatra Syntax description in the README
-  class Sinatra < AST
-    def parse_element(buffer)
-      case char = buffer.getch
-      when nil, ?? then unexpected(char)
-      when ?)      then unexpected(char, exception: UnexpectedClosingGroup)
-      when ?*      then Splat.new
-      when ?/      then Separator.new(char)
-      when ?(      then Group.parse { parse_buffer(buffer) }
-      when ?:      then Capture.parse { buffer.scan(/\w+/) }
-      when ?\\     then Char.new expect(buffer, /./)
-      else Char.new(char)
-      end
-    end
+  class Sinatra < AST::Pattern
+    on(nil, ??, ?)) { |c| unexpected(c) }
+    on(?*)          { |c| node(:splat) }
+    on(?()          { |c| node(:group) { read unless scan(?)) } }
+    on(?:)          { |c| node(:capture) { scan(/\w+/) } }
+    on(?\\)         { |c| node(:char, expect(/./)) }
 
-    def parse_suffix(element, buffer)
-      return element unless buffer.scan(/\?/)
-      Optional.new(element)
+    suffix ?? do |char, element|
+      node(:optional, element)
     end
-
-    private :parse_element, :parse_suffix
   end
 end

data/lib/mustermann/template.rb

@@ -1,4 +1,4 @@
-require 'mustermann/ast'
+require 'mustermann/ast/pattern'
 
 module Mustermann
   # URI template pattern implementation.
@@ -6,115 +6,22 @@ module Mustermann
   # @example
   #   Mustermann.new('/{foo}') === '/bar' # => true
   #
-  # @see Pattern
+  # @see Mustermann::Pattern
   # @see file:README.md#template Syntax description in the README
   # @see http://tools.ietf.org/html/rfc6570 RFC 6570
-  class Template < AST
-    Operator  ||= Struct.new(:separator, :allow_reserved, :prefix, :parametric)
-    OPERATORS ||= {
-      nil => Operator.new(?,, false, false, false), ?+  => Operator.new(?,, true,  false, false),
-      ?#  => Operator.new(?,, true,  ?#,    false), ?.  => Operator.new(?., false, ?.,    false),
-      ?/  => Operator.new(?/, false, ?/,    false), ?;  => Operator.new(?;, false, ?;,    true),
-      ??  => Operator.new(?&, false, ??,    true),  ?&  => Operator.new(?&, false, ?&,    true)
-    }
-
-    # AST node for template expressions.
-    # @!visibility private
-    class Expression < Group
-      # @!visibility private
-      attr_accessor :operator
-
-      # makes sure we have the proper surrounding characters for the operator
-      # @!visibility private
-      def transform
-        self.operator = OPERATORS.fetch(operator) { raise CompileError, "#{operator} operator not supported" }
-        new_payload   = payload.inject { |list, element| Array(list) << separator << element }
-        @payload      = Array(new_payload).map!(&:transform)
-        payload.unshift separator(operator.prefix) if operator.prefix
-        self
-      end
-
-      # @!visibility private
-      def compile(greedy: true, **options)
-        super(allow_reserved: operator.allow_reserved, greedy: greedy && !operator.allow_reserved,
-          parametric: operator.parametric, separator: operator.separator, **options)
-      end
-
-      # @!visibility private
-      def separator(char = operator.separator)
-        AST.const_get(:Separator).new(char) # uhm
-      end
-    end
-
-    # AST node for template variables.
-    # @!visibility private
-    class Variable < Capture
-      # @!visibility private
-      attr_accessor :prefix, :explode
-
-      # @!visibility private
-      def compile(**options)
-        return super(**options) if explode or not options[:parametric]
-        parametric super(parametric: false, **options)
-      end
-
-      # @!visibility private
-      def pattern(parametric: false, **options)
-        register_param(parametric: parametric, **options)
-        pattern = super(**options)
-        pattern = parametric(pattern) if parametric
-        pattern = "#{pattern}(?:#{Regexp.escape(options.fetch(:separator))}#{pattern})*" if explode
-        pattern
-      end
-
-      # @!visibility private
-      def parametric(string)
-        "#{Regexp.escape(name)}(?:=#{string})?"
+  class Template < AST::Pattern
+    on ?{ do |char|
+      variable = proc do
+        match  = expect(/(?<name>\w+)(?:\:(?<prefix>\d{1,4})|(?<explode>\*))?/)
+        node(:variable, match[:name], prefix: match[:prefix], explode: match[:explode])
       end
 
-      # @!visibility private
-      def qualified(string, **options)
-        prefix ? "#{string}{1,#{prefix}}" : super(string, **options)
-      end
-
-      # @!visibility private
-      def default(allow_reserved: false, **options)
-        allow_reserved ? '[\w\-\.~%\:/\?#\[\]@\!\$\&\'\(\)\*\+,;=]' : '[\w\-\.~%]'
-      end
-
-      # @!visibility private
-      def register_param(parametric: false, split_params: nil, separator: nil, **options)
-        return unless explode and split_params
-        split_params[name] = { separator: separator, parametric: parametric }
-      end
-    end
-
-    # @!visibility private
-    def parse_element(buffer)
-      parse_expression(buffer) || parse_literal(buffer)
-    end
-
-    # @!visibility private
-    def parse_expression(buffer)
-      return unless buffer.scan(/\{/)
       operator   = buffer.scan(/[\+\#\.\/;\?\&\=\,\!\@\|]/)
-      expression = Expression.new(parse_variable(buffer), operator: operator)
-      expression.parse { parse_variable(buffer) if buffer.scan(/,/) }
-      expression if expect(buffer, ?})
-    end
-
-    # @!visibility private
-    def parse_variable(buffer)
-      match = expect(buffer, /(?<name>\w+)(?:\:(?<prefix>\d{1,4})|(?<explode>\*))?/)
-      Variable.new(match[:name], prefix: match[:prefix], explode: match[:explode])
+      expression = node(:expression, [variable[]], operator: operator) { variable[] if scan(?,) }
+      expression if expect(?})
     end
 
-    # @!visibility private
-    def parse_literal(buffer)
-      return unless char = buffer.getch
-      raise unexpected(?}) if char == ?}
-      char == ?/ ? Separator.new('/') : Char.new(char)
-    end
+    on(?}) { |c| unexpected(c) }
 
     # @!visibility private
     def compile(*args, **options)
@@ -135,6 +42,6 @@ module Mustermann
       @split_params.include? key
     end
 
-    private :parse_element, :parse_expression, :parse_literal, :parse_variable, :map_param, :always_array?
+    private :compile, :map_param, :always_array?
   end
 end

data/lib/mustermann/version.rb

@@ -1,3 +1,3 @@
 module Mustermann
-  VERSION ||= '0.0.1'
+  VERSION ||= '0.1.0'
 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]
+  s.extra_rdoc_files      = %w[README.md internals.md]
   s.require_path          = 'lib'
   s.required_ruby_version = '>= 2.0.0'
 

data/spec/extension_spec.rb

@@ -44,6 +44,7 @@ describe Mustermann::Extension do
 
     context 'route local' do
       before do
+        app.set(:pattern, nil)
         app.get('/:id', capture: /\d+/) { 'ok' }
       end
 
@@ -84,6 +85,148 @@ describe Mustermann::Extension do
     end
   end
 
+  describe :pattern do
+    describe :except do
+      before { app.get('/auth/*', pattern: { except: '/auth/login' }) { 'ok' } }
+      example { get('/auth/dunno').should     be_ok }
+      example { get('/auth/login').should_not be_ok }
+    end
+
+    describe :capture do
+      context 'route local' do
+        before do
+          app.set(:pattern, nil)
+          app.get('/:id', pattern: { capture: /\d+/ }) { 'ok' }
+        end
+
+        example { get('/42').should be_ok }
+        example { get('/foo').should_not be_ok }
+      end
+
+      context 'global and route local' do
+        context 'global is a hash' do
+          before do
+            app.set(:pattern, capture: { id: /\d+/ })
+            app.get('/:id(.:ext)?', pattern: { capture: { ext: 'png' }}) { ?a }
+            app.get('/:id',         pattern: { capture: { id: 'foo'  }}) { ?b }
+            app.get('/:id',         pattern: { capture: :alpha })        { ?c }
+          end
+
+          example { get('/20')     .body.should be == ?a }
+          example { get('/20.png') .body.should be == ?a }
+          example { get('/foo')    .body.should be == ?b }
+          example { get('/bar')    .body.should be == ?c }
+        end
+
+        context 'global is not a hash' do
+          before do
+            app.set(:pattern, capture: /\d+/)
+            app.get('/:slug(.:ext)?', pattern: { capture: { ext: 'png' }}) { params[:slug] }
+            app.get('/:slug', pattern: { capture: :alpha }) { 'ok' }
+          end
+
+          example { get('/20.png').should be_ok }
+          example { get('/foo.png').should_not be_ok }
+          example { get('/foo').should be_ok }
+
+          example { get('/20.png') .body.should be == '20' }
+          example { get('/42')     .body.should be == '42' }
+          example { get('/foo')    .body.should be == 'ok' }
+        end
+      end
+    end
+
+    describe :greedy do
+      context 'default' do
+        before { app.get('/:name.:ext') { params[:name] }}
+        example { get('/foo.bar')     .body.should be == 'foo'     }
+        example { get('/foo.bar.baz') .body.should be == 'foo.bar' }
+      end
+
+      context 'enabled' do
+        before { app.get('/:name.:ext', pattern: { greedy: true }) { params[:name] }}
+        example { get('/foo.bar')     .body.should be == 'foo'     }
+        example { get('/foo.bar.baz') .body.should be == 'foo.bar' }
+      end
+
+      context 'disabled' do
+        before { app.get('/:name.:ext', pattern: { greedy: false }) { params[:name] }}
+        example { get('/foo.bar')     .body.should be == 'foo' }
+        example { get('/foo.bar.baz') .body.should be == 'foo' }
+      end
+
+      context 'global' do
+        before do
+          app.set(:pattern, greedy: false)
+          app.get('/:name.:ext') { params[:name] }
+        end
+
+        example { get('/foo.bar')     .body.should be == 'foo' }
+        example { get('/foo.bar.baz') .body.should be == 'foo' }
+      end
+    end
+
+    describe :space_matches_plus do
+      context 'default' do
+        before { app.get('/foo bar') { 'ok' }}
+        example { get('/foo%20bar') .should be_ok }
+        example { get('/foo+bar')   .should be_ok }
+      end
+
+      context 'enabled' do
+        before { app.get('/foo bar', pattern: { space_matches_plus: true }) { 'ok' }}
+        example { get('/foo%20bar') .should be_ok }
+        example { get('/foo+bar')   .should be_ok }
+      end
+
+      context 'disabled' do
+        before { app.get('/foo bar', pattern: { space_matches_plus: false }) { 'ok' }}
+        example { get('/foo%20bar') .should     be_ok }
+        example { get('/foo+bar')   .should_not be_ok }
+      end
+
+      context 'global' do
+        before do
+          app.set(:pattern, space_matches_plus: false)
+          app.get('/foo bar') { 'ok' }
+        end
+
+        example { get('/foo%20bar') .should     be_ok }
+        example { get('/foo+bar')   .should_not be_ok }
+      end
+    end
+
+    describe :uri_decode do
+      context 'default' do
+        before { app.get('/&') { 'ok' }}
+        example { get('/&')   .should be_ok }
+        example { get('/%26') .should be_ok }
+      end
+
+      context 'enabled' do
+        before { app.get('/&', pattern: { uri_decode: true }) { 'ok' }}
+        example { get('/&')   .should be_ok }
+        example { get('/%26') .should be_ok }
+      end
+
+      context 'disabled' do
+        before { app.get('/&', pattern: { uri_decode: false }) { 'ok' }}
+        example { get('/&')   .should     be_ok }
+        example { get('/%26') .should_not be_ok }
+      end
+
+      context 'global' do
+        before do
+          app.set(:pattern, uri_decode: false)
+          app.get('/&') { 'ok' }
+        end
+
+        example { get('/&')   .should     be_ok }
+        example { get('/%26') .should_not be_ok }
+      end
+    end
+  end
+
   describe :type do
     describe :identity do
       before do

data/spec/mustermann_spec.rb

@@ -0,0 +1,41 @@
+require 'support'
+require 'mustermann'
+require 'mustermann/extension'
+require 'sinatra/base'
+
+describe Mustermann do
+  describe :new do
+    example { Mustermann.new('')                  .should be_a(Mustermann::Sinatra)  }
+    example { Mustermann.new('', type: :identity) .should be_a(Mustermann::Identity) }
+    example { Mustermann.new('', type: :rails)    .should be_a(Mustermann::Rails)    }
+    example { Mustermann.new('', type: :shell)    .should be_a(Mustermann::Shell)    }
+    example { Mustermann.new('', type: :sinatra)  .should be_a(Mustermann::Sinatra)  }
+    example { Mustermann.new('', type: :simple)   .should be_a(Mustermann::Simple)   }
+    example { Mustermann.new('', type: :template) .should be_a(Mustermann::Template) }
+
+    example { expect { Mustermann.new('', foo:  :bar) }.to raise_error(ArgumentError, "unsupported option :foo for Mustermann::Sinatra") }
+    example { expect { Mustermann.new('', type: :ast) }.to raise_error(ArgumentError, "unsupported type :ast") }
+  end
+
+  describe :[] do
+    example { Mustermann[:identity] .should be == Mustermann::Identity }
+    example { Mustermann[:rails]    .should be == Mustermann::Rails    }
+    example { Mustermann[:shell]    .should be == Mustermann::Shell    }
+    example { Mustermann[:sinatra]  .should be == Mustermann::Sinatra  }
+    example { Mustermann[:simple]   .should be == Mustermann::Simple   }
+    example { Mustermann[:template] .should be == Mustermann::Template }
+
+    example { expect { Mustermann[:ast] }.to raise_error(ArgumentError, "unsupported type :ast") }
+  end
+
+  describe :extend_object do
+    context 'special behavior for Sinatra only' do
+      example { Object  .new.extend(Mustermann).should     be_a(Mustermann)            }
+      example { Object  .new.extend(Mustermann).should_not be_a(Mustermann::Extension) }
+      example { Class   .new.extend(Mustermann).should     be_a(Mustermann)            }
+      example { Class   .new.extend(Mustermann).should_not be_a(Mustermann::Extension) }
+      example { Sinatra .new.extend(Mustermann).should_not be_a(Mustermann)            }
+      example { Sinatra .new.extend(Mustermann).should     be_a(Mustermann::Extension) }
+    end
+  end
+end