yaparc 0.1.6 → 0.2.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (9) hide show
  1. data/README +36 -36
  2. data/lib/yaparc.rb +121 -199
  3. data/tests/test_abc.rb +40 -41
  4. data/tests/test_calc.rb +24 -29
  5. data/tests/test_owl.rb +986 -15
  6. data/tests/test_parser.rb +94 -45
  7. data/tests/test_sql.rb +98 -106
  8. data/tests/test_uri.rb +100 -100
  9. metadata +2 -2
data/tests/test_parser.rb CHANGED
@@ -5,11 +5,25 @@ require 'pp'
5
5
  class YaparcTest < Test::Unit::TestCase
6
6
  include ::Yaparc
7
7
 
8
+ def test_directory_structure
9
+ parser = Yaparc::Seq.new(Yaparc::Many.new(Yaparc::Regex.new(/\A[a-z]/),''),
10
+ Yaparc::Many.new(Yaparc::Seq.new(Yaparc::Symbol.new('/'),
11
+ Yaparc::Regex.new(/\A[a-z]*/)) do |_,path|
12
+ path
13
+ end,'')
14
+ ) do |head, rest|
15
+ {:head => head,:rest => rest }
16
+ end
17
+ result = parser.parse("root/user")
18
+ assert_instance_of Result::OK, result
19
+ assert_equal Hash[:head=>"root", :rest=>"user"], result.value
20
+ end
21
+
8
22
  def test_seq_alt_parse
9
- parser = Yaparc::SeqParser.new(Yaparc::Symbol.new('scheme'),
10
- Yaparc::Symbol.new(':'),
11
- Yaparc::AltParser.new(Natural.new,
12
- Identifier.new))
23
+ parser = Yaparc::Seq.new(Yaparc::Symbol.new('scheme'),
24
+ Yaparc::Symbol.new(':'),
25
+ Yaparc::Alt.new(Natural.new,
26
+ Identifier.new))
13
27
  result = parser.parse("scheme:124")
14
28
  assert_instance_of Result::OK, result
15
29
  result = parser.parse("scheme:identifier")
@@ -17,7 +31,7 @@ class YaparcTest < Test::Unit::TestCase
17
31
  end
18
32
 
19
33
  def test_succeed_parse
20
- parser = ::Yaparc::SucceedParser.new(1)
34
+ parser = ::Yaparc::Succeed.new(1)
21
35
  result = parser.parse("abs")
22
36
  assert_equal 1, result.value
23
37
  assert_equal "abs", result.input
@@ -29,13 +43,13 @@ class YaparcTest < Test::Unit::TestCase
29
43
  end
30
44
 
31
45
  def test_fail_parse
32
- parser = ::Yaparc::FailParser.new
46
+ parser = ::Yaparc::Fail.new
33
47
  result = parser.parse("abc")
34
48
  assert_instance_of Result::Fail, result
35
49
  end
36
50
 
37
51
  def test_item_parse
38
- parser = ::Yaparc::ItemParser.new
52
+ parser = ::Yaparc::Item.new
39
53
  result = parser.parse("")
40
54
  assert_instance_of Result::Fail, result
41
55
  result = parser.parse("abc")
@@ -52,12 +66,12 @@ class YaparcTest < Test::Unit::TestCase
52
66
  false
53
67
  end
54
68
  end
55
- parser = SatisfyParser.new(is_integer)
69
+ parser = Satisfy.new(is_integer)
56
70
  result = parser.parse("123")
57
71
  assert_equal "1", result.value
58
72
  assert_equal "23", result.input
59
73
 
60
- parser = SatisfyParser.new(is_integer)
74
+ parser = Satisfy.new(is_integer)
61
75
  result = parser.parse("abc")
62
76
  assert_instance_of Result::Fail, result
63
77
 
@@ -69,58 +83,73 @@ class YaparcTest < Test::Unit::TestCase
69
83
  false
70
84
  end
71
85
  end
72
- parser = SatisfyParser.new(is_char)
86
+ parser = Satisfy.new(is_char)
73
87
  result = parser.parse("abc")
74
88
  assert_equal "a", result.value
75
89
  assert_equal "bc", result.input
76
90
  end
77
91
 
78
92
  def test_seq_parse
79
- parser = SeqParser.new(ItemParser.new, ItemParser.new) do |item1, item2|
93
+ parser = Seq.new(Item.new, Item.new) do |item1, item2|
80
94
  [item1, item2]
81
95
  end
82
96
  result = parser.parse("abcdef")
83
97
  assert_equal ["a", "b"], result.value
84
98
  assert_equal "cdef", result.input
85
99
 
86
- parser = SeqParser.new(ItemParser.new, ItemParser.new, ItemParser.new) do |item1, item2, item3|
100
+ parser = Seq.new(Item.new, Item.new, Item.new) do |item1, item2, item3|
87
101
  [item1, item3]
88
102
  end
89
103
  result = parser.parse("ABCDEF")
90
104
  assert_equal ["A", "C"], result.value
91
105
  assert_equal "DEF", result.input
92
106
 
93
- parser = SeqParser.new(ItemParser.new, ItemParser.new, ItemParser.new) do |item1, item2, item3|
107
+ parser = Seq.new(Item.new, Item.new, Item.new) do |item1, item2, item3|
94
108
  [item2]
95
109
  end
96
110
  result = parser.parse("ABCDEF")
97
111
  assert_equal ["B"], result.value
98
112
  assert_equal "DEF", result.input
113
+
114
+ parser = Seq.new(Digit.new, Many.new(Char.new('a'),''),Many.new(Digit.new,'')) do |digit, _,digits|
115
+ digit + digits
116
+ end
117
+ result = parser.parse("123abc")
118
+ assert_equal "123", result.value
119
+ assert_equal "abc", result.input
120
+
121
+ parser = Seq.new(
122
+ Yaparc::Apply.new(Yaparc::Tokenize.new(Digit.new)){|digit| digit}, Many.new(Char.new('a'),''),Many.new(Digit.new,'')) do |digit, _,digits|
123
+ digit + digits
124
+ end
125
+ result = parser.parse("123abc")
126
+ assert_equal "123", result.value
127
+ assert_equal "abc", result.input
99
128
  end
100
129
 
101
130
  def test_seq_parse_without_block
102
- parser = SeqParser.new(ItemParser.new, ItemParser.new)
131
+ parser = Seq.new(Item.new, Item.new)
103
132
  result = parser.parse("abcdef")
104
133
  assert_equal "b", result.value
105
134
  assert_equal "cdef", result.input
106
135
  end
107
136
 
108
137
  def test_alt_parse
109
- parser = AltParser.new(ItemParser.new, SucceedParser.new('d'))
138
+ parser = Alt.new(Item.new, Succeed.new('d'))
110
139
  result = parser.parse("abc")
111
140
  assert_equal "a", result.value
112
141
  assert_equal "bc", result.input
113
142
 
114
- parser = AltParser.new(FailParser.new, SucceedParser.new('d'))
143
+ parser = Alt.new(Fail.new, Succeed.new('d'))
115
144
  result = parser.parse("abc")
116
145
  assert_equal "d", result.value
117
146
  assert_equal "abc", result.input
118
147
 
119
- parser = AltParser.new(FailParser.new, FailParser.new)
148
+ parser = Alt.new(Fail.new, Fail.new)
120
149
  result = parser.parse("abc")
121
150
  assert_instance_of Result::Fail, result
122
151
 
123
- parser = AltParser.new(Natural.new, Ident.new)
152
+ parser = Alt.new(Natural.new, Ident.new)
124
153
  result = parser.parse("abc")
125
154
  assert_instance_of Result::OK, result
126
155
  result = parser.parse("124")
@@ -134,14 +163,14 @@ class YaparcTest < Test::Unit::TestCase
134
163
 
135
164
  def test_apply_parse
136
165
  is_digit = lambda {|i| i >= '0' and i <= '9'}
137
- parser = ApplyParser.new(SatisfyParser.new(is_digit)) do |digit|
166
+ parser = Apply.new(Satisfy.new(is_digit)) do |digit|
138
167
  digit.to_i - '0'.to_i
139
168
  end
140
169
  result = parser.parse('7')
141
170
  assert_equal 7, result.value
142
171
  assert_equal "", result.input
143
172
 
