mustermann 1.1.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7fdfa1980b36632e06c011f926b33f0d6d8812f72286004b2398a4f31dd9a82
-  data.tar.gz: 7daa22487d1a56e826fef04f5f63ecef1d67484151612304402e5a01c7f4be33
+  metadata.gz: ea330a8bf09165e676628df2668f0afa5d8fd32372bb7b07ed6a286cf274f74c
+  data.tar.gz: 58b0252ef3ba1d5bd06b3dceab50c06ba011d98b9e2bc54c6caa314443fa722b
 SHA512:
-  metadata.gz: 8d80afba1b13c99bcafc6862ad7dc195a0b8c0ac80279498fb9b8b75ecf6ea290cbe4b90f3f6f60d4e3c52f2f517f5a6059d05993c23179b6b2be22aaca320b8
-  data.tar.gz: f109d137a09eeb9781c92bfd366b1b421b118753b20ff905f1ab7d161946f254de2e376541c9e74215a7215f30ce0589992a0790d6e6861ae8d5c9606beda08a
+  metadata.gz: f9e8638a1cb73cf39256c6cb422d4d1a4601a2d9348aba8361d31083103e0495a843d595b579f08d2614ba1b665b41959a79eaffd869348551a2cb558c1cf1ea
+  data.tar.gz: 5b569063e6dd7d3beb3bdd983d4f5c30a9d12ce7b5e06d0f1f215e56004ba678011df824d26a94d5dc136d957c7835e5bcc38081cbbda2d838cfe78b3ca00ec7

data/README.md

@@ -377,30 +377,7 @@ mapper['/foo/bar'] # => "/foo/bar"
 <a name="-sinatra-integration"></a>
 ## Sinatra Integration
 
