mustermann-contrib 1.0.0.beta2

data/spec/shell_spec.rb

@@ -0,0 +1,147 @@
+require 'support'
+require 'mustermann/shell'
+
+describe Mustermann::Shell 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') }
+
+    example { pattern.params('/').should be == {} }
+    example { pattern.params('').should be_nil }
+  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 match('/foo%2Fbar') }
+    it { should match('/foo%2fbar') }
+  end
+
+  pattern '/*/bar' do
+    it { should     match('/foo/bar')     }
+    it { should     match('/bar/bar')     }
+    it { should     match('/foo%2Fbar')   }
+    it { should     match('/foo%2fbar')   }
+    it { should_not match('/foo/foo/bar') }
+    it { should_not match('/bar/foo')     }
+  end
+
+  pattern '/**/foo' do
+    it { should match('/a/b/c/foo')   }
+    it { should match('/a/b/c/foo')   }
+    it { should match('/a/.b/c/foo')  }
+    it { should match('/a/.b/c/foo')  }
+  end
+
+  pattern '/:foo' do
+    it { should     match('/:foo')    }
+    it { should     match('/%3Afoo')  }
+    it { should_not match('/foo')     }
+    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 '/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_not match('/path%2Bwith%2Bspaces') }
+    it { should_not match('/path+with+spaces')     }
+  end
+
+  pattern '/foo&bar' do
+    it { should match('/foo&bar') }
+  end
+
+  pattern '/test.bar' do
+    it { should     match('/test.bar') }
+    it { should_not match('/test0bar') }
+  end
+
+  pattern '/{foo,bar}' do
+    it { should     match('/foo')    }
+    it { should     match('/bar')    }
+    it { should_not match('/foobar') }
+  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_not match('/path%20with%20spaces') }
+    it { should_not match('/path%2Bwith%2Bspaces') }
+    it { should_not match('/path+with+spaces')     }
+  end
+
+  describe :=~ do
+    example { '/foo'.should be =~ Mustermann::Shell.new('/foo') }
+  end
+
+  context "peeking" do
+    subject(:pattern) { Mustermann::Shell.new("foo*/") }
+
+    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 }
+
+      context 'with just * as pattern' do
+        subject(:pattern) { Mustermann::Shell.new('*') }
+        example { pattern.peek_size('foo')              .should be == 3 }
+        example { pattern.peek_size('foo/bar')          .should be == 3 }
+        example { pattern.peek_size('foo/bar/baz')      .should be == 3 }
+        example { pattern.peek_size('foo/bar/baz/blah') .should be == 3 }
+      end
+    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 == [{}, "foo bar/".size] }
+      example { pattern.peek_params("foo%20bar/blah") .should be == [{}, "foo%20bar/".size] }
+      example { pattern.peek_params("/foo bar")       .should be_nil }
+    end
+  end
+
+  context "highlighting" do
+    let(:pattern) { Mustermann::Shell.new("/**,*/\\*/{a,b}") }
+    subject(:sexp) { Mustermann::Visualizer.highlight(pattern).to_sexp }
+    it { should be == '(root (separator /) (special *) (special *) (char ,) (special *) (separator /) (escaped "\\\\" (escaped_char *)) (separator /) (union { (root (char a)) ,(root (char b)) }))' }
+  end
+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

data/spec/string_scanner_spec.rb

