mustermann 0.3.1 → 0.4.0

data/lib/mustermann/pattern_cache.rb

@@ -0,0 +1,49 @@
+require 'set'
+require 'thread'
+require 'mustermann'
+
+module Mustermann
+  # A simple, persistent cache for creating repositories.
+  #
+  # @example
+  #   require 'mustermann/pattern_cache'
+  #   cache = Mustermann::PatternCache.new
+  #   
+  #   # use this instead of Mustermann.new
+  #   pattern = cache.create_pattern("/:name", type: :rails)
+  #
+  # @note
+  #   {Mustermann::Pattern.new} (which is used by {Mustermann.new}) will reuse instances that have
+  #   not yet been garbage collected. You only need an extra cache if you do not keep a reference to
+  #   the patterns around.
+  #
+  # @api private
+  class PatternCache
+    # @param [Hash] pattern_options default options used for {#create_pattern}
+    def initialize(**pattern_options)
+      @cached          = Set.new
+      @mutex           = Mutex.new
+      @pattern_options = pattern_options
+    end
+
+    # @param (see Mustermann.new)
+    # @return (see Mustermann.new)
+    # @raise (see Mustermann.new)
+    # @see Mustermann.new
+    def create_pattern(string, **pattern_options)
+      pattern = Mustermann.new(string, **pattern_options, **@pattern_options)
+      @mutex.synchronize { @cached.add(pattern) } unless @cached.include? pattern
+      pattern
+    end
+
+    # Removes all pattern instances from the cache.
+    def clear
+      @mutex.synchronize { @cached.clear }
+    end
+
+    # @return [Integer] number of currently cached patterns
+    def size
+      @mutex.synchronize { @cached.size }
+    end
+  end
+end

data/lib/mustermann/regexp.rb

@@ -0,0 +1 @@
+require 'mustermann/regular'

data/lib/mustermann/regexp_based.rb

@@ -15,7 +15,24 @@ module Mustermann
     # @see (see Mustermann::Pattern#initialize)
     def initialize(string, **options)
       super
-      @regexp = compile(**options)
+      regexp       = compile(**options)
+      @peek_regexp = /\A(#{regexp})/
+      @regexp      = /\A#{regexp}\Z/
+    end
+
+    # @param (see Mustermann::Pattern#peek_size)
+    # @return (see Mustermann::Pattern#peek_size)
+    # @see (see Mustermann::Pattern#peek_size)
+    def peek_size(string)
+      return unless match = peek_match(string)
+      match.to_s.size
+    end
+
+    # @param (see Mustermann::Pattern#peek_match)
+    # @return (see Mustermann::Pattern#peek_match)
+    # @see (see Mustermann::Pattern#peek_match)
+    def peek_match(string)
+      @peek_regexp.match(string)
     end
 
     extend Forwardable

data/lib/mustermann/regular.rb

@@ -1,3 +1,4 @@
+require 'mustermann'
 require 'mustermann/regexp_based'
 
 module Mustermann
@@ -9,6 +10,8 @@ module Mustermann
   # @see Mustermann::Pattern
   # @see file:README.md#simple Syntax description in the README
   class Regular < RegexpBased
+    register :regexp, :regular
+
     # @param (see Mustermann::Pattern#initialize)
     # @return (see Mustermann::Pattern#initialize)
     # @see (see Mustermann::Pattern#initialize)
@@ -18,7 +21,7 @@ module Mustermann
     end
 
     def compile(**options)
-      /\A#{@string}\Z/
+      /#{@string}/
     end
 
     private :compile

data/lib/mustermann/simple_match.rb

@@ -26,5 +26,10 @@ module Mustermann
     def [](*args)
       captures[*args]
     end
+
+    # @return [String] string representation
+    def inspect
+      "#<%p %p>" % [self.class, @string]
+    end
   end
 end

data/lib/mustermann/sinatra.rb

@@ -1,3 +1,4 @@
+require 'mustermann'
 require 'mustermann/ast/pattern'
 
 module Mustermann
@@ -9,11 +10,27 @@ module Mustermann
   # @see Mustermann::Pattern
   # @see file:README.md#sinatra Syntax description in the README
   class Sinatra < AST::Pattern
-    on(nil, ??, ?)) { |c| unexpected(c) }
-    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(/./)) }
+    register :sinatra
+
+    on(nil, ??, ?), ?|) { |c| unexpected(c) }
+
+    on(?*)  { |c| scan(/\w+/) ? node(:named_splat, buffer.matched) : node(:splat) }
+    on(?:)  { |c| node(:capture) { scan(/\w+/) } }
+    on(?\\) { |c| node(:char, expect(/./)) }
+
+    on ?( do |char|
+      groups = []
+      groups << node(:group) { read unless check(?)) or scan(?|) } until scan(?))
+      groups.size == 1 ? groups.first : node(:union, groups)
+    end
+
+    on ?{ do |char|
+      type = scan(?+) ? :named_splat : :capture
+      name = expect(/[\w\.]+/)
+      type = :splat if type == :named_splat and name == 'splat'
+      expect(?})
+      node(type, name)
+    end
 
     suffix ?? do |char, element|
       node(:optional, element)