-All patterns implement `match`, which means they can be dropped into Sinatra and other Rack routers:
-
-``` ruby
-require 'sinatra'
-require 'mustermann'
-
-get Mustermann.new('/:foo') do
-  params[:foo]
-end
-```
-
-In fact, since using this with Sinatra is the main use case, it comes with a build-in extension for **Sinatra 1.x**.
-
-``` ruby
-require 'sinatra'
-require 'mustermann'
-
-register Mustermann
-
-# this will use Mustermann rather than the built-in pattern matching
-get '/:slug(.ext)?' do
-  params[:slug]
-end
-```
+Mustermann is used in Sinatra by default since version 2.0, for previous versions an [extension](https://github.com/sinatra/mustermann-sinatra-extension) is available.
 
 ### Configuration
 

data/lib/mustermann/ast/expander.rb

@@ -12,11 +12,11 @@ module Mustermann
     class Expander < Translator
       raises ExpandError
 
-      translate Array do |*args|
+      translate(Array, &-> (*args) do
         inject(t.pattern) do |pattern, element|
           t.add_to(pattern, t(element, *args))
         end
-      end
+      end.ruby2_keywords)
 
       translate :capture do |**options|
         t.for_capture(node, **options)
@@ -124,6 +124,8 @@ module Mustermann
       # @see Mustermann::AST::Translator#expand
       # @!visibility private
       ruby2_keywords def escape(string, *args)
+        return super unless string.respond_to?(:=~)
+
         # URI::Parser is pretty slow, let's not send every string to it, even if it's unnecessary
         string =~ /\A\w*\Z/ ? string : super
       end

data/lib/mustermann/ast/node.rb

@@ -35,8 +35,8 @@ module Mustermann
       # Helper for creating a new instance and calling #parse on it.
       # @return [Mustermann::AST::Node]
       # @!visibility private
-      def self.parse(*args, &block)
-        new(*args).tap { |n| n.parse(&block) }
+      def self.parse(payload = nil, **options, &block)
+        new(payload, **options).tap { |n| n.parse(&block) }
       end
 
       # @!visibility private
@@ -108,7 +108,7 @@ module Mustermann
         # @see Mustermann::AST::Node#parse
         # @!visibility private
         def parse
-          self.payload ||= ""
+          self.payload ||= String.new
           super
         end
 

data/lib/mustermann/ast/translator.rb

@@ -120,7 +120,7 @@ module Mustermann
       # @!visibility private
       def escape(char, parser: URI::DEFAULT_PARSER, escape: parser.regexp[:UNSAFE], also_escape: nil)
         escape = Regexp.union(also_escape, escape) if also_escape
-        char =~ escape ? parser.escape(char, Regexp.union(*escape)) : char
+        char.to_s =~ escape ? parser.escape(char, Regexp.union(*escape)) : char
       end
     end
   end

data/lib/mustermann/extension.rb

@@ -1,50 +1,3 @@
 # frozen_string_literal: true
-require 'sinatra/version'
-fail "no need to load the Mustermann extension for #{::Sinatra::VERSION}" if ::Sinatra::VERSION >= '2.0.0'
 
-require 'mustermann'
-
-module Mustermann
-  # Sinatra 1.x extension switching default pattern parsing over to Mustermann.
-  #
-  # @example With classic Sinatra application
-  #   require 'sinatra'
-  #   require 'mustermann'
-  #
-  #   register Mustermann
-  #   get('/:id', capture: /\d+/) { ... }
-  #
-  # @example With modular Sinatra application
-  #   require 'sinatra/base'
-  #   require 'mustermann'
-  #
-  #   class MyApp < Sinatra::Base
-  #     register Mustermann
-  #     get('/:id', capture: /\d+/) { ... }
-  #   end
-  #
-  # @see file:README.md#Sinatra_Integration "Sinatra Integration" in the README
-  module Extension
-    def compile!(verb, path, block, except: nil, capture: nil, pattern: { }, **options)
-      if path.respond_to? :to_str
-        pattern[:except]  = except  if except
-        pattern[:capture] = capture if capture
-
-        if settings.respond_to? :pattern and settings.pattern?
-          pattern.merge! settings.pattern do |key, local, global|
-            next local unless local.is_a? Hash
-            next global.merge(local) if global.is_a? Hash
-            Hash.new(global).merge! local
-          end
-        end
-
-        path = Mustermann.new(path, **pattern)
-        condition { params.merge! path.params(captures: Array(params[:captures]), offset: -1) }
-      end
-
-      super(verb, path, block, options)
-    end
-
-    private :compile!
-  end
-end
+fail "Mustermann extension for Sinatra has been extracted into its own gem. More information at https://github.com/sinatra/mustermann-sinatra-extension"

data/lib/mustermann/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Mustermann
-  VERSION ||= '1.1.1'
+  VERSION ||= '3.0.0'
 end

data/lib/mustermann.rb

@@ -75,8 +75,8 @@ module Mustermann
     end
   end
 
-  @mutex ||= Mutex.new
-  @types ||= {}
+  @mutex = Mutex.new
+  @types = {}
 
   # Maps a type to its factory.
   #
@@ -120,7 +120,6 @@ module Mustermann
   def self.extend_object(object)
     return super unless defined? ::Sinatra::Base and object.is_a? Class and object < ::Sinatra::Base
     require 'mustermann/extension'
-    object.register Extension
   end
 end
 

data/mustermann.gemspec

@@ -10,10 +10,9 @@ Gem::Specification.new do |s|
   s.summary               = %q{Your personal string matching expert.}
   s.description           = %q{A library implementing patterns that behave like regular expressions.}
   s.license               = 'MIT'
-  s.required_ruby_version = '>= 2.2.0'
+  s.required_ruby_version = '>= 2.6.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_runtime_dependency('ruby2_keywords', '~> 0.0.1')
 end

data/spec/mustermann_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require 'support'
 require 'mustermann'
-require 'mustermann/extension'
 require 'sinatra/base'
 
 describe Mustermann do
@@ -70,11 +69,9 @@ describe Mustermann do
   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) }
+
+      example { expect { Sinatra.new.extend(Mustermann) }.to raise_error(RuntimeError, "Mustermann extension for Sinatra has been extracted into its own gem. More information at https://github.com/sinatra/mustermann-sinatra-extension") }
     end
   end
 

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: mustermann
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Konstantin Haase
 - Zachary Scott
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-03 00:00:00.000000000 Z
+date: 2022-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby2_keywords
@@ -76,7 +76,6 @@ files:
 - spec/concat_spec.rb
 - spec/equality_map_spec.rb
 - spec/expander_spec.rb
-- spec/extension_spec.rb
 - spec/identity_spec.rb
 - spec/mapper_spec.rb
 - spec/mustermann_spec.rb
@@ -90,7 +89,7 @@ homepage: https://github.com/sinatra/mustermann
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -98,16 +97,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
-signing_key: 
+rubygems_version: 3.0.3.1
+signing_key:
 specification_version: 4
 summary: Your personal string matching expert.
 test_files:
