mustermann-simple 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ea32ffc659a85d4e2f1f0670e2f187b119f0ec0
+  data.tar.gz: c3079a0b6784c514512e7a6f9d71bd8c809ceb6e
+SHA512:
+  metadata.gz: cefc68dec41e61edaf025029c447a192f44d01d95abe405505dc8554a94823d95e722a39d54149b8c90978a21a83676afc37b6cdb35021e5821bf8e099eb613b
+  data.tar.gz: 12a7a8d205961cd6a41e74f0b5acf183cda02b0f59dd476d224c156e6e564d56eb5c4214ff9d9030526ca4f02c183cbe69c853a44bab63cce10343ff58483935

data/README.md

@@ -0,0 +1,76 @@
+# Simple Syntax for Mustermann
+
+This gem implements the `simple` pattern type for Mustermann. It is compatible with [Sinatra](http://www.sinatrarb.com/) (1.x), [Scalatra](http://www.scalatra.org/) and [Dancer](http://perldancer.org/).
+
+## Overview
+
+**Supported options:**
+`greedy`, `space_matches_plus`, `uri_decode` and `ignore_unknown_options`.
+
+This is useful for porting an application that relies on this behavior to a later Sinatra version and to make sure Sinatra 2.0 patterns do not decrease performance. Simple patterns internally use the same code older Sinatra versions used for compiling the pattern. Error messages for broken patterns will therefore not be as informative as for other pattern implementations.
+
+``` ruby
+require 'mustermann'
+
+pattern = Mustermann.new('/:example', type: :simple)
+pattern === "/foo.bar"     # => true
+pattern === "/foo/bar"     # => false
+pattern.params("/foo.bar") # => { "example" => "foo.bar" }
+pattern.params("/foo/bar") # => nil
+
+pattern = Mustermann.new('/:example/?:optional?', type: :simple)
+pattern === "/foo.bar"     # => true
+pattern === "/foo/bar"     # => true
+pattern.params("/foo.bar") # => { "example" => "foo.bar", "optional" => nil   }
+pattern.params("/foo/bar") # => { "example" => "foo",     "optional" => "bar" }
+
+pattern = Mustermann.new('/*', type: :simple)
+pattern === "/foo.bar"     # => true
+pattern === "/foo/bar"     # => true
+pattern.params("/foo.bar") # => { "splat" => ["foo.bar"] }
+pattern.params("/foo/bar") # => { "splat" => ["foo/bar"] }
+```
+
+## Syntax
+
+<table>
+  <thead>
+    <tr>
+      <th>Syntax Element</th>
+      <th>Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><b>:</b><i>name</i></td>
+      <td>
+        Captures anything but a forward slash in a greedy fashion. Capture is named <i>name</i>.
+      </td>
+    </tr>
+    <tr>
+      <td><b>*</b></td>
+      <td>
+        Captures anything in a non-greedy fashion. Capture is named splat.
+        It is always an array of captures, as you can use <tt>*</tt> more than once in a pattern.
+      </td>
+    </tr>
+    <tr>
+      <td><i>x</i><b>?</b></td>
+      <td>Makes <i>x</i> optional. For instance <tt>foo?</tt> matches <tt>foo</tt> or <tt>fo</tt>.</td>
+    </tr>
+    <tr>
+      <td><b>/</b></td>
+      <td>
+        Matches forward slash. Does not match URI encoded version of forward slash.
+      </td>
+    </tr>
+    <tr>
+      <td><i>any special character</i></td>
+      <td>Matches exactly that character or a URI encoded version of it.</td>
+    </tr>
+    <tr>
+      <td><i>any other character</i></td>
+      <td>Matches exactly that character.</td>
+    </tr>
+  </tbody>
+</table>

data/lib/mustermann/simple.rb

@@ -0,0 +1,50 @@
+require 'mustermann'
+require 'mustermann/regexp_based'
+
+module Mustermann
+  # Sinatra 1.3 style pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/:foo', type: :simple) === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#simple Syntax description in the README
+  class Simple < RegexpBased
+    register :simple
+    supported_options :greedy, :space_matches_plus
+    instance_delegate highlighter: 'self.class'
+
+    # @!visibility private
+    # @return [#highlight, nil]
+    #   highlighing logic for mustermann-visualizer,
+    #   nil if mustermann-visualizer hasn't been loaded
+    def self.highlighter
+      return unless defined? Mustermann::Visualizer::Highlighter
+      @highlighter ||= Mustermann::Visualizer::Highlighter.create do
+        on(/:(\w+)/) { |matched| element(:capture, ':') { element(:name, matched[1..-1]) } }
+        on("*" => :splat, "?" => :optional)
+      end
+    end
+
+    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
+      Regexp.new(pattern)
+    rescue SyntaxError, RegexpError => error
+      type = error.message["invalid group name"] ? CompileError : ParseError
+      raise type, error.message, error.backtrace
+    end
+
+    def encoded(char, uri_decode, space_matches_plus)
+      return Regexp.escape(char) unless uri_decode
+      parser  = URI::Parser.new
+      encoded = Regexp.union(parser.escape(char), parser.escape(char, /./).downcase, parser.escape(char, /./).upcase)
+      encoded = Regexp.union(encoded, encoded('+', true, true)) if space_matches_plus and char == " "
+      encoded
+    end
+
+    private :compile, :encoded
+  end
+end

data/mustermann-simple.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path("../../mustermann/lib", __FILE__)
+require "mustermann/version"
+
+Gem::Specification.new do |s|
+  s.name                  = "mustermann-simple"
+  s.version               = Mustermann::VERSION
+  s.author                = "Konstantin Haase"
+  s.email                 = "konstantin.mailinglists@googlemail.com"
+  s.homepage              = "https://github.com/rkh/mustermann"
+  s.summary               = %q{Simple syntax for Mustermann}
+  s.description           = %q{Adds Sinatra 1.x style patterns to Mustermman}
+  s.license               = 'MIT'
+  s.required_ruby_version = '>= 2.1.0'
+  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.add_dependency 'mustermann', Mustermann::VERSION
+end

data/spec/simple_spec.rb

@@ -0,0 +1,268 @@
+require 'support'
+require 'mustermann/simple'
+require 'mustermann/visualizer'
+
+describe Mustermann::Simple do
+  extend Support::Pattern
+
+  pattern '' do
+    it { should     match('')  }
+    it { should_not match('/') }
+
+    it { should_not respond_to(:expand)       }
+    it { should_not respond_to(:to_templates) }
+  end
+
+  pattern '/' do
+    it { should     match('/')    }
+    it { should_not match('/foo') }
+  end
+
+  pattern '/foo' do
+    it { should     match('/foo')     }
+    it { should_not match('/bar')     }
+    it { should_not match('/foo.bar') }
+  end
+
+  pattern '/foo/bar' do
+    it { should     match('/foo/bar')   }
+    it { should_not match('/foo%2Fbar') }
+    it { should_not match('/foo%2fbar') }
+  end
+
+  pattern '/:foo' do
+    it { should match('/foo')       .capturing foo: 'foo'       }
+    it { should match('/bar')       .capturing foo: 'bar'       }
+    it { should match('/foo.bar')   .capturing foo: 'foo.bar'   }
+    it { should match('/%0Afoo')    .capturing foo: '%0Afoo'    }
+    it { should match('/foo%2Fbar') .capturing foo: 'foo%2Fbar' }
+
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+  end
+
+  pattern '/föö' do
+    it { should match("/f%C3%B6%C3%B6") }
+  end
+
+  pattern "/:foo/:bar" do
+    it { should match('/foo/bar')               .capturing foo: 'foo',              bar: 'bar'     }
+    it { should match('/foo.bar/bar.foo')       .capturing foo: 'foo.bar',          bar: 'bar.foo' }
+    it { should match('/user@example.com/name') .capturing foo: 'user@example.com', bar: 'name'    }
+    it { should match('/10.1/te.st')            .capturing foo: '10.1',             bar: 'te.st'   }
+    it { should match('/10.1.2/te.st')          .capturing foo: '10.1.2',           bar: 'te.st'   }
+
+    it { should_not match('/foo%2Fbar') }
+    it { should_not match('/foo%2fbar') }
+
+    example { pattern.params('/bar/foo').should be == {"foo" => "bar", "bar" => "foo"} }
+    example { pattern.params('').should be_nil }
+  end
+
+  pattern '/hello/:person' do
+    it { should match('/hello/Frank').capturing person: 'Frank' }
+  end
+
+  pattern '/?:foo?/?:bar?' do
+    it { should match('/hello/world') .capturing foo: 'hello', bar: 'world' }
+    it { should match('/hello')       .capturing foo: 'hello', bar: nil     }
+    it { should match('/')            .capturing foo: nil,     bar: nil     }
+    it { should match('')             .capturing foo: nil,     bar: nil     }
+
+    it { should_not match('/hello/world/') }
+  end
+
+  pattern '/*' do
+    it { should match('/')        .capturing splat: '' }
+    it { should match('/foo')     .capturing splat: 'foo' }
+    it { should match('/foo/bar') .capturing splat: 'foo/bar' }
+
+    example { pattern.params('/foo').should be == {"splat" => ["foo"]} }
+  end
+
+  pattern '/:foo/*' do
+    it { should match("/foo/bar/baz")     .capturing foo: 'foo',   splat: 'bar/baz'   }
+    it { should match("/foo/")            .capturing foo: 'foo',   splat: ''          }
+    it { should match('/h%20w/h%20a%20y') .capturing foo: 'h%20w', splat: 'h%20a%20y' }
+    it { should_not match('/foo') }
+
+    example { pattern.params('/bar/foo').should be == {"splat" => ["foo"], "foo" => "bar"} }
+    example { pattern.params('/bar/foo/f%20o').should be == {"splat" => ["foo/f o"], "foo" => "bar"} }
+  end
+
+  pattern '/test$/' do
+    it { should match('/test$/') }
+  end
+
+  pattern '/te+st/' do
+    it { should     match('/te+st/') }
+    it { should_not match('/test/')  }
+    it { should_not match('/teest/') }
+  end
+
+  pattern "/path with spaces" do
+    it { should match('/path%20with%20spaces') }
+    it { should match('/path%2Bwith%2Bspaces') }
+    it { should match('/path+with+spaces')     }
+  end
+
+  pattern '/foo&bar' do
+    it { should match('/foo&bar') }
+  end
+
+  pattern '/*/:foo/*/*' do
+    it { should match('/bar/foo/bling/baz/boom') }
+
+    it "should capture all splat parts" do
+      match = pattern.match('/bar/foo/bling/baz/boom')
+      match.captures.should be == ['bar', 'foo', 'bling', 'baz/boom']
+      match.names.should be == ['splat', 'foo']
+    end
+
+    it 'should map to proper params' do
+      pattern.params('/bar/foo/bling/baz/boom').should be == {
+        "foo" => "foo", "splat" => ['bar', 'bling', 'baz/boom']
+      }
+    end
+  end
+
+  pattern '/test.bar' do
+    it { should     match('/test.bar') }
+    it { should_not match('/test0bar') }
+  end
+
+  pattern '/:file.:ext' do
+    it { should match('/pony.jpg')    .capturing file: 'pony', ext: 'jpg' }
+    it { should match('/pony%2Ejpg') .capturing file: 'pony', ext: 'jpg' }
+    it { should match('/pony%2ejpg') .capturing file: 'pony', ext: 'jpg' }
+
+    it { should match('/pony%E6%AD%A3%2Ejpg') .capturing file: 'pony%E6%AD%A3', ext: 'jpg' }
+    it { should match('/pony%e6%ad%a3%2ejpg') .capturing file: 'pony%e6%ad%a3', ext: 'jpg' }
+    it { should match('/pony正%2Ejpg')        .capturing file: 'pony正',         ext: 'jpg' }
+    it { should match('/pony正%2ejpg')        .capturing file: 'pony正',         ext: 'jpg' }
+    it { should match('/pony正..jpg')         .capturing file: 'pony正.',        ext: 'jpg' }
+
+    it { should_not match('/.jpg') }
+  end
+
+  pattern '/:id/test.bar' do
+    it { should match('/3/test.bar')   .capturing id: '3'   }
+    it { should match('/2/test.bar')   .capturing id: '2'   }
+    it { should match('/2E/test.bar')  .capturing id: '2E'  }
+    it { should match('/2e/test.bar')  .capturing id: '2e'  }
+    it { should match('/%2E/test.bar') .capturing id: '%2E' }
+  end
+
+  pattern '/10/:id' do
+    it { should match('/10/test')  .capturing id: 'test'  }
+    it { should match('/10/te.st') .capturing id: 'te.st' }
+  end
+
+  pattern '/10.1/:id' do
+    it { should match('/10.1/test')  .capturing id: 'test'  }
+    it { should match('/10.1/te.st') .capturing id: 'te.st' }
+  end
+
+  pattern '/foo?' do
+    it { should     match('/fo')   }
+    it { should     match('/foo')  }
+    it { should_not match('')      }
+    it { should_not match('/')     }
+    it { should_not match('/f')    }
+    it { should_not match('/fooo') }
+  end
+
+  pattern '/:fOO' do
+    it { should match('/a').capturing fOO: 'a' }
+  end
+
+  pattern '/:_X' do
+    it { should match('/a').capturing _X: 'a' }
+  end
+
+  pattern '/:f00' do
+    it { should match('/a').capturing f00: 'a' }
+  end
+
+  pattern '/:foo.?' do
+    it { should match('/a.').capturing foo: 'a.' }
+    it { should match('/xy').capturing foo: 'xy' }
+  end
+
+  pattern '/(a)' do
+    it { should     match('/(a)') }
+    it { should_not match('/a') }
+  end
+
+  pattern '/:foo.?', greedy: false do
+    it { should match('/a.').capturing foo: 'a'  }
+    it { should match('/xy').capturing foo: 'xy' }
+  end
+
+  pattern '/foo?', uri_decode: false do
+    it { should     match('/foo')  }
+    it { should     match('/fo')   }
+    it { should_not match('/foo?') }
+  end
+
+  pattern '/foo/bar', uri_decode: false do
+    it { should     match('/foo/bar')   }
+    it { should_not match('/foo%2Fbar') }
+    it { should_not match('/foo%2fbar') }
+  end
+
+  pattern "/path with spaces", uri_decode: false do
+    it { should     match('/path with spaces')     }
+    it { should_not match('/path%20with%20spaces') }
+    it { should_not match('/path%2Bwith%2Bspaces') }
+    it { should_not match('/path+with+spaces')     }
+  end
+
+  pattern "/path with spaces", space_matches_plus: false do
+    it { should     match('/path%20with%20spaces') }
+    it { should_not match('/path%2Bwith%2Bspaces') }
+    it { should_not match('/path+with+spaces')     }
+  end
+
+  context 'error handling' do
+    example '? at beginning of route' do
+      expect { Mustermann::Simple.new('?foobar') }.
+        to raise_error(Mustermann::ParseError)
+    end
+
+    example 'invalid capture name' do
+      expect { Mustermann::Simple.new('/:1a/') }.
+        to raise_error(Mustermann::CompileError)
+    end
+  end
+
+  context "peeking" do
+    subject(:pattern) { Mustermann::Simple.new(":name") }
+
+    describe :peek_size do
+      example { pattern.peek_size("foo bar/blah")   .should be == "foo bar".size }
+      example { pattern.peek_size("foo%20bar/blah") .should be == "foo%20bar".size }
+      example { pattern.peek_size("/foo bar")       .should be_nil }
+    end
+
+    describe :peek_match do
+      example { pattern.peek_match("foo bar/blah")   .to_s .should be == "foo bar" }
+      example { pattern.peek_match("foo%20bar/blah") .to_s .should be == "foo%20bar" }
+      example { pattern.peek_match("/foo bar")             .should be_nil }
+    end
+
+    describe :peek_params do
+      example { pattern.peek_params("foo bar/blah")   .should be == [{"name" => "foo bar"}, "foo bar".size] }
+      example { pattern.peek_params("foo%20bar/blah") .should be == [{"name" => "foo bar"}, "foo%20bar".size] }
+      example { pattern.peek_params("/foo bar")       .should be_nil }
+    end
+  end
+
+  context "highlighting" do
+    let(:pattern) { Mustermann::Simple.new("/:name?/*") }
+    subject(:sexp) { Mustermann::Visualizer.highlight(pattern).to_sexp }
+    it { should be == "(root (separator /) (capture : (name name)) (optional ?) (separator /) (splat *))" }
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: mustermann-simple
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Konstantin Haase
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mustermann
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+description: Adds Sinatra 1.x style patterns to Mustermman
+email: konstantin.mailinglists@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/mustermann/simple.rb
+- mustermann-simple.gemspec
+- spec/simple_spec.rb
+homepage: https://github.com/rkh/mustermann
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Simple syntax for Mustermann
+test_files:
+- spec/simple_spec.rb
+has_rdoc: