blob: 2f5522bc8aec6f9b4b0d98c7953f4e6a61e905c8 (
plain)
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
|
require_relative '../../spec_helper'
require_relative '../fixtures/classes'
describe "Regexps with modifiers" do
it "supports /i (case-insensitive)" do
/foo/i.match("FOO").to_a.should == ["FOO"]
end
it "supports /m (multiline)" do
/foo.bar/m.match("foo\nbar").to_a.should == ["foo\nbar"]
/foo.bar/.match("foo\nbar").should be_nil
end
it "supports /x (extended syntax)" do
/\d +/x.match("abc123").to_a.should == ["123"] # Quantifiers can be separated from the expression they apply to
end
it "supports /o (once)" do
2.times do |i|
/#{i}/o.should == /0/
end
end
it "invokes substitutions for /o only once" do
ScratchPad.record []
o = Object.new
def o.to_s
ScratchPad << :to_s
"class_with_to_s"
end
eval "2.times { /#{o}/o }"
ScratchPad.recorded.should == [:to_s]
end
it "supports modifier combinations" do
/foo/imox.match("foo").to_a.should == ["foo"]
/foo/imoximox.match("foo").to_a.should == ["foo"]
-> { eval('/foo/a') }.should raise_error(SyntaxError)
end
it "supports (?~) (absent operator)" do
Regexp.new("(?~foo)").match("hello").to_a.should == ["hello"]
"foo".scan(Regexp.new("(?~foo)")).should == ["fo","o",""]
end
it "supports (?imx-imx) (inline modifiers)" do
/(?i)foo/.match("FOO").to_a.should == ["FOO"]
/foo(?i)/.match("FOO").should be_nil
# Interaction with /i
/(?-i)foo/i.match("FOO").should be_nil
/foo(?-i)/i.match("FOO").to_a.should == ["FOO"]
# Multiple uses
/foo (?i)bar (?-i)baz/.match("foo BAR baz").to_a.should == ["foo BAR baz"]
/foo (?i)bar (?-i)baz/.match("foo BAR BAZ").should be_nil
/(?m)./.match("\n").to_a.should == ["\n"]
/.(?m)/.match("\n").should be_nil
# Interaction with /m
/(?-m)./m.match("\n").should be_nil
/.(?-m)/m.match("\n").to_a.should == ["\n"]
# Multiple uses
/. (?m). (?-m)./.match(". \n .").to_a.should == [". \n ."]
/. (?m). (?-m)./.match(". \n \n").should be_nil
/(?x) foo /.match("foo").to_a.should == ["foo"]
/ foo (?x)/.match("foo").should be_nil
# Interaction with /x
/(?-x) foo /x.match("foo").should be_nil
/ foo (?-x)/x.match("foo").to_a.should == ["foo"]
# Multiple uses
/( foo )(?x)( bar )(?-x)( baz )/.match(" foo bar baz ").to_a.should == [" foo bar baz ", " foo ", "bar", " baz "]
/( foo )(?x)( bar )(?-x)( baz )/.match(" foo barbaz").should be_nil
# Parsing
/(?i-i)foo/.match("FOO").should be_nil
/(?ii)foo/.match("FOO").to_a.should == ["FOO"]
/(?-)foo/.match("foo").to_a.should == ["foo"]
-> { eval('/(?o)/') }.should raise_error(SyntaxError)
end
it "supports (?imx-imx:expr) (scoped inline modifiers)" do
/foo (?i:bar) baz/.match("foo BAR baz").to_a.should == ["foo BAR baz"]
/foo (?i:bar) baz/.match("foo BAR BAZ").should be_nil
/foo (?-i:bar) baz/i.match("foo BAR BAZ").should be_nil
/. (?m:.) ./.match(". \n .").to_a.should == [". \n ."]
/. (?m:.) ./.match(". \n \n").should be_nil
/. (?-m:.) ./m.match("\n \n \n").should be_nil
/( foo )(?x: bar )( baz )/.match(" foo bar baz ").to_a.should == [" foo bar baz ", " foo ", " baz "]
/( foo )(?x: bar )( baz )/.match(" foo barbaz").should be_nil
/( foo )(?-x: bar )( baz )/x.match("foo bar baz").to_a.should == ["foo bar baz", "foo", "baz"]
# Parsing
/(?i-i:foo)/.match("FOO").should be_nil
/(?ii:foo)/.match("FOO").to_a.should == ["FOO"]
/(?-:)foo/.match("foo").to_a.should == ["foo"]
-> { eval('/(?o:)/') }.should raise_error(SyntaxError)
end
it "supports . with /m" do
# Basic matching
/./m.match("\n").to_a.should == ["\n"]
end
it "supports ASCII/Unicode modifiers" do
eval('/(?a)[[:alpha:]]+/').match("a\u3042").to_a.should == ["a"]
eval('/(?d)[[:alpha:]]+/').match("a\u3042").to_a.should == ["a\u3042"]
eval('/(?u)[[:alpha:]]+/').match("a\u3042").to_a.should == ["a\u3042"]
eval('/(?a)\w+/').match("a\u3042").to_a.should == ["a"]
eval('/(?d)\w+/').match("a\u3042").to_a.should == ["a"]
eval('/(?u)\w+/').match("a\u3042").to_a.should == ["a\u3042"]
end
end
|