@@ -116,7 +114,6 @@ test_files:
 - spec/concat_spec.rb
 - spec/equality_map_spec.rb
 - spec/expander_spec.rb
-- spec/extension_spec.rb
 - spec/identity_spec.rb
 - spec/mapper_spec.rb
 - spec/mustermann_spec.rb

data/spec/extension_spec.rb

@@ -1,297 +0,0 @@
-# frozen_string_literal: true
-require 'support'
-require 'mustermann/extension'
-require 'sinatra/base'
-require 'rack/test'
-
-describe Mustermann::Extension do
-  include Rack::Test::Methods
-
-  subject :app do
-    Sinatra.new do
-      set :environment, :test
-      register Mustermann
-    end
-  end
-
-  it 'sets up the extension' do
-    app.should be_a(Mustermann::Extension)
-  end
-
-  context 'uses Sinatra-style patterns by default' do
-    before { app.get('/:slug(.:extension)?') { params[:slug] } }
-    example { get('/foo')     .body.should be == 'foo'  }
-    example { get('/foo.')    .body.should be == 'foo.' }
-    example { get('/foo.bar') .body.should be == 'foo'  }
-    example { get('/a%20b')   .body.should be == 'a b'  }
-  end
-
-  describe :except do
-    before { app.get('/auth/*', except: '/auth/login') { 'ok' } }
-    example { get('/auth/dunno').should     be_ok }
-    example { get('/auth/login').should_not be_ok }
-  end
-
-  describe :capture do
-    context 'global' do
-      before do
-        app.set(:pattern, capture: { ext: %w[png jpg gif] })
-        app.get('/:slug(.:ext)?') { params[:slug] }
-      end
-
-      example { get('/foo.bar').body.should be == 'foo.bar' }
-      example { get('/foo.png').body.should be == 'foo'     }
-    end
-
-    context 'route local' do
-      before do
-        app.set(:pattern, nil)
-        app.get('/:id', 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)?', capture: { ext: 'png' }) { ?a }
-          app.get('/:id',         capture: { id: 'foo'  }) { ?b }
-          app.get('/:id',         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)?', capture: { ext: 'png' }) { params[:slug] }
-          app.get('/:slug', 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 :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
-        app.set(:pattern, type: :identity)
-        app.get('/:foo') { 'ok' }
-      end
-
-      example { get('/:foo').should be_ok }
-      example { get('/foo').should_not be_ok }
-    end
-
-    describe :rails do
-      before do
-        app.set(:pattern, type: :rails)
-        app.get('/:slug(.:extension)') { params[:slug] }
-      end
-
-      example { get('/foo')     .body.should be == 'foo'  }
-      example { get('/foo.')    .body.should be == 'foo.' }
-      example { get('/foo.bar') .body.should be == 'foo'  }
-      example { get('/a%20b')   .body.should be == 'a b'  }
-    end
-
-    describe :shell do
-      before do
-        app.set(:pattern, type: :shell)
-        app.get('/{foo,bar}') { 'ok' }
-      end
-
-      example { get('/foo').should be_ok }
-      example { get('/bar').should be_ok }
-    end
-
-    describe :simple do
-      before do
-        app.set(:pattern, type: :simple)
-        app.get('/(a)') { 'ok' }
-      end
-
-      example { get('/(a)').should be_ok }
-      example { get('/a').should_not be_ok }
-    end
-
-    describe :simple do
-      before do
-        app.set(:pattern, type: :template)
-        app.get('/foo{/segments*}{.ext}') { "%p %p" % [params[:segments], params[:ext]] }
-      end
-
-      example { get('/foo/a.png').should be_ok }
-      example { get('/foo/a').should_not be_ok }
-
-      example { get('/foo/a.png').body.should be == '["a"] "png"' }
-      example { get('/foo/a/b.png').body.should be == '["a", "b"] "png"' }
-    end
-  end
-
-  context 'works with filters' do
-    before do
-      app.before('/auth/*', except: '/auth/login') { halt 'auth required' }
-      app.get('/auth/login') { 'please log in' }
-    end
-
-    example { get('/auth/dunno').body.should be == 'auth required' }
-    example { get('/auth/login').body.should be == 'please log in' }
-  end
-end