1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
# frozen_string_literal: true
require 'support'
require 'mustermann'
describe Mustermann::Concat do
describe Mustermann::Concat::Native do
context "sinatra + sinatra" do
subject(:pattern) { Mustermann.new("/:foo") + Mustermann.new("/:bar") }
its(:class) { should be == Mustermann::Sinatra }
its(:to_s) { should be == "/{foo}/{bar}" }
end
context "sinatra + string" do
subject(:pattern) { Mustermann.new("/:foo") + "/:bar" }
its(:class) { should be == Mustermann::Sinatra }
its(:to_s) { should be == "/{foo}/\\:bar" }
end
context "regular + regular" do
subject(:pattern) { Mustermann.new(/foo/) + Mustermann.new(/bar/) }
its(:class) { should be == Mustermann::Regular }
its(:to_s) { should be == "foobar" }
end
xcontext "sinatra + rails" do
subject(:pattern) { Mustermann.new("/:foo") + Mustermann.new("/:bar", type: :rails) }
its(:class) { should be == Mustermann::Sinatra }
its(:to_s) { should be == "/{foo}/{bar}" }
end
xcontext "sinatra + flask" do
subject(:pattern) { Mustermann.new("/:foo") + Mustermann.new("/<bar>", type: :flask) }
its(:class) { should be == Mustermann::Sinatra }
its(:to_s) { should be == "/{foo}/{bar}" }
end
xcontext "sinatra + flask (typed)" do
subject(:pattern) { Mustermann.new("/:foo") + Mustermann.new("/<int:bar>", type: :flask) }
its(:class) { should be == Mustermann::Concat }
its(:to_s) { should be == '(sinatra:"/:foo" + flask:"/<int:bar>")' }
end
context "sinatra + sinatra (different options)" do
subject(:pattern) { Mustermann.new("/:foo") + Mustermann.new("/:bar", uri_decode: false) }
its(:class) { should be == Mustermann::Concat }
its(:to_s) { should be == '(sinatra:"/:foo" + sinatra:"/:bar")' }
end
xcontext "sinatra + rails (different options)" do
subject(:pattern) { Mustermann.new("/:foo") + Mustermann.new("/:bar", type: :rails, uri_decode: false) }
its(:class) { should be == Mustermann::Concat }
its(:to_s) { should be == '(sinatra:"/:foo" + rails:"/:bar")' }
end
xcontext "sinatra + rails (different options) + sinatra" do
subject(:pattern) { Mustermann.new("/:foo") + Mustermann.new("/:bar", type: :rails, uri_decode: false) + Mustermann.new("/:baz") }
its(:class) { should be == Mustermann::Concat }
its(:to_s) { should be == '(sinatra:"/:foo" + rails:"/:bar" + sinatra:"/:baz")' }
end
context "sinatra + (sinatra + regular)" do
subject(:pattern) { Mustermann.new("/foo") + (Mustermann.new("/bar") + Mustermann.new(/baz/)) }
its(:class) { should be == Mustermann::Concat }
its(:to_s) { should be == '(sinatra:"/foo/bar" + regular:"baz")' }
end
xcontext "sinatra + (sinatra + rails (different options) + sinatra)" do
subject(:pattern) { Mustermann.new("/foo") + (Mustermann.new("/bar") + Mustermann.new("/baz", type: :rails, uri_decode: false) + Mustermann.new("/boo")) }
its(:class) { should be == Mustermann::Concat }
its(:to_s) { should be == '(sinatra:"/foo/bar" + rails:"/baz" + sinatra:"/boo")' }
end
end
subject(:pattern) { Mustermann::Concat.new("/:foo", "/:bar") }
describe :=== do
example { (pattern === "/foo/bar") .should be true }
example { (pattern === "/foo/bar/") .should be false }
example { (pattern === "/foo") .should be false }
end
describe :match do
it { should match("/foo/bar").capturing(foo: "foo", bar: "bar") }
it { should_not match("/foo/bar/") }
it { should_not match("/foo/") }
end
describe :params do
example { pattern.params("/foo/bar") .should be == { "foo" => "foo", "bar" => "bar" }}
example { pattern.params("/foo/bar/") .should be_nil }
example { pattern.params("/foo") .should be_nil }
end
describe :peek do
example { pattern.peek("/foo/bar/baz") .should be == "/foo/bar" }
example { pattern.peek("/foo") .should be_nil }
end
describe :peek_params do
example { pattern.peek_params("/foo/bar/baz") .should be == [{ "foo" => "foo", "bar" => "bar" }, 8]}
example { pattern.peek_params("/foo") .should be_nil }
end
describe :peek_match do
example { pattern.peek_match("/foo/bar/baz").to_s .should be == "/foo/bar" }
example { pattern.peek_match("/foo") .should be_nil }
end
describe :peek_size do
example { pattern.peek_size("/foo/bar/baz") .should be == 8 }
example { pattern.peek_size("/foo") .should be_nil }
end
describe :expand do
it { should expand(foo: :bar, bar: :foo) .to('/bar/foo') }
it { should expand(:append, foo: :bar, bar: :foo, baz: 42) .to('/bar/foo?baz=42') }
it { should_not expand(foo: :bar) }
end
describe :to_templates do
subject(:pattern) { Mustermann::Concat.new("/:foo|:bar", "(/:baz)?") }
it { should generate_template("/{foo}/{baz}") }
it { should generate_template("{bar}/{baz}") }
it { should generate_template("/{foo}") }
it { should generate_template("{bar}") }
end
end
|