144
- parser = Yaparc::ApplyParser.new(Yaparc::RegexParser.new(/\d+/)) do |match|
173
+ parser = Yaparc::Apply.new(Yaparc::Regex.new(/\d+/)) do |match|
145
174
  Integer(match)
146
175
  end
147
176
  result = parser.parse('7')
@@ -149,50 +178,50 @@ class YaparcTest < Test::Unit::TestCase
149
178
  end
150
179
 
151
180
  def test_char_parse
152
- parser = CharParser.new("a")
181
+ parser = Char.new("a")
153
182
  result = parser.parse("abc")
154
183
  assert_equal "a", result.value
155
184
  assert_equal "bc", result.input
156
185
 
157
- parser = CharParser.new("a")
186
+ parser = Char.new("a")
158
187
  result = parser.parse("123")
159
188
  assert_instance_of Result::Fail, result
160
189
  end
161
190
 
162
191
  def test_string_parse
163
- parser = StringParser.new("abc")
192
+ parser = Yaparc::String.new("abc")
164
193
  result = parser.parse("abcdef")
165
194
  assert_equal "abc", result.value
166
195
  assert_equal "def", result.input
167
196
 
168
- parser = StringParser.new("abc")
197
+ parser = Yaparc::String.new("abc")
169
198
  result = parser.parse("ab1234")
170
199
  assert_instance_of Result::Fail, result
171
200
  end
172
201
 
173
202
  def test_regex_parse
174
- parser = RegexParser.new(/[a-z]/)
203
+ parser = Regex.new(/\A[a-z]/)
175
204
  result = parser.parse("abcdef")
176
205
  assert_equal "a", result.value
177
206
  assert_equal "bcdef", result.input
178
207
 
179
- parser = RegexParser.new(/[0-9]+/)
208
+ parser = Regex.new(/\A[0-9]+/)
180
209
  result = parser.parse("1234ab")
181
210
  assert_equal "1234", result.value
182
211
  assert_equal "ab", result.input
183
212
 
184
- parser = RegexParser.new(/[0-9]+/)
213
+ parser = Regex.new(/\A[0-9]+/)
185
214
  result = parser.parse("1234ab") do |match|
186
215
  Integer(match)
187
216
  end
188
217
  assert_equal 1234, result.value
189
218
 
190
- parser = RegexParser.new(/([0-9]+):([a-z]+)/)
219
+ parser = Regex.new(/([0-9]+):([a-z]+)/)
191
220
  result = parser.parse_with_parameter("1234:ab") do |match1, match2|
192
221
  assert_equal 'ab', match2
193
222
  end
194
223
 
195
- parser = RegexParser.new(/([0-9]+):([a-z]+)/) do |match1, match2|
224
+ parser = Regex.new(/([0-9]+):([a-z]+)/) do |match1, match2|
196
225
  [match2,match1]
197
226
  end
198
227
  result = parser.parse("1234:ab")
@@ -200,19 +229,19 @@ class YaparcTest < Test::Unit::TestCase
200
229
  end
201
230
 
202
231
  def test_zero_one_parse
203
- parser = ZeroOneParser.new(StringParser.new("abc"))
232
+ parser = ZeroOne.new(Yaparc::String.new("abc"))
204
233
  result = parser.parse("abc ")
205
234
  assert_equal "abc", result.value
206
235
  assert_equal " ", result.input
207
- parser = ZeroOneParser.new(StringParser.new("abc"))
236
+ parser = ZeroOne.new(Yaparc::String.new("abc"))
208
237
  result = parser.parse("123")
209
238
  assert_equal [], result.value
210
239
  assert_equal "123", result.input
211
240
  end
212
241
 
213
242
  def test_many_parse
214
- is_digit = SatisfyParser.new(lambda {|i| i >= '0' and i <= '9'})
215
- parser = ManyParser.new(is_digit,"")
243
+ is_digit = Satisfy.new(lambda {|i| i >= '0' and i <= '9'})
244
+ parser = Many.new(is_digit,"")
216
245
  result = parser.parse("123abc")
217
246
  assert_equal "123", result.value
218
247
  assert_equal "abc", result.input
@@ -220,11 +249,19 @@ class YaparcTest < Test::Unit::TestCase
220
249
  result = parser.parse("abcdef")
221
250
  assert_equal "", result.value