data/lib/mustermann/to_pattern.rb

@@ -16,8 +16,11 @@ module Mustermann
   #
   #   Foo.new.to_pattern # => #<Mustermann::Sinatra:":foo/:bar">
   #
-  # By default included into {String}, {Symbol}, {Regexp} and {Mustermann::Pattern}.
+  # By default included into String, Symbol, Regexp, Array and {Mustermann::Pattern}.
   module ToPattern
+    PRIMITIVES = [String, Symbol, Array, Regexp, Mustermann::Pattern]
+    private_constant :PRIMITIVES
+
     # Converts the object into a {Mustermann::Pattern}.
     #
     # @example converting a string
@@ -30,16 +33,18 @@ module Mustermann
     #   /.*/.to_pattern # => #<Mustermann::Regular:".*">
     #
     # @example converting a pattern
-    #  Mustermann.new("foo").to_pattern # => #<Mustermann::Sinatra:"foo">
+    #   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)
+      input   = self if PRIMITIVES.any? { |p| self.is_a? p }
+      input ||= __getobj__ if respond_to?(:__getobj__)
+      Mustermann.new(input || to_s, **options)
     end
 
-    append_features String
-    append_features Regexp
-    append_features Mustermann::Pattern
+    PRIMITIVES.each do |klass|
+      append_features(klass)
+    end
   end
 end

data/lib/mustermann/version.rb

@@ -1,3 +1,3 @@
 module Mustermann
-  VERSION ||= '0.3.1'
+  VERSION ||= '0.4.0'
 end

data/mustermann.gemspec

@@ -10,22 +10,9 @@ Gem::Specification.new do |s|
   s.summary               = %q{use patterns like regular expressions}
   s.description           = %q{library implementing patterns that behave like regular expressions}
   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.extra_rdoc_files      = %w[README.md internals.md]
-  s.require_path          = 'lib'
-  s.required_ruby_version = '>= 2.0.0'
-
   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'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'yard'
-  s.add_development_dependency 'redcarpet'
-  s.add_development_dependency 'simplecov'
-  s.add_development_dependency 'coveralls'
 end

data/spec/ast_spec.rb

@@ -0,0 +1,14 @@
+require 'support'
+require 'mustermann/ast/node'
+
+describe Mustermann::AST do
+  describe :type do
+    example { Mustermann::AST::Node[:char].type     .should be == :char }
+    example { Mustermann::AST::Node[:char].new.type .should be == :char }
+  end
+
+  describe :min_size do
+    example { Mustermann::AST::Node[:char].new.min_size.should be == 1 }
+    example { Mustermann::AST::Node[:node].new.min_size.should be == 0 }
+  end
+end

data/spec/composite_spec.rb