@@ -0,0 +1,271 @@
+require 'support'
+require 'mustermann/string_scanner'
+
+describe Mustermann::StringScanner do
+  include Support::ScanMatcher
+
+  subject(:scanner) { Mustermann::StringScanner.new(example_string) }
+  let(:example_string) { "foo bar" }
+
+  describe :scan do
+    it { should scan("foo")     }
+    it { should scan(/foo/)     }
+    it { should scan(:name)     }
+    it { should scan(":name")   }
+
+    it { should_not scan(" ")   }
+    it { should_not scan("bar") }
+
+    example do
+      should scan("foo")
+      should scan(" ")
+      should scan("bar")
+    end
+
+    example do
+      scanner.position = 4
+      should scan("bar")
+    end
+
+    example do
+      should scan("foo")
+      scanner.reset
+      should scan("foo")
+    end
+  end
+
+  describe :check do
+    it { should check("foo")     }
+    it { should check(/foo/)     }
+    it { should check(:name)     }
+    it { should check(":name")   }
+
+    it { should_not check(" ")   }
+    it { should_not check("bar") }
+
+    example do
+      should     check("foo")
+      should_not check(" ")
+      should_not check("bar")
+      should     check("foo")
+    end
+
+    example do
+      scanner.position = 4
+      should check("bar")
+    end
+  end
+
+  describe :scan_until do
+    it { should scan_until("foo")     }
+    it { should scan_until(":name")   }
+    it { should scan_until(" ")       }
+    it { should scan_until("bar")     }
+    it { should_not scan_until("baz") }
+
+    example do
+      should scan_until(" ")
+      should check("bar")
+    end
+
+    example do
+      should scan_until(" ")
+      scanner.reset
+      should scan("foo")
+    end
+  end
+
+  describe :check_until do
+    it { should check_until("foo")     }
+    it { should check_until(":name")   }
+    it { should check_until(" ")       }
+    it { should check_until("bar")     }
+    it { should_not check_until("baz") }
+
+    example do
+      should check_until(" ")
+      should_not check("bar")
+    end
+  end
+
+  describe :getch do
+    example { scanner.getch.should be == "f" }
+
+    example do
+      scanner.scan("foo")
+      scanner.getch.should be == " "
+      should scan("bar")
+    end
+
+    example do
+      scanner.getch
+      scanner.reset
+      should scan("foo")
+    end
+  end
+
+  describe :<< do
+    example do
+      should_not scan_until("baz")
+      scanner << " baz"
+      scanner.to_s.should be == "foo bar baz"
+      should scan_until("baz")
+    end
+  end
+
+  describe :eos? do
+    it { should_not be_eos }
+    example do
+      scanner.position = 7
+      should be_eos
+    end
+  end
+
+  describe :beginning_of_line? do
+    let(:example_string) { "foo\nbar" }
+    it { should be_beginning_of_line }
+
+    example do
+      scanner.position = 2
+      should_not be_beginning_of_line
+    end
+
+    example do
+      scanner.position = 3
+      should_not be_beginning_of_line
+    end
+
+    example do
+      scanner.position = 4
+      should be_beginning_of_line
+    end
+  end
+
+  describe :rest do
+    example { scanner.rest.should be == "foo bar" }
+    example do
+      scanner.position = 4
+      scanner.rest.should be == "bar"
+    end
+  end
+
+  describe :rest_size do
+    example { scanner.rest_size.should be == 7 }
+    example do
+      scanner.position = 4
+      scanner.rest_size.should be == 3
+    end
+  end
+
+  describe :peek do
+    example { scanner.peek(3).should be == "foo" }
+
+    example do
+      scanner.peek(3).should be == "foo"
+      scanner.peek(3).should be == "foo"
+    end
+
+    example do
+      scanner.position = 4
+      scanner.peek(3).should be == "bar"
+    end
+  end
+
+  describe :inspect do
+    example { scanner.inspect.should be == '#<Mustermann::StringScanner 0/7 @ "foo bar">' }
+    example do
+      scanner.position = 4
+      scanner.inspect.should be == '#<Mustermann::StringScanner 4/7 @ "foo bar">'
+    end
+  end
+
+  describe :[] do
+    example do
+      should scan(:name)
+      scanner['name'].should be == "foo bar"
+    end
+
+    example do
+      should scan(:name, capture: /\S+/)
+      scanner['name'].should be == "foo"
+      should scan(" :name", capture: /\S+/)
+      scanner['name'].should be == "bar"
+    end
+
+    example do
+      should scan(":a",  capture: /\S+/)
+      should scan(" :b", capture: /\S+/)
+      scanner['a'].should be == "foo"
+      scanner['b'].should be == "bar"
+    end
+
+    example do
+      a = scanner.scan(":a",  capture: /\S+/)
+      b = scanner.scan(" :b", capture: /\S+/)
+      a.params['a'].should be == 'foo'
+      b.params['b'].should be == 'bar'
+      a.params['b'].should be_nil
+      b.params['a'].should be_nil
+    end
+
+    example do
+      result = scanner.check(":a",  capture: /\S+/)
+      result.params['a'].should be == 'foo'
+      scanner['a'].should be_nil
+    end
+
+    example do
+      should scan(:name)
+      scanner.reset
+      scanner['name'].should be_nil
+    end
+  end
+
+  describe :unscan do
+    example do
+      should scan(:name, capture: /\S+/)
+      scanner['name'].should be == "foo"
+      should scan(" :name", capture: /\S+/)
+      scanner['name'].should be == "bar"
+      scanner.unscan
+      scanner['name'].should be == "foo"
+      scanner.rest.should be == " bar"
+    end
+
+    example do
+      should scan_until(" ")
+      scanner.unscan
+      scanner.rest.should be == "foo bar"
+    end
+
+    example do
+      expect { scanner.unscan }.to raise_error(Mustermann::StringScanner::ScanError,
+        'unscan failed: previous match record not exist')
+    end
+  end
+
+  describe :terminate do
+    example do
+      scanner.terminate
+      scanner.should be_eos
+    end
+  end
+
+  describe :to_h do
+    example { scanner.to_h.should be == {} }
+    example do
+    end
+  end
+
+  describe :to_s do
+    example { scanner.to_s.should be == "foo bar" }
+  end
+
+  describe :clear_cache do
+    example do
+      scanner.scan("foo")
+      Mustermann::StringScanner.clear_cache
+      Mustermann::StringScanner.cache_size.should be == 0
+    end
+  end
+end