222
251
  assert_equal "abcdef", result.input
252
+
253
+ parser = Many.new(Alt.new(Ident.new, Nat.new),'')
254
+ result = parser.parse("abc23def")
255
+ assert_equal "abc23def", result.value
256
+
257
+ parser = Many.new(Digit.new,0)
258
+ result = parser.parse("abc")
259
+ assert_instance_of Result::OK, result
223
260
  end
224
261
 
225
262
  def test_many_one_parse
226
- is_digit = SatisfyParser.new(lambda {|i| i >= '0' and i <= '9'})
227
- parser = ManyOneParser.new(is_digit,"")
263
+ is_digit = Satisfy.new(lambda {|i| i >= '0' and i <= '9'})
264
+ parser = ManyOne.new(is_digit,"")
228
265
  result = parser.parse("123abc")
229
266
  assert_equal "123", result.value
230
267
  assert_equal "abc", result.input
@@ -232,6 +269,10 @@ class YaparcTest < Test::Unit::TestCase
232
269
  result = parser.parse("abcdef")
233
270
  assert_instance_of Result::Fail, result
234
271
  assert_equal "abcdef", result.input
272
+
273
+ parser = ManyOne.new(Char.new('a'),'')
274
+ result = parser.parse("123abc")
275
+ assert_instance_of Result::Fail, result
235
276
  end
236
277
 
237
278
  def test_ident
@@ -241,6 +282,13 @@ class YaparcTest < Test::Unit::TestCase
241
282
  assert_equal " def", result.input
242
283
  end
243
284
 
285
+ def test_digit
286
+ parser = Digit.new
287
+ result = parser.parse("123 abc")
288
+ assert_equal '1', result.value
289
+ assert_equal "23 abc", result.input
290
+ end
291
+
244
292
  def test_nat
245
293
  parser = Nat.new
246
294
  result = parser.parse("123 abc")
@@ -249,7 +297,7 @@ class YaparcTest < Test::Unit::TestCase
249
297
  end
250
298
 
251
299
  def test_nat_ident
252
- parser = SeqParser.new(Nat.new, Ident.new) do |nat, ident|
300
+ parser = Seq.new(Nat.new, Ident.new) do |nat, ident|
253
301
  [nat,ident]
254
302
  end
255
303
  result = parser.parse("123abc")
@@ -279,9 +327,9 @@ class YaparcTest < Test::Unit::TestCase
279
327
  # end
280
328
 
281
329
  def test_tokenize_with_block
282
- parser = TokenizeParser.new(Ident.new) do |tokenize|
283
- tokenize.prefix = SpaceParser.new
284
- tokenize.postfix = SpaceParser.new
330
+ parser = Tokenize.new(Ident.new) do |tokenize|
331
+ tokenize.prefix = Space.new
332
+ tokenize.postfix = Space.new
285
333
  end
286
334
 
287
335
  result = parser.parse(" abc")
@@ -293,9 +341,9 @@ class YaparcTest < Test::Unit::TestCase
293
341
  assert_instance_of Result::Fail, result
294
342
  assert_equal "\n abc", result.input
295
343
 
296
- parser = TokenizeParser.new(Ident.new) do |tokenize|
297
- tokenize.prefix = WhiteSpaceParser.new
298
- tokenize.postfix = WhiteSpaceParser.new
344
+ parser = Tokenize.new(Ident.new) do |tokenize|
345
+ tokenize.prefix = WhiteSpace.new
346
+ tokenize.postfix = WhiteSpace.new
299
347
  end
300
348
 
301
349
  result = parser.parse(" \n abc")
@@ -305,14 +353,14 @@ class YaparcTest < Test::Unit::TestCase
305
353
  end
306
354
 
307
355
  def test_tokenize_without_block
308
- parser = TokenizeParser.new(Ident.new, :prefix => WhiteSpaceParser.new, :postfix => WhiteSpaceParser.new)
356
+ parser = Tokenize.new(Ident.new, :prefix => WhiteSpace.new, :postfix => WhiteSpace.new)
309
357
 
310
358
  result = parser.parse(" abc")
311
359
  assert_instance_of Result::OK, result
312
360
  assert_equal "abc", result.value
313
361
  assert_equal "", result.input