@@ -0,0 +1,147 @@
+require 'support'
+require 'mustermann'
+
+describe Mustermann::Composite do
+  describe :new do
+    example 'with no argument' do
+      expect { Mustermann::Composite.new }.
+        to raise_error(ArgumentError, 'cannot create empty composite pattern')
+    end
+
+    example 'with one argument' do
+      pattern = Mustermann.new('/foo')
+      Mustermann::Composite.new(pattern).should be == pattern
+    end
+  end
+
+  context :| do
+    subject(:pattern) { Mustermann.new('/foo/:name', '/:first/:second') }
+
+    describe :== do
+      example { subject.should     be == subject                                                       }
+      example { subject.should     be == Mustermann.new('/foo/:name', '/:first/:second')               }
+      example { subject.should_not be == Mustermann.new('/foo/:name')                                  }
+      example { subject.should_not be == Mustermann.new('/foo/:name', '/:first/:second', operator: :&) }
+    end
+
+    describe :=== do
+      example { subject.should     be === "/foo/bar" }
+      example { subject.should     be === "/fox/bar" }
+      example { subject.should_not be === "/foo"     }
+    end
+
+    describe :params do
+      example { subject.params("/foo/bar") .should be == { "name"  => "bar" }                    }
+      example { subject.params("/fox/bar") .should be == { "first" => "fox", "second" => "bar" } }
+      example { subject.params("/foo")     .should be_nil                                        }
+    end
+
+    describe :=== do
+      example { subject.should     match("/foo/bar") }
+      example { subject.should     match("/fox/bar") }
+      example { subject.should_not match("/foo")     }
+    end
+
+    describe :expand do
+      example { subject.should respond_to(:expand) }
+      example { subject.expand(name: 'bar')                 .should be == '/foo/bar' }
+      example { subject.expand(first: 'fox', second: 'bar') .should be == '/fox/bar' }
+
+      context "without expandable patterns" do
+        subject(:pattern) { Mustermann.new('/foo/:name', '/:first/:second', type: :simple) }
+        example { subject.should_not respond_to(:expand) }
+        example { expect { subject.expand(name: 'bar') }.to raise_error(NotImplementedError) }
+      end
+    end
+
+    describe :to_templates do
+      example { should respond_to(:to_templates) }
+      example { should generate_templates('/foo/{name}', '/{first}/{second}') }
+
+      context "without patterns implementing to_templates" do
+        subject(:pattern) { Mustermann.new('/foo/:name', '/:first/:second', type: :simple) }
+        example { should_not respond_to(:to_templates) }
+        example { expect { subject.to_templates }.to raise_error(NotImplementedError) }
+      end
+    end
+  end
+
+  context :& do
+    subject(:pattern) { Mustermann.new('/foo/:name', '/:first/:second', operator: :&) }
+
+    describe :== do
+      example { subject.should     be == subject                                                       }
+      example { subject.should     be == Mustermann.new('/foo/:name', '/:first/:second', operator: :&) }
+      example { subject.should_not be == Mustermann.new('/foo/:name')                                  }
+      example { subject.should_not be == Mustermann.new('/foo/:name', '/:first/:second')               }
+    end
+
+    describe :=== do
+      example { subject.should     be === "/foo/bar" }
+      example { subject.should_not be === "/fox/bar" }
+      example { subject.should_not be === "/foo"     }
+    end
+
+    describe :params do
+      example { subject.params("/foo/bar") .should be == { "name"  => "bar" } }
+      example { subject.params("/fox/bar") .should be_nil                     }
+      example { subject.params("/foo")     .should be_nil                     }
+    end
+
+    describe :match do
+      example { subject.should     match("/foo/bar") }
+      example { subject.should_not match("/fox/bar") }
+      example { subject.should_not match("/foo")     }
+    end
+
+    describe :expand do
+      example { subject.should_not respond_to(:expand) }
+      example { expect { subject.expand(name: 'bar') }.to raise_error(NotImplementedError) }
+    end
+  end
+
+  context :^ do
+    subject(:pattern) { Mustermann.new('/foo/:name', '/:first/:second', operator: :^) }
+
+    describe :== do
+      example { subject.should     be == subject                                                       }
+      example { subject.should_not be == Mustermann.new('/foo/:name', '/:first/:second')               }
+      example { subject.should_not be == Mustermann.new('/foo/:name')                                  }
+      example { subject.should_not be == Mustermann.new('/foo/:name', '/:first/:second', operator: :&) }
+    end
+
+    describe :=== do
+      example { subject.should_not be === "/foo/bar" }
+      example { subject.should     be === "/fox/bar" }
+      example { subject.should_not be === "/foo"     }
+    end
+
+    describe :params do
+      example { subject.params("/foo/bar") .should be_nil                                        }
+      example { subject.params("/fox/bar") .should be == { "first" => "fox", "second" => "bar" } }
+      example { subject.params("/foo")     .should be_nil                                        }
+    end
+
+    describe :match do
+      example { subject.should_not match("/foo/bar") }
+      example { subject.should     match("/fox/bar") }
+      example { subject.should_not match("/foo")     }
+    end
+
+    describe :expand do
+      example { subject.should_not respond_to(:expand) }
+      example { expect { subject.expand(name: 'bar') }.to raise_error(NotImplementedError) }
+    end
+  end
+
+  describe :inspect do
+    let(:sinatra)  { Mustermann.new('x')                  }
+    let(:rails)    { Mustermann.new('x', type: :rails)    }
+    let(:identity) { Mustermann.new('x', type: :identity) }
+
+    example { (sinatra | rails)            .inspect.should include('(sinatra:"x" | rails:"x")')                  }
+    example { (sinatra ^ rails)            .inspect.should include('(sinatra:"x" ^ rails:"x")')                  }
+    example { (sinatra | rails | identity) .inspect.should include('(sinatra:"x" | rails:"x" | identity:"x")')   }
+    example { (sinatra | rails & identity) .inspect.should include('(sinatra:"x" | (rails:"x" & identity:"x"))') }
+  end
+end

