yaparc 0.1.6 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
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("<")