314
362
 
315
- parser = TokenizeParser.new(Ident.new, :prefix => SpaceParser.new, :postfix => SpaceParser.new)
363
+ parser = Tokenize.new(Ident.new, :prefix => Space.new, :postfix => Space.new)
316
364
  result = parser.parse(" \n abc")
317
365
  assert_instance_of Result::Fail, result
318
366
  assert_equal "\n abc", result.input
@@ -336,6 +384,7 @@ class YaparcTest < Test::Unit::TestCase
336
384
  result = parser_with_keyword.parse(" xyz")
337
385
  assert_equal "xyz", result.value
338
386
  assert_equal "", result.input
387
+
339
388
  end
340
389
 
341
390
  def test_natural
@@ -353,7 +402,7 @@ class YaparcTest < Test::Unit::TestCase
353
402
  end
354
403
 
355
404
  def test_literal_parser
356
- parser = LiteralParser.new('%')
405
+ parser = Literal.new('%')
357
406
  result = parser.parse(" % ")
358
407
  assert_equal "%", result.value
359
408
  assert_equal "", result.input
data/tests/test_sql.rb CHANGED
@@ -31,7 +31,7 @@ module SQL
31
31
 
32
32
  def initialize
33
33
  @parser = lambda do
34
- Yaparc::SeqParser.new(SelectExpression.new,
34
+ Yaparc::Seq.new(SelectExpression.new,
35
35
  FromExpression.new,
36
36
  WhereExpression.new) do |select, from, where|
37
37
  {:select => select, :from => from, :where => where }
@@ -46,7 +46,7 @@ module SQL
46
46
 
47
47
  def initialize
48
48
  @parser = lambda do
49
- Yaparc::SeqParser.new(
49
+ Yaparc::Seq.new(
50
50
  Yaparc::Symbol.new('select'),
51
51
  TermSequence.new) do |_,terms|
52
52
  terms
@@ -61,18 +61,15 @@ module SQL
61
61
 
62
62
  def initialize
63
63
  @parser = lambda do
64
- Yaparc::SeqParser.new(
65
- Term.new,
66
- Yaparc::ManyParser.new(
67
- Yaparc::SeqParser.new(
68
- Yaparc::Symbol.new(','),
69
- TermSequence.new) do |_, terms|
70
- terms
71
- end
72
- # end,
73
- # []
74
- )
75
- ) do |term,terms|
64
+ Yaparc::Seq.new(
65
+ Term.new,
66
+ Yaparc::Many.new(
67
+ Yaparc::Seq.new(
68
+ Yaparc::Symbol.new(','),
69
+ TermSequence.new) do |_, terms|
70
+ terms
71
+ end)
72
+ ) do |term,terms|
76
73
  [term] + terms
77
74
  end
78
75
  end
@@ -85,16 +82,16 @@ module SQL
85
82
 
86
83
  def initialize
87
84
  @parser = lambda do
88
- Yaparc::SeqParser.new(
89
- Yaparc::Symbol.new('from'),
90
- PathExpression.new,
91
- Yaparc::ManyParser.new(
92
- Yaparc::SeqParser.new(
93
- Yaparc::Symbol.new(','),
94
- PathExpression.new) do |_, path|
95
- [path]
96
- end)
97
- ) do |_,path,paths|
85
+ Yaparc::Seq.new(
86
+ Yaparc::Symbol.new('from'),
87
+ PathExpression.new,
88
+ Yaparc::Many.new(
89
+ Yaparc::Seq.new(
90
+ Yaparc::Symbol.new(','),
91
+ PathExpression.new) do |_, path|
92
+ [path]
93
+ end)
94
+ ) do |_,path,paths|
98
95
  path + paths
99
96
  end
100
97
  end
@@ -108,10 +105,10 @@ module SQL
108
105
 
109
106
  def initialize
110
107
  @parser = lambda do
111
- Yaparc::SeqParser.new(
108
+ Yaparc::Seq.new(
112
109
  Yaparc::Symbol.new('/'),
113
110
  Term.new,
114
- Yaparc::ManyParser.new(
111
+ Yaparc::Many.new(
115
112
  PathExpression.new do |path|
116
113
  path
117
114
  end)
@@ -129,7 +126,7 @@ module SQL
129
126
 
130
127
  def initialize
131
128
  @parser = lambda do
132
- Yaparc::ManyParser.new(SearchCond.new)
129
+ Yaparc::Many.new(SearchCond.new)
133
130
  end
134
131
  end
135
132
  end
@@ -159,74 +156,74 @@ module SQL
159
156
 
160
157
  def initialize
161
158
  @parser = lambda do
162
- Yaparc::AltParser.new(
163
- Yaparc::SeqParser.new(Term.new,
164
- Op.new,
165
- Term.new) do |term1, op, term2|
166
- {:operator => op, :args => [term1, term2]}
167
- end,
168
- Yaparc::SeqParser.new(Yaparc::Symbol.new('('),
169
- Yaparc::Symbol.new('NOT'),
170
- SearchCond.new,
171
- Yaparc::Symbol.new(')')) do |_, _, cond, _|
172
- {:logic => :not, :conditions => [cond]}
173
- end,
174
- Yaparc::SeqParser.new(Yaparc::Symbol.new('('),
175
- SearchCond.new,
176
- Yaparc::Symbol.new('AND'),
177
- SearchCond.new,
178
- Yaparc::Symbol.new(')')) do |_, cond1, _,cond2,_|
179
- {:logic => :and, :conditions => [cond1, cond2]}
180
- end,
181
- Yaparc::SeqParser.new(Yaparc::Symbol.new('('),
182
- SearchCond.new,
183
- Yaparc::Symbol.new('OR'),
184
- SearchCond.new,
185
- Yaparc::Symbol.new(')')) do |_, cond1, _,cond2,_|
186
- {:logic => :or, :conditions => [cond1,cond2]}
187
- end,
188
- Yaparc::SeqParser.new(Yaparc::Symbol.new('EXISTS'),
189
- Yaparc::Symbol.new('('),
190
- QueryBody.new,
191
- Yaparc::Symbol.new(')')) do |_, _, body,_|
192
- {:logic => :exits, :condition => body}
193
- end,
194
- # term op ANY ( query_body )
195
- Yaparc::SeqParser.new(Term.new,
196
- Op.new,
197
- Yaparc::Symbol.new('ANY'),
198
- Yaparc::Symbol.new('('),
199
- QueryBody.new,
200
- Yaparc::Symbol.new(')')) do |term, op, _, _, body,_|
201
- {:operator => op,
202
- :term1 => term,
203
- :term2 => {:logic => :any, :condition => body}
204
- }
205
- end,
206
- # term op ALL ( query_body )
207
- Yaparc::SeqParser.new(Term.new,
208
- Op.new,
209
- Yaparc::Symbol.new('ALL'),
210
- Yaparc::Symbol.new('('),
211
- QueryBody.new,
212
- Yaparc::Symbol.new(')')) do |term, op, _, _, body,_|
213
- {:operator => op,
214
- :term1 => term,
215
- :term2 => {:logic => :ALL, :condition => body}
216
- }
217
- end,
218
- # term IN ( query_body )
219
- Yaparc::SeqParser.new(Term.new,
220
- Op.new,
221
- Yaparc::Symbol.new('IN'),
222
- Yaparc::Symbol.new('('),
223
- QueryBody.new,
224
- Yaparc::Symbol.new(')')) do |term, op, _, _, body,_|
225
- {:operator => op,
226
- :term1 => term,
227
- :term2 => {:logic => :IN, :condition => body}
228
- }
229
- end)
159
+ Yaparc::Alt.new(
160
+ Yaparc::Seq.new(Term.new,
161
+ Op.new,
162
+ Term.new) do |term1, op, term2|
163
+ {:operator => op, :args => [term1, term2]}
164
+ end,
165
+ Yaparc::Seq.new(Yaparc::Symbol.new('('),
166
+ Yaparc::Symbol.new('NOT'),
167
+ SearchCond.new,
168
+ Yaparc::Symbol.new(')')) do |_, _, cond, _|
169
+ {:logic => :not, :conditions => [cond]}
170
+ end,
171
+ Yaparc::Seq.new(Yaparc::Symbol.new('('),
172
+ SearchCond.new,
173
+ Yaparc::Symbol.new('AND'),
174
+ SearchCond.new,
175
+ Yaparc::Symbol.new(')')) do |_, cond1, _,cond2,_|
176
+ {:logic => :and, :conditions => [cond1, cond2]}
177
+ end,
178
+ Yaparc::Seq.new(Yaparc::Symbol.new('('),
179
+ SearchCond.new,
180
+ Yaparc::Symbol.new('OR'),
181
+ SearchCond.new,
182
+ Yaparc::Symbol.new(')')) do |_, cond1, _,cond2,_|
183
+ {:logic => :or, :conditions => [cond1,cond2]}
184
+ end,
185
+ Yaparc::Seq.new(Yaparc::Symbol.new('EXISTS'),
186
+ Yaparc::Symbol.new('('),
187
+ QueryBody.new,
188
+ Yaparc::Symbol.new(')')) do |_, _, body,_|
189
+ {:logic => :exits, :condition => body}
190
+ end,
191
+ # term op ANY ( query_body )
192
+ Yaparc::Seq.new(Term.new,
193
+ Op.new,
194
+ Yaparc::Symbol.new('ANY'),
195
+ Yaparc::Symbol.new('('),
196
+ QueryBody.new,
197
+ Yaparc::Symbol.new(')')) do |term, op, _, _, body,_|
198
+ {:operator => op,
199
+ :term1 => term,
200
+ :term2 => {:logic => :any, :condition => body}
201
+ }
202
+ end,
203
+ # term op ALL ( query_body )
204
+ Yaparc::Seq.new(Term.new,
205
+ Op.new,
206
+ Yaparc::Symbol.new('ALL'),
207
+ Yaparc::Symbol.new('('),
208
+ QueryBody.new,
209
+ Yaparc::Symbol.new(')')) do |term, op, _, _, body,_|
210
+ {:operator => op,
211
+ :term1 => term,
212
+ :term2 => {:logic => :ALL, :condition => body}
213
+ }
214
+ end,
215
+ # term IN ( query_body )
216
+ Yaparc::Seq.new(Term.new,
217
+ Op.new,
218
+ Yaparc::Symbol.new('IN'),
219
+ Yaparc::Symbol.new('('),
220
+ QueryBody.new,
221
+ Yaparc::Symbol.new(')')) do |term, op, _, _, body,_|
222
+ {:operator => op,
223
+ :term1 => term,
224
+ :term2 => {:logic => :IN, :condition => body}
225
+ }
226
+ end)
230
227
  end
231
228
  end
232
229
  end
@@ -237,12 +234,12 @@ module SQL
237
234
 
238
235
  def initialize
239
236
  @parser = lambda do
240
- Yaparc::AltParser.new(
241
- Yaparc::ApplyParser.new(Yaparc::Symbol.new('<>')) {|_| :not},
242
- Yaparc::ApplyParser.new(Yaparc::Symbol.new('<=')) {|_| :lesser_eq },
243
- Yaparc::ApplyParser.new(Yaparc::Symbol.new('>=')) {|_| :greater_eq },
244
- Yaparc::ApplyParser.new(Yaparc::Symbol.new('<')) {|_| :lesser},
245
- Yaparc::ApplyParser.new(Yaparc::Symbol.new('>')) {|_| :greater })
237
+ Yaparc::Alt.new(
238
+ Yaparc::Apply.new(Yaparc::Symbol.new('<>')) {|_| :not},
239
+ Yaparc::Apply.new(Yaparc::Symbol.new('<=')) {|_| :lesser_eq },
240
+ Yaparc::Apply.new(Yaparc::Symbol.new('>=')) {|_| :greater_eq },
241
+ Yaparc::Apply.new(Yaparc::Symbol.new('<')) {|_| :lesser},
242
+ Yaparc::Apply.new(Yaparc::Symbol.new('>')) {|_| :greater })
246
243
  end
247
244
  end
248
245
  end
@@ -252,11 +249,6 @@ end # of SQL
252
249
  class YaparcQueryTest < Test::Unit::TestCase
253
250
  include ::Yaparc
254
251
 
255
- # def setup
256
- # @expr = Expr.new
257
- # @factor = Factor.new
258
- # end
259
-
260
252
  def test_op
261
253
  op = SQL::Op.new
262
254
  result = op.parse("<")