data/spec/expander_spec.rb

@@ -30,6 +30,21 @@ describe Mustermann::Expander do
     expander.expand(foo: 'pony', ext: nil).should be == '/pony'
   end
 
+  it 'supports splat' do
+    expander = Mustermann::Expander.new << Mustermann.new("/foo/*/baz")
+    expander.expand(splat: 'bar').should be == '/foo/bar/baz'
+  end
+
+  it 'supports multiple splats' do
+    expander = Mustermann::Expander.new << Mustermann.new("/foo/*/bar/*")
+    expander.expand(splat: [123, 456]).should be == '/foo/123/bar/456'
+  end
+
+  it 'supports identity patterns' do
+    expander = Mustermann::Expander.new('/:foo', type: :identity)
+    expander.expand.should be == '/:foo'
+  end
+
   describe :additional_values do
     context "illegal value" do
       example { expect { Mustermann::Expander.new(additional_values: :foo) }.to raise_error(ArgumentError) }

data/spec/identity_spec.rb

@@ -7,6 +7,21 @@ describe Mustermann::Identity do
   pattern '' do
     it { should     match('')  }
     it { should_not match('/') }
+
+    it { should respond_to(:expand)       }
+    it { should respond_to(:to_templates) }
+
+
+    it { should     generate_template('')              }
+    it { should     expand.to('')                      }
+    it { should     expand(:ignore, a: 10).to('')      }
+    it { should     expand(:append, a: 10).to('?a=10') }
+    it { should_not expand(:raise,  a: 10)             }
+    it { should_not expand(a: 10)                      }
+
+    example do
+      pattern.match('').inspect.should be == '#<Mustermann::SimpleMatch "">'
+    end
   end
 
   pattern '/' do
@@ -15,6 +30,9 @@ describe Mustermann::Identity do
 
     example { pattern.params('/').should be == {} }
     example { pattern.params('').should be_nil }
+
+    it { should generate_template('/') }
+    it { should expand.to('/')         }
   end
 
   pattern '/foo' do
@@ -37,6 +55,9 @@ describe Mustermann::Identity do
     it { should_not match('/foo/bar') }
     it { should_not match('/')        }
     it { should_not match('/foo/')    }
+
+    it { should generate_template('/:foo') }
+    it { should expand.to('/:foo')         }
   end
 
   pattern '/föö' do
@@ -57,6 +78,7 @@ describe Mustermann::Identity do
     it { should     match('/path%20with%20spaces') }
     it { should_not match('/path%2Bwith%2Bspaces') }
     it { should_not match('/path+with+spaces')     }
+    it { should generate_template('/path%20with%20spaces') }
   end
 
   pattern '/foo&bar' do
@@ -79,4 +101,26 @@ describe Mustermann::Identity do
     it { should_not match('/path%2Bwith%2Bspaces') }
     it { should_not match('/path+with+spaces')     }
   end
+
+  context "peeking" do
+    subject(:pattern) { Mustermann::Identity.new("foo bar") }
+
+    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("foobar")         .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("foobar")              .should be_nil }
+    end
+
+    describe :peek_params do
+      example { pattern.peek_params("foo bar blah")   .should be == [{}, "foo bar".size] }
+      example { pattern.peek_params("foo%20bar blah") .should be == [{}, "foo%20bar".size] }
+      example { pattern.peek_params("foobar")         .should be_nil }
+    end
+  end
 end