expressir 0.2.0 → 0.2.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (49) hide show
  1. checksums.yaml +4 -4
  2. data/demo.rb +3 -1
  3. data/expressir.gemspec +1 -1
  4. data/lib/expressir/express.rb +0 -1
  5. data/lib/expressir/express_exp/generated/ExpressLexer.rb +235 -232
  6. data/lib/expressir/express_exp/generated/ExpressParser.rb +1461 -1435
  7. data/lib/expressir/express_exp/parser.rb +8 -3
  8. data/lib/expressir/express_exp/visitor.rb +167 -136
  9. data/lib/expressir/model.rb +91 -0
  10. data/lib/expressir/model/constant.rb +2 -0
  11. data/lib/expressir/model/derived.rb +4 -0
  12. data/lib/expressir/model/entity.rb +12 -0
  13. data/lib/expressir/model/enumeration_item.rb +13 -0
  14. data/lib/expressir/model/explicit.rb +4 -0
  15. data/lib/expressir/model/expressions/aggregate_initializer.rb +13 -0
  16. data/lib/expressir/model/expressions/query.rb +8 -0
  17. data/lib/expressir/model/function.rb +31 -0
  18. data/lib/expressir/model/inverse.rb +4 -0
  19. data/lib/expressir/model/literals/binary.rb +13 -0
  20. data/lib/expressir/model/literals/integer.rb +13 -0
  21. data/lib/expressir/model/literals/logical.rb +13 -0
  22. data/lib/expressir/model/literals/real.rb +13 -0
  23. data/lib/expressir/model/literals/string.rb +15 -0
  24. data/lib/expressir/model/local.rb +2 -0
  25. data/lib/expressir/model/parameter.rb +2 -0
  26. data/lib/expressir/model/procedure.rb +31 -0
  27. data/lib/expressir/model/repository.rb +6 -0
  28. data/lib/expressir/model/rule.rb +31 -0
  29. data/lib/expressir/model/schema.rb +10 -0
  30. data/lib/expressir/model/statements/alias.rb +8 -0
  31. data/lib/expressir/model/statements/case_action.rb +2 -2
  32. data/lib/expressir/model/statements/if.rb +2 -2
  33. data/lib/expressir/model/statements/repeat.rb +10 -2
  34. data/lib/expressir/model/subtype_constraint.rb +2 -0
  35. data/lib/expressir/model/type.rb +8 -0
  36. data/lib/expressir/model/types/aggregate.rb +2 -0
  37. data/lib/expressir/model/types/enumeration.rb +4 -4
  38. data/lib/expressir/model/types/generic.rb +2 -0
  39. data/lib/expressir/model/types/generic_entity.rb +2 -0
  40. data/lib/expressir/model/types/select.rb +4 -4
  41. data/lib/expressir/model/unique.rb +2 -0
  42. data/lib/expressir/model/where.rb +2 -0
  43. data/lib/expressir/version.rb +1 -1
  44. data/original/examples/syntax/remark.exp +127 -0
  45. data/original/examples/syntax/syntax.exp +15 -10
  46. data/spec/expressir/express_exp/remark_spec.rb +301 -0
  47. data/spec/expressir/express_exp/syntax_spec.rb +659 -307
  48. metadata +15 -6
  49. data/lib/expressir/model/expressions/unknown.rb +0 -8
@@ -0,0 +1,301 @@
1
+ require "spec_helper"
2
+ require "expressir/express_exp/parser"
3
+
4
+ RSpec.describe Expressir::ExpressExp::Parser do
5
+ describe ".from_file" do
6
+ it "build an instance from a file" do
7
+ repo = Expressir::ExpressExp::Parser.from_exp(sample_file)
8
+
9
+ schema = repo.schemas.first
10
+
11
+ schema.tap do |x|
12
+ expect(x).to be_instance_of(Expressir::Model::Schema)
13
+ expect(x.remarks).to be_instance_of(Array)
14
+ expect(x.remarks.count).to eq(2)
15
+ expect(x.remarks[0]).to eq("universal scope - schema before")
16
+ expect(x.remarks[1]).to eq("universal scope - schema")
17
+ end
18
+
19
+ schema.constants.first.tap do |x|
20
+ expect(x).to be_instance_of(Expressir::Model::Constant)
21
+ expect(x.remarks).to be_instance_of(Array)
22
+ expect(x.remarks.count).to eq(2)
23
+ expect(x.remarks[0]).to eq("schema scope - constant")
24
+ expect(x.remarks[1]).to eq("universal scope - constant")
25
+ end
26
+
27
+ schema.types.first.tap do |x|
28
+ expect(x).to be_instance_of(Expressir::Model::Type)
29
+ expect(x.remarks).to be_instance_of(Array)
30
+ expect(x.remarks.count).to eq(2)
31
+ expect(x.remarks[0]).to eq("schema scope - type")
32
+ expect(x.remarks[1]).to eq("universal scope - type")
33
+ end
34
+
35
+ schema.entities.first.tap do |x|
36
+ expect(x).to be_instance_of(Expressir::Model::Entity)
37
+ expect(x.remarks).to be_instance_of(Array)
38
+ expect(x.remarks.count).to eq(2)
39
+ expect(x.remarks[0]).to eq("schema scope - entity")
40
+ expect(x.remarks[1]).to eq("universal scope - entity")
41
+ end
42
+
43
+ schema.entities.first.explicit.first.tap do |x|
44
+ expect(x).to be_instance_of(Expressir::Model::Explicit)
45
+ expect(x.remarks).to be_instance_of(Array)
46
+ expect(x.remarks.count).to eq(3)
47
+ expect(x.remarks[0]).to eq("entity scope - entity explicit")
48
+ expect(x.remarks[1]).to eq("schema scope - entity explicit")
49
+ expect(x.remarks[2]).to eq("universal scope - entity explicit")
50
+ end
51
+
52
+ schema.entities.first.derived.first.tap do |x|
53
+ expect(x).to be_instance_of(Expressir::Model::Derived)
54
+ expect(x.remarks).to be_instance_of(Array)
55
+ expect(x.remarks.count).to eq(3)
56
+ expect(x.remarks[0]).to eq("entity scope - entity derived")
57
+ expect(x.remarks[1]).to eq("schema scope - entity derived")
58
+ expect(x.remarks[2]).to eq("universal scope - entity derived")
59
+ end
60
+
61
+ schema.entities.first.inverse.first.tap do |x|
62
+ expect(x).to be_instance_of(Expressir::Model::Inverse)
63
+ expect(x.remarks).to be_instance_of(Array)
64
+ expect(x.remarks.count).to eq(3)
65
+ expect(x.remarks[0]).to eq("entity scope - entity inverse")
66
+ expect(x.remarks[1]).to eq("schema scope - entity inverse")
67
+ expect(x.remarks[2]).to eq("universal scope - entity inverse")
68
+ end
69
+
70
+ schema.entities.first.unique.first.tap do |x|
71
+ expect(x).to be_instance_of(Expressir::Model::Unique)
72
+ expect(x.remarks).to be_instance_of(Array)
73
+ expect(x.remarks.count).to eq(3)
74
+ expect(x.remarks[0]).to eq("entity scope - entity unique")
75
+ expect(x.remarks[1]).to eq("schema scope - entity unique")
76
+ expect(x.remarks[2]).to eq("universal scope - entity unique")
77
+ end
78
+
79
+ schema.entities.first.where.first.tap do |x|
80
+ expect(x).to be_instance_of(Expressir::Model::Where)
81
+ expect(x.remarks).to be_instance_of(Array)
82
+ expect(x.remarks.count).to eq(3)
83
+ expect(x.remarks[0]).to eq("entity scope - entity where")
84
+ expect(x.remarks[1]).to eq("schema scope - entity where")
85
+ expect(x.remarks[2]).to eq("universal scope - entity where")
86
+ end
87
+
88
+ schema.subtype_constraints.first.tap do |x|
89
+ expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
90
+ expect(x.remarks).to be_instance_of(Array)
91
+ expect(x.remarks.count).to eq(2)
92
+ expect(x.remarks[0]).to eq("schema scope - subtype constraint")
93
+ expect(x.remarks[1]).to eq("universal scope - subtype constraint")
94
+ end
95
+
96
+ schema.functions.first.tap do |x|
97
+ expect(x).to be_instance_of(Expressir::Model::Function)
98
+ expect(x.remarks).to be_instance_of(Array)
99
+ expect(x.remarks.count).to eq(2)
100
+ expect(x.remarks[0]).to eq("schema scope - function")
101
+ expect(x.remarks[1]).to eq("universal scope - function")
102
+ end
103
+
104
+ schema.functions.first.parameters.first.tap do |x|
105
+ expect(x).to be_instance_of(Expressir::Model::Parameter)
106
+ expect(x.remarks).to be_instance_of(Array)
107
+ expect(x.remarks.count).to eq(3)
108
+ expect(x.remarks[0]).to eq("function scope - function parameter")
109
+ expect(x.remarks[1]).to eq("schema scope - function parameter")
110
+ expect(x.remarks[2]).to eq("universal scope - function parameter")
111
+ end
112
+
113
+ schema.functions.first.types.first.tap do |x|
114
+ expect(x).to be_instance_of(Expressir::Model::Type)
115
+ expect(x.remarks).to be_instance_of(Array)
116
+ expect(x.remarks.count).to eq(3)
117
+ expect(x.remarks[0]).to eq("function scope - function type")
118
+ expect(x.remarks[1]).to eq("schema scope - function type")
119
+ expect(x.remarks[2]).to eq("universal scope - function type")
120
+ end
121
+
122
+ schema.functions.first.constants.first.tap do |x|
123
+ expect(x).to be_instance_of(Expressir::Model::Constant)
124
+ expect(x.remarks).to be_instance_of(Array)
125
+ expect(x.remarks.count).to eq(3)
126
+ expect(x.remarks[0]).to eq("function scope - function constant")
127
+ expect(x.remarks[1]).to eq("schema scope - function constant")
128
+ expect(x.remarks[2]).to eq("universal scope - function constant")
129
+ end
130
+
131
+ schema.functions.first.locals.first.tap do |x|
132
+ expect(x).to be_instance_of(Expressir::Model::Local)
133
+ expect(x.remarks).to be_instance_of(Array)
134
+ expect(x.remarks.count).to eq(3)
135
+ expect(x.remarks[0]).to eq("function scope - function local")
136
+ expect(x.remarks[1]).to eq("schema scope - function local")
137
+ expect(x.remarks[2]).to eq("universal scope - function local")
138
+ end
139
+
140
+ schema.functions.first.statements[0].tap do |x|
141
+ expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
142
+ expect(x.remarks).to be_instance_of(Array)
143
+ expect(x.remarks.count).to eq(1)
144
+ expect(x.remarks[0]).to eq("function alias scope - function alias")
145
+ end
146
+
147
+ schema.functions.first.statements[1].tap do |x|
148
+ expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
149
+ expect(x.remarks).to be_instance_of(Array)
150
+ expect(x.remarks.count).to eq(1)
151
+ expect(x.remarks[0]).to eq("function repeat scope - function repeat")
152
+ end
153
+
154
+ schema.functions.first.statements[2].tap do |x|
155
+ expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
156
+ expect(x.expression).to be_instance_of(Expressir::Model::Expressions::Query)
157
+ expect(x.expression.remarks).to be_instance_of(Array)
158
+ expect(x.expression.remarks.count).to eq(1)
159
+ expect(x.expression.remarks[0]).to eq("function query scope - function query")
160
+ end
161
+
162
+ schema.procedures.first.tap do |x|
163
+ expect(x).to be_instance_of(Expressir::Model::Procedure)
164
+ expect(x.remarks).to be_instance_of(Array)
165
+ expect(x.remarks.count).to eq(2)
166
+ expect(x.remarks[0]).to eq("schema scope - procedure")
167
+ expect(x.remarks[1]).to eq("universal scope - procedure")
168
+ end
169
+
170
+ schema.procedures.first.parameters.first.tap do |x|
171
+ expect(x).to be_instance_of(Expressir::Model::Parameter)
172
+ expect(x.remarks).to be_instance_of(Array)
173
+ expect(x.remarks.count).to eq(3)
174
+ expect(x.remarks[0]).to eq("procedure scope - procedure parameter")
175
+ expect(x.remarks[1]).to eq("schema scope - procedure parameter")
176
+ expect(x.remarks[2]).to eq("universal scope - procedure parameter")
177
+ end
178
+
179
+ schema.procedures.first.types.first.tap do |x|
180
+ expect(x).to be_instance_of(Expressir::Model::Type)
181
+ expect(x.remarks).to be_instance_of(Array)
182
+ expect(x.remarks.count).to eq(3)
183
+ expect(x.remarks[0]).to eq("procedure scope - procedure type")
184
+ expect(x.remarks[1]).to eq("schema scope - procedure type")
185
+ expect(x.remarks[2]).to eq("universal scope - procedure type")
186
+ end
187
+
188
+ schema.procedures.first.constants.first.tap do |x|
189
+ expect(x).to be_instance_of(Expressir::Model::Constant)
190
+ expect(x.remarks).to be_instance_of(Array)
191
+ expect(x.remarks.count).to eq(3)
192
+ expect(x.remarks[0]).to eq("procedure scope - procedure constant")
193
+ expect(x.remarks[1]).to eq("schema scope - procedure constant")
194
+ expect(x.remarks[2]).to eq("universal scope - procedure constant")
195
+ end
196
+
197
+ schema.procedures.first.locals.first.tap do |x|
198
+ expect(x).to be_instance_of(Expressir::Model::Local)
199
+ expect(x.remarks).to be_instance_of(Array)
200
+ expect(x.remarks.count).to eq(3)
201
+ expect(x.remarks[0]).to eq("procedure scope - procedure local")
202
+ expect(x.remarks[1]).to eq("schema scope - procedure local")
203
+ expect(x.remarks[2]).to eq("universal scope - procedure local")
204
+ end
205
+
206
+ schema.procedures.first.statements[0].tap do |x|
207
+ expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
208
+ expect(x.remarks).to be_instance_of(Array)
209
+ expect(x.remarks.count).to eq(1)
210
+ expect(x.remarks[0]).to eq("procedure alias scope - procedure alias")
211
+ end
212
+
213
+ schema.procedures.first.statements[1].tap do |x|
214
+ expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
215
+ expect(x.remarks).to be_instance_of(Array)
216
+ expect(x.remarks.count).to eq(1)
217
+ expect(x.remarks[0]).to eq("procedure repeat scope - procedure repeat")
218
+ end
219
+
220
+ schema.procedures.first.statements[2].tap do |x|
221
+ expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
222
+ expect(x.expression).to be_instance_of(Expressir::Model::Expressions::Query)
223
+ expect(x.expression.remarks).to be_instance_of(Array)
224
+ expect(x.expression.remarks.count).to eq(1)
225
+ expect(x.expression.remarks[0]).to eq("procedure query scope - procedure query")
226
+ end
227
+
228
+ schema.rules.first.tap do |x|
229
+ expect(x).to be_instance_of(Expressir::Model::Rule)
230
+ expect(x.remarks).to be_instance_of(Array)
231
+ expect(x.remarks.count).to eq(2)
232
+ expect(x.remarks[0]).to eq("schema scope - rule")
233
+ expect(x.remarks[1]).to eq("universal scope - rule")
234
+ end
235
+
236
+ schema.rules.first.types.first.tap do |x|
237
+ expect(x).to be_instance_of(Expressir::Model::Type)
238
+ expect(x.remarks).to be_instance_of(Array)
239
+ expect(x.remarks.count).to eq(3)
240
+ expect(x.remarks[0]).to eq("rule scope - rule type")
241
+ expect(x.remarks[1]).to eq("schema scope - rule type")
242
+ expect(x.remarks[2]).to eq("universal scope - rule type")
243
+ end
244
+
245
+ schema.rules.first.constants.first.tap do |x|
246
+ expect(x).to be_instance_of(Expressir::Model::Constant)
247
+ expect(x.remarks).to be_instance_of(Array)
248
+ expect(x.remarks.count).to eq(3)
249
+ expect(x.remarks[0]).to eq("rule scope - rule constant")
250
+ expect(x.remarks[1]).to eq("schema scope - rule constant")
251
+ expect(x.remarks[2]).to eq("universal scope - rule constant")
252
+ end
253
+
254
+ schema.rules.first.locals.first.tap do |x|
255
+ expect(x).to be_instance_of(Expressir::Model::Local)
256
+ expect(x.remarks).to be_instance_of(Array)
257
+ expect(x.remarks.count).to eq(3)
258
+ expect(x.remarks[0]).to eq("rule scope - rule local")
259
+ expect(x.remarks[1]).to eq("schema scope - rule local")
260
+ expect(x.remarks[2]).to eq("universal scope - rule local")
261
+ end
262
+
263
+ schema.rules.first.statements[0].tap do |x|
264
+ expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
265
+ expect(x.remarks).to be_instance_of(Array)
266
+ expect(x.remarks.count).to eq(1)
267
+ expect(x.remarks[0]).to eq("rule alias scope - rule alias")
268
+ end
269
+
270
+ schema.rules.first.statements[1].tap do |x|
271
+ expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
272
+ expect(x.remarks).to be_instance_of(Array)
273
+ expect(x.remarks.count).to eq(1)
274
+ expect(x.remarks[0]).to eq("rule repeat scope - rule repeat")
275
+ end
276
+
277
+ schema.rules.first.statements[2].tap do |x|
278
+ expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
279
+ expect(x.expression).to be_instance_of(Expressir::Model::Expressions::Query)
280
+ expect(x.expression.remarks).to be_instance_of(Array)
281
+ expect(x.expression.remarks.count).to eq(1)
282
+ expect(x.expression.remarks[0]).to eq("rule query scope - rule query")
283
+ end
284
+
285
+ schema.rules.first.where.first.tap do |x|
286
+ expect(x).to be_instance_of(Expressir::Model::Where)
287
+ expect(x.remarks).to be_instance_of(Array)
288
+ expect(x.remarks.count).to eq(3)
289
+ expect(x.remarks[0]).to eq("rule scope - rule where")
290
+ expect(x.remarks[1]).to eq("schema scope - rule where")
291
+ expect(x.remarks[2]).to eq("universal scope - rule where")
292
+ end
293
+ end
294
+ end
295
+
296
+ def sample_file
297
+ @sample_file ||= Expressir.root_path.join(
298
+ "original", "examples", "syntax", "remark.exp"
299
+ )
300
+ end
301
+ end
@@ -1,5 +1,5 @@
1
1
  require "spec_helper"
2
- require_relative "../../../lib/expressir/express_exp/parser"
2
+ require "expressir/express_exp/parser"
3
3
 
4
4
  RSpec.describe Expressir::ExpressExp::Parser do
5
5
  describe ".from_file" do
@@ -9,7 +9,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
9
9
  schemas = repo.schemas
10
10
 
11
11
  schema = schemas.find{|x| x.id == "syntaxSchema"}
12
- expect(schema.version).to eq("version")
12
+ expect(schema.version).to be_instance_of(Expressir::Model::Literals::String)
13
+ expect(schema.version.value).to eq("version")
13
14
 
14
15
  interfaces = schema.interfaces
15
16
  constants = schema.constants
@@ -67,35 +68,44 @@ RSpec.describe Expressir::ExpressExp::Parser do
67
68
 
68
69
  # literals
69
70
  constants.find{|x| x.id == "binaryExpression"}.expression.tap do |x|
70
- expect(x).to eq("xxx")
71
+ expect(x).to be_instance_of(Expressir::Model::Literals::Binary)
72
+ expect(x.value).to eq("011110000111100001111000")
71
73
  end
72
74
 
73
75
  constants.find{|x| x.id == "integerExpression"}.expression.tap do |x|
74
- expect(x).to eq(999)
76
+ expect(x).to be_instance_of(Expressir::Model::Literals::Integer)
77
+ expect(x.value).to eq("999")
75
78
  end
76
79
 
77
- constants.find{|x| x.id == "logicalTrueExpression"}.expression.tap do |x|
78
- expect(x).to eq(true)
80
+ constants.find{|x| x.id == "trueLogicalExpression"}.expression.tap do |x|
81
+ expect(x).to be_instance_of(Expressir::Model::Literals::Logical)
82
+ expect(x.value).to eq(true)
79
83
  end
80
84
 
81
- constants.find{|x| x.id == "logicalFalseExpression"}.expression.tap do |x|
82
- expect(x).to eq(false)
85
+ constants.find{|x| x.id == "falseLogicalExpression"}.expression.tap do |x|
86
+ expect(x).to be_instance_of(Expressir::Model::Literals::Logical)
87
+ expect(x.value).to eq(false)
83
88
  end
84
89
 
85
- constants.find{|x| x.id == "logicalUnknownExpression"}.expression.tap do |x|
86
- expect(x).to be_instance_of(Expressir::Model::Expressions::Unknown)
90
+ constants.find{|x| x.id == "unknownLogicalExpression"}.expression.tap do |x|
91
+ expect(x).to be_instance_of(Expressir::Model::Literals::Logical)
92
+ expect(x.value).to eq(nil)
87
93
  end
88
94
 
89
95
  constants.find{|x| x.id == "realExpression"}.expression.tap do |x|
90
- expect(x).to eq(999.999)
96
+ expect(x).to be_instance_of(Expressir::Model::Literals::Real)
97
+ expect(x.value).to eq("999.999")
91
98
  end
92
99
 
93
- constants.find{|x| x.id == "stringSimpleExpression"}.expression.tap do |x|
94
- expect(x).to eq("xxx")
100
+ constants.find{|x| x.id == "simpleStringExpression"}.expression.tap do |x|
101
+ expect(x).to be_instance_of(Expressir::Model::Literals::String)
102
+ expect(x.value).to eq("xxx")
95
103
  end
96
104
 
97
- constants.find{|x| x.id == "stringEncodedExpression"}.expression.tap do |x|
98
- expect(x).to eq("xxx")
105
+ constants.find{|x| x.id == "encodedStringExpression"}.expression.tap do |x|
106
+ expect(x).to be_instance_of(Expressir::Model::Literals::String)
107
+ expect(x.value).to eq("000000780000007800000078")
108
+ expect(x.encoded).to eq(true)
99
109
  end
100
110
 
101
111
  # constants
@@ -126,7 +136,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
126
136
  expect(x.function.id).to eq("ABS")
127
137
  expect(x.parameters).to be_instance_of(Array)
128
138
  expect(x.parameters.count).to eq(1)
129
- expect(x.parameters[0]).to eq(true)
139
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
140
+ expect(x.parameters[0].value).to eq(true)
130
141
  end
131
142
 
132
143
  constants.find{|x| x.id == "acosExpression"}.expression.tap do |x|
@@ -135,7 +146,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
135
146
  expect(x.function.id).to eq("ACOS")
136
147
  expect(x.parameters).to be_instance_of(Array)
137
148
  expect(x.parameters.count).to eq(1)
138
- expect(x.parameters[0]).to eq(true)
149
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
150
+ expect(x.parameters[0].value).to eq(true)
139
151
  end
140
152
 
141
153
  constants.find{|x| x.id == "asinExpression"}.expression.tap do |x|
@@ -144,7 +156,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
144
156
  expect(x.function.id).to eq("ASIN")
145
157
  expect(x.parameters).to be_instance_of(Array)
146
158
  expect(x.parameters.count).to eq(1)
147
- expect(x.parameters[0]).to eq(true)
159
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
160
+ expect(x.parameters[0].value).to eq(true)
148
161
  end
149
162
 
150
163
  constants.find{|x| x.id == "atanExpression"}.expression.tap do |x|
@@ -153,7 +166,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
153
166
  expect(x.function.id).to eq("ATAN")
154
167
  expect(x.parameters).to be_instance_of(Array)
155
168
  expect(x.parameters.count).to eq(1)
156
- expect(x.parameters[0]).to eq(true)
169
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
170
+ expect(x.parameters[0].value).to eq(true)
157
171
  end
158
172
 
159
173
  constants.find{|x| x.id == "blengthExpression"}.expression.tap do |x|
@@ -162,7 +176,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
162
176
  expect(x.function.id).to eq("BLENGTH")
163
177
  expect(x.parameters).to be_instance_of(Array)
164
178
  expect(x.parameters.count).to eq(1)
165
- expect(x.parameters[0]).to eq(true)
179
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
180
+ expect(x.parameters[0].value).to eq(true)
166
181
  end
167
182
 
168
183
  constants.find{|x| x.id == "cosExpression"}.expression.tap do |x|
@@ -171,7 +186,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
171
186
  expect(x.function.id).to eq("COS")
172
187
  expect(x.parameters).to be_instance_of(Array)
173
188
  expect(x.parameters.count).to eq(1)
174
- expect(x.parameters[0]).to eq(true)
189
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
190
+ expect(x.parameters[0].value).to eq(true)
175
191
  end
176
192
 
177
193
  constants.find{|x| x.id == "existsExpression"}.expression.tap do |x|
@@ -180,7 +196,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
180
196
  expect(x.function.id).to eq("EXISTS")
181
197
  expect(x.parameters).to be_instance_of(Array)
182
198
  expect(x.parameters.count).to eq(1)
183
- expect(x.parameters[0]).to eq(true)
199
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
200
+ expect(x.parameters[0].value).to eq(true)
184
201
  end
185
202
 
186
203
  constants.find{|x| x.id == "expExpression"}.expression.tap do |x|
@@ -189,7 +206,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
189
206
  expect(x.function.id).to eq("EXP")
190
207
  expect(x.parameters).to be_instance_of(Array)
191
208
  expect(x.parameters.count).to eq(1)
192
- expect(x.parameters[0]).to eq(true)
209
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
210
+ expect(x.parameters[0].value).to eq(true)
193
211
  end
194
212
 
195
213
  constants.find{|x| x.id == "formatExpression"}.expression.tap do |x|
@@ -198,7 +216,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
198
216
  expect(x.function.id).to eq("FORMAT")
199
217
  expect(x.parameters).to be_instance_of(Array)
200
218
  expect(x.parameters.count).to eq(1)
201
- expect(x.parameters[0]).to eq(true)
219
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
220
+ expect(x.parameters[0].value).to eq(true)
202
221
  end
203
222
 
204
223
  constants.find{|x| x.id == "hiboundExpression"}.expression.tap do |x|
@@ -207,7 +226,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
207
226
  expect(x.function.id).to eq("HIBOUND")
208
227
  expect(x.parameters).to be_instance_of(Array)
209
228
  expect(x.parameters.count).to eq(1)
210
- expect(x.parameters[0]).to eq(true)
229
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
230
+ expect(x.parameters[0].value).to eq(true)
211
231
  end
212
232
 
213
233
  constants.find{|x| x.id == "hiindexExpression"}.expression.tap do |x|
@@ -216,7 +236,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
216
236
  expect(x.function.id).to eq("HIINDEX")
217
237
  expect(x.parameters).to be_instance_of(Array)
218
238
  expect(x.parameters.count).to eq(1)
219
- expect(x.parameters[0]).to eq(true)
239
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
240
+ expect(x.parameters[0].value).to eq(true)
220
241
  end
221
242
 
222
243
  constants.find{|x| x.id == "lengthExpression"}.expression.tap do |x|
@@ -225,7 +246,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
225
246
  expect(x.function.id).to eq("LENGTH")
226
247
  expect(x.parameters).to be_instance_of(Array)
227
248
  expect(x.parameters.count).to eq(1)
228
- expect(x.parameters[0]).to eq(true)
249
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
250
+ expect(x.parameters[0].value).to eq(true)
229
251
  end
230
252
 
231
253
  constants.find{|x| x.id == "loboundExpression"}.expression.tap do |x|
@@ -234,7 +256,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
234
256
  expect(x.function.id).to eq("LOBOUND")
235
257
  expect(x.parameters).to be_instance_of(Array)
236
258
  expect(x.parameters.count).to eq(1)
237
- expect(x.parameters[0]).to eq(true)
259
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
260
+ expect(x.parameters[0].value).to eq(true)
238
261
  end
239
262
 
240
263
  constants.find{|x| x.id == "loindexExpression"}.expression.tap do |x|
@@ -243,7 +266,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
243
266
  expect(x.function.id).to eq("LOINDEX")
244
267
  expect(x.parameters).to be_instance_of(Array)
245
268
  expect(x.parameters.count).to eq(1)
246
- expect(x.parameters[0]).to eq(true)
269
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
270
+ expect(x.parameters[0].value).to eq(true)
247
271
  end
248
272
 
249
273
  constants.find{|x| x.id == "logExpression"}.expression.tap do |x|
@@ -252,7 +276,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
252
276
  expect(x.function.id).to eq("LOG")
253
277
  expect(x.parameters).to be_instance_of(Array)
254
278
  expect(x.parameters.count).to eq(1)
255
- expect(x.parameters[0]).to eq(true)
279
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
280
+ expect(x.parameters[0].value).to eq(true)
256
281
  end
257
282
 
258
283
  constants.find{|x| x.id == "log2Expression"}.expression.tap do |x|
@@ -261,7 +286,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
261
286
  expect(x.function.id).to eq("LOG2")
262
287
  expect(x.parameters).to be_instance_of(Array)
263
288
  expect(x.parameters.count).to eq(1)
264
- expect(x.parameters[0]).to eq(true)
289
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
290
+ expect(x.parameters[0].value).to eq(true)
265
291
  end
266
292
 
267
293
  constants.find{|x| x.id == "log10Expression"}.expression.tap do |x|
@@ -270,7 +296,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
270
296
  expect(x.function.id).to eq("LOG10")
271
297
  expect(x.parameters).to be_instance_of(Array)
272
298
  expect(x.parameters.count).to eq(1)
273
- expect(x.parameters[0]).to eq(true)
299
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
300
+ expect(x.parameters[0].value).to eq(true)
274
301
  end
275
302
 
276
303
  constants.find{|x| x.id == "nvlExpression"}.expression.tap do |x|
@@ -279,7 +306,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
279
306
  expect(x.function.id).to eq("NVL")
280
307
  expect(x.parameters).to be_instance_of(Array)
281
308
  expect(x.parameters.count).to eq(1)
282
- expect(x.parameters[0]).to eq(true)
309
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
310
+ expect(x.parameters[0].value).to eq(true)
283
311
  end
284
312
 
285
313
  constants.find{|x| x.id == "oddExpression"}.expression.tap do |x|
@@ -288,7 +316,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
288
316
  expect(x.function.id).to eq("ODD")
289
317
  expect(x.parameters).to be_instance_of(Array)
290
318
  expect(x.parameters.count).to eq(1)
291
- expect(x.parameters[0]).to eq(true)
319
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
320
+ expect(x.parameters[0].value).to eq(true)
292
321
  end
293
322
 
294
323
  constants.find{|x| x.id == "rolesofExpression"}.expression.tap do |x|
@@ -297,7 +326,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
297
326
  expect(x.function.id).to eq("ROLESOF")
298
327
  expect(x.parameters).to be_instance_of(Array)
299
328
  expect(x.parameters.count).to eq(1)
300
- expect(x.parameters[0]).to eq(true)
329
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
330
+ expect(x.parameters[0].value).to eq(true)
301
331
  end
302
332
 
303
333
  constants.find{|x| x.id == "sinExpression"}.expression.tap do |x|
@@ -306,7 +336,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
306
336
  expect(x.function.id).to eq("SIN")
307
337
  expect(x.parameters).to be_instance_of(Array)
308
338
  expect(x.parameters.count).to eq(1)
309
- expect(x.parameters[0]).to eq(true)
339
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
340
+ expect(x.parameters[0].value).to eq(true)
310
341
  end
311
342
 
312
343
  constants.find{|x| x.id == "sizeofExpression"}.expression.tap do |x|
@@ -315,7 +346,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
315
346
  expect(x.function.id).to eq("SIZEOF")
316
347
  expect(x.parameters).to be_instance_of(Array)
317
348
  expect(x.parameters.count).to eq(1)
318
- expect(x.parameters[0]).to eq(true)
349
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
350
+ expect(x.parameters[0].value).to eq(true)
319
351
  end
320
352
 
321
353
  constants.find{|x| x.id == "sqrtExpression"}.expression.tap do |x|
@@ -324,7 +356,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
324
356
  expect(x.function.id).to eq("SQRT")
325
357
  expect(x.parameters).to be_instance_of(Array)
326
358
  expect(x.parameters.count).to eq(1)
327
- expect(x.parameters[0]).to eq(true)
359
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
360
+ expect(x.parameters[0].value).to eq(true)
328
361
  end
329
362
 
330
363
  constants.find{|x| x.id == "tanExpression"}.expression.tap do |x|
@@ -333,7 +366,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
333
366
  expect(x.function.id).to eq("TAN")
334
367
  expect(x.parameters).to be_instance_of(Array)
335
368
  expect(x.parameters.count).to eq(1)
336
- expect(x.parameters[0]).to eq(true)
369
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
370
+ expect(x.parameters[0].value).to eq(true)
337
371
  end
338
372
 
339
373
  constants.find{|x| x.id == "typeofExpression"}.expression.tap do |x|
@@ -342,7 +376,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
342
376
  expect(x.function.id).to eq("TYPEOF")
343
377
  expect(x.parameters).to be_instance_of(Array)
344
378
  expect(x.parameters.count).to eq(1)
345
- expect(x.parameters[0]).to eq(true)
379
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
380
+ expect(x.parameters[0].value).to eq(true)
346
381
  end
347
382
 
348
383
  constants.find{|x| x.id == "usedinExpression"}.expression.tap do |x|
@@ -351,7 +386,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
351
386
  expect(x.function.id).to eq("USEDIN")
352
387
  expect(x.parameters).to be_instance_of(Array)
353
388
  expect(x.parameters.count).to eq(1)
354
- expect(x.parameters[0]).to eq(true)
389
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
390
+ expect(x.parameters[0].value).to eq(true)
355
391
  end
356
392
 
357
393
  constants.find{|x| x.id == "valueExpression"}.expression.tap do |x|
@@ -360,7 +396,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
360
396
  expect(x.function.id).to eq("VALUE")
361
397
  expect(x.parameters).to be_instance_of(Array)
362
398
  expect(x.parameters.count).to eq(1)
363
- expect(x.parameters[0]).to eq(true)
399
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
400
+ expect(x.parameters[0].value).to eq(true)
364
401
  end
365
402
 
366
403
  constants.find{|x| x.id == "valueInExpression"}.expression.tap do |x|
@@ -369,7 +406,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
369
406
  expect(x.function.id).to eq("VALUE_IN")
370
407
  expect(x.parameters).to be_instance_of(Array)
371
408
  expect(x.parameters.count).to eq(1)
372
- expect(x.parameters[0]).to eq(true)
409
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
410
+ expect(x.parameters[0].value).to eq(true)
373
411
  end
374
412
 
375
413
  constants.find{|x| x.id == "valueUniqueExpression"}.expression.tap do |x|
@@ -378,7 +416,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
378
416
  expect(x.function.id).to eq("VALUE_UNIQUE")
379
417
  expect(x.parameters).to be_instance_of(Array)
380
418
  expect(x.parameters.count).to eq(1)
381
- expect(x.parameters[0]).to eq(true)
419
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
420
+ expect(x.parameters[0].value).to eq(true)
382
421
  end
383
422
 
384
423
  # operations
@@ -387,7 +426,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
387
426
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::UnaryPlus)
388
427
  expect(x.operands).to be_instance_of(Array)
389
428
  expect(x.operands.count).to eq(1)
390
- expect(x.operands[0]).to eq(4)
429
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
430
+ expect(x.operands[0].value).to eq("4")
391
431
  end
392
432
 
393
433
  constants.find{|x| x.id == "unaryMinusExpression"}.expression.tap do |x|
@@ -395,7 +435,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
395
435
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::UnaryMinus)
396
436
  expect(x.operands).to be_instance_of(Array)
397
437
  expect(x.operands.count).to eq(1)
398
- expect(x.operands[0]).to eq(4)
438
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
439
+ expect(x.operands[0].value).to eq("4")
399
440
  end
400
441
 
401
442
  constants.find{|x| x.id == "additionExpression"}.expression.tap do |x|
@@ -403,8 +444,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
403
444
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::Addition)
404
445
  expect(x.operands).to be_instance_of(Array)
405
446
  expect(x.operands.count).to eq(2)
406
- expect(x.operands[0]).to eq(4)
407
- expect(x.operands[1]).to eq(2)
447
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
448
+ expect(x.operands[0].value).to eq("4")
449
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
450
+ expect(x.operands[1].value).to eq("2")
408
451
  end
409
452
 
410
453
  constants.find{|x| x.id == "subtractionExpression"}.expression.tap do |x|
@@ -412,8 +455,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
412
455
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::Subtraction)
413
456
  expect(x.operands).to be_instance_of(Array)
414
457
  expect(x.operands.count).to eq(2)
415
- expect(x.operands[0]).to eq(4)
416
- expect(x.operands[1]).to eq(2)
458
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
459
+ expect(x.operands[0].value).to eq("4")
460
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
461
+ expect(x.operands[1].value).to eq("2")
417
462
  end
418
463
 
419
464
  constants.find{|x| x.id == "multiplicationExpression"}.expression.tap do |x|
@@ -421,8 +466,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
421
466
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
422
467
  expect(x.operands).to be_instance_of(Array)
423
468
  expect(x.operands.count).to eq(2)
424
- expect(x.operands[0]).to eq(4)
425
- expect(x.operands[1]).to eq(2)
469
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
470
+ expect(x.operands[0].value).to eq("4")
471
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
472
+ expect(x.operands[1].value).to eq("2")
426
473
  end
427
474
 
428
475
  constants.find{|x| x.id == "realDivisionExpression"}.expression.tap do |x|
@@ -430,8 +477,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
430
477
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::RealDivision)
431
478
  expect(x.operands).to be_instance_of(Array)
432
479
  expect(x.operands.count).to eq(2)
433
- expect(x.operands[0]).to eq(4)
434
- expect(x.operands[1]).to eq(2)
480
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
481
+ expect(x.operands[0].value).to eq("4")
482
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
483
+ expect(x.operands[1].value).to eq("2")
435
484
  end
436
485
 
437
486
  constants.find{|x| x.id == "integerDivisionExpression"}.expression.tap do |x|
@@ -439,8 +488,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
439
488
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::IntegerDivision)
440
489
  expect(x.operands).to be_instance_of(Array)
441
490
  expect(x.operands.count).to eq(2)
442
- expect(x.operands[0]).to eq(4)
443
- expect(x.operands[1]).to eq(2)
491
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
492
+ expect(x.operands[0].value).to eq("4")
493
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
494
+ expect(x.operands[1].value).to eq("2")
444
495
  end
445
496
 
446
497
  constants.find{|x| x.id == "moduloExpression"}.expression.tap do |x|
@@ -448,8 +499,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
448
499
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::Modulo)
449
500
  expect(x.operands).to be_instance_of(Array)
450
501
  expect(x.operands.count).to eq(2)
451
- expect(x.operands[0]).to eq(4)
452
- expect(x.operands[1]).to eq(2)
502
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
503
+ expect(x.operands[0].value).to eq("4")
504
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
505
+ expect(x.operands[1].value).to eq("2")
453
506
  end
454
507
 
455
508
  constants.find{|x| x.id == "exponentiationExpression"}.expression.tap do |x|
@@ -457,8 +510,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
457
510
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::Exponentiation)
458
511
  expect(x.operands).to be_instance_of(Array)
459
512
  expect(x.operands.count).to eq(2)
460
- expect(x.operands[0]).to eq(4)
461
- expect(x.operands[1]).to eq(2)
513
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
514
+ expect(x.operands[0].value).to eq("4")
515
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
516
+ expect(x.operands[1].value).to eq("2")
462
517
  end
463
518
 
464
519
  constants.find{|x| x.id == "additionAdditionExpression"}.expression.tap do |x|
@@ -470,9 +525,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
470
525
  expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
471
526
  expect(x.operands[0].operands).to be_instance_of(Array)
472
527
  expect(x.operands[0].operands.count).to eq(2)
473
- expect(x.operands[0].operands[0]).to eq(4)
474
- expect(x.operands[0].operands[1]).to eq(2)
475
- expect(x.operands[1]).to eq(1)
528
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
529
+ expect(x.operands[0].operands[0].value).to eq("4")
530
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
531
+ expect(x.operands[0].operands[1].value).to eq("2")
532
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
533
+ expect(x.operands[1].value).to eq("1")
476
534
  end
477
535
 
478
536
  constants.find{|x| x.id == "subtractionSubtractionExpression"}.expression.tap do |x|
@@ -484,9 +542,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
484
542
  expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Subtraction)
485
543
  expect(x.operands[0].operands).to be_instance_of(Array)
486
544
  expect(x.operands[0].operands.count).to eq(2)
487
- expect(x.operands[0].operands[0]).to eq(4)
488
- expect(x.operands[0].operands[1]).to eq(2)
489
- expect(x.operands[1]).to eq(1)
545
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
546
+ expect(x.operands[0].operands[0].value).to eq("4")
547
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
548
+ expect(x.operands[0].operands[1].value).to eq("2")
549
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
550
+ expect(x.operands[1].value).to eq("1")
490
551
  end
491
552
 
492
553
  constants.find{|x| x.id == "additionSubtractionExpression"}.expression.tap do |x|
@@ -498,9 +559,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
498
559
  expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
499
560
  expect(x.operands[0].operands).to be_instance_of(Array)
500
561
  expect(x.operands[0].operands.count).to eq(2)
501
- expect(x.operands[0].operands[0]).to eq(4)
502
- expect(x.operands[0].operands[1]).to eq(2)
503
- expect(x.operands[1]).to eq(1)
562
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
563
+ expect(x.operands[0].operands[0].value).to eq("4")
564
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
565
+ expect(x.operands[0].operands[1].value).to eq("2")
566
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
567
+ expect(x.operands[1].value).to eq("1")
504
568
  end
505
569
 
506
570
  constants.find{|x| x.id == "subtractionAdditionExpression"}.expression.tap do |x|
@@ -512,9 +576,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
512
576
  expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Subtraction)
513
577
  expect(x.operands[0].operands).to be_instance_of(Array)
514
578
  expect(x.operands[0].operands.count).to eq(2)
515
- expect(x.operands[0].operands[0]).to eq(4)
516
- expect(x.operands[0].operands[1]).to eq(2)
517
- expect(x.operands[1]).to eq(1)
579
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
580
+ expect(x.operands[0].operands[0].value).to eq("4")
581
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
582
+ expect(x.operands[0].operands[1].value).to eq("2")
583
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
584
+ expect(x.operands[1].value).to eq("1")
518
585
  end
519
586
 
520
587
  constants.find{|x| x.id == "additionMultiplicationExpression"}.expression.tap do |x|
@@ -522,13 +589,16 @@ RSpec.describe Expressir::ExpressExp::Parser do
522
589
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::Addition)
523
590
  expect(x.operands).to be_instance_of(Array)
524
591
  expect(x.operands.count).to eq(2)
525
- expect(x.operands[0]).to eq(8)
592
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
593
+ expect(x.operands[0].value).to eq("8")
526
594
  expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
527
595
  expect(x.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
528
596
  expect(x.operands[1].operands).to be_instance_of(Array)
529
597
  expect(x.operands[1].operands.count).to eq(2)
530
- expect(x.operands[1].operands[0]).to eq(4)
531
- expect(x.operands[1].operands[1]).to eq(2)
598
+ expect(x.operands[1].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
599
+ expect(x.operands[1].operands[0].value).to eq("4")
600
+ expect(x.operands[1].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
601
+ expect(x.operands[1].operands[1].value).to eq("2")
532
602
  end
533
603
 
534
604
  constants.find{|x| x.id == "multiplicationAdditionExpression"}.expression.tap do |x|
@@ -540,9 +610,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
540
610
  expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
541
611
  expect(x.operands[0].operands).to be_instance_of(Array)
542
612
  expect(x.operands[0].operands.count).to eq(2)
543
- expect(x.operands[0].operands[0]).to eq(8)
544
- expect(x.operands[0].operands[1]).to eq(4)
545
- expect(x.operands[1]).to eq(2)
613
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
614
+ expect(x.operands[0].operands[0].value).to eq("8")
615
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
616
+ expect(x.operands[0].operands[1].value).to eq("4")
617
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
618
+ expect(x.operands[1].value).to eq("2")
546
619
  end
547
620
 
548
621
  constants.find{|x| x.id == "parenthesisAdditionMultiplicationExpression"}.expression.tap do |x|
@@ -554,9 +627,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
554
627
  expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
555
628
  expect(x.operands[0].operands).to be_instance_of(Array)
556
629
  expect(x.operands[0].operands.count).to eq(2)
557
- expect(x.operands[0].operands[0]).to eq(8)
558
- expect(x.operands[0].operands[1]).to eq(4)
559
- expect(x.operands[1]).to eq(2)
630
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
631
+ expect(x.operands[0].operands[0].value).to eq("8")
632
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
633
+ expect(x.operands[0].operands[1].value).to eq("4")
634
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
635
+ expect(x.operands[1].value).to eq("2")
560
636
  end
561
637
 
562
638
  constants.find{|x| x.id == "multiplicationParenthesisAdditionExpression"}.expression.tap do |x|
@@ -564,13 +640,16 @@ RSpec.describe Expressir::ExpressExp::Parser do
564
640
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
565
641
  expect(x.operands).to be_instance_of(Array)
566
642
  expect(x.operands.count).to eq(2)
567
- expect(x.operands[0]).to eq(8)
643
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
644
+ expect(x.operands[0].value).to eq("8")
568
645
  expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
569
646
  expect(x.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Addition)
570
647
  expect(x.operands[1].operands).to be_instance_of(Array)
571
648
  expect(x.operands[1].operands.count).to eq(2)
572
- expect(x.operands[1].operands[0]).to eq(4)
573
- expect(x.operands[1].operands[1]).to eq(2)
649
+ expect(x.operands[1].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
650
+ expect(x.operands[1].operands[0].value).to eq("4")
651
+ expect(x.operands[1].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
652
+ expect(x.operands[1].operands[1].value).to eq("2")
574
653
  end
575
654
 
576
655
  constants.find{|x| x.id == "equalExpression"}.expression.tap do |x|
@@ -578,8 +657,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
578
657
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::Equal)
579
658
  expect(x.operands).to be_instance_of(Array)
580
659
  expect(x.operands.count).to eq(2)
581
- expect(x.operands[0]).to eq(4)
582
- expect(x.operands[1]).to eq(2)
660
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
661
+ expect(x.operands[0].value).to eq("4")
662
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
663
+ expect(x.operands[1].value).to eq("2")
583
664
  end
584
665
 
585
666
  constants.find{|x| x.id == "notEqualExpression"}.expression.tap do |x|
@@ -587,8 +668,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
587
668
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::NotEqual)
588
669
  expect(x.operands).to be_instance_of(Array)
589
670
  expect(x.operands.count).to eq(2)
590
- expect(x.operands[0]).to eq(4)
591
- expect(x.operands[1]).to eq(2)
671
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
672
+ expect(x.operands[0].value).to eq("4")
673
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
674
+ expect(x.operands[1].value).to eq("2")
592
675
  end
593
676
 
594
677
  constants.find{|x| x.id == "ltExpression"}.expression.tap do |x|
@@ -596,8 +679,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
596
679
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::LessThan)
597
680
  expect(x.operands).to be_instance_of(Array)
598
681
  expect(x.operands.count).to eq(2)
599
- expect(x.operands[0]).to eq(4)
600
- expect(x.operands[1]).to eq(2)
682
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
683
+ expect(x.operands[0].value).to eq("4")
684
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
685
+ expect(x.operands[1].value).to eq("2")
601
686
  end
602
687
 
603
688
  constants.find{|x| x.id == "gtExpression"}.expression.tap do |x|
@@ -605,8 +690,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
605
690
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::GreaterThan)
606
691
  expect(x.operands).to be_instance_of(Array)
607
692
  expect(x.operands.count).to eq(2)
608
- expect(x.operands[0]).to eq(4)
609
- expect(x.operands[1]).to eq(2)
693
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
694
+ expect(x.operands[0].value).to eq("4")
695
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
696
+ expect(x.operands[1].value).to eq("2")
610
697
  end
611
698
 
612
699
  constants.find{|x| x.id == "lteExpression"}.expression.tap do |x|
@@ -614,8 +701,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
614
701
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
615
702
  expect(x.operands).to be_instance_of(Array)
616
703
  expect(x.operands.count).to eq(2)
617
- expect(x.operands[0]).to eq(4)
618
- expect(x.operands[1]).to eq(2)
704
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
705
+ expect(x.operands[0].value).to eq("4")
706
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
707
+ expect(x.operands[1].value).to eq("2")
619
708
  end
620
709
 
621
710
  constants.find{|x| x.id == "gteExpression"}.expression.tap do |x|
@@ -623,8 +712,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
623
712
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::GreaterThanOrEqual)
624
713
  expect(x.operands).to be_instance_of(Array)
625
714
  expect(x.operands.count).to eq(2)
626
- expect(x.operands[0]).to eq(4)
627
- expect(x.operands[1]).to eq(2)
715
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
716
+ expect(x.operands[0].value).to eq("4")
717
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
718
+ expect(x.operands[1].value).to eq("2")
628
719
  end
629
720
 
630
721
  constants.find{|x| x.id == "orExpression"}.expression.tap do |x|
@@ -632,8 +723,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
632
723
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::Or)
633
724
  expect(x.operands).to be_instance_of(Array)
634
725
  expect(x.operands.count).to eq(2)
635
- expect(x.operands[0]).to eq(true)
636
- expect(x.operands[1]).to eq(false)
726
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
727
+ expect(x.operands[0].value).to eq(true)
728
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
729
+ expect(x.operands[1].value).to eq(false)
637
730
  end
638
731
 
639
732
  constants.find{|x| x.id == "andExpression"}.expression.tap do |x|
@@ -641,20 +734,27 @@ RSpec.describe Expressir::ExpressExp::Parser do
641
734
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::And)
642
735
  expect(x.operands).to be_instance_of(Array)
643
736
  expect(x.operands.count).to eq(2)
644
- expect(x.operands[0]).to eq(true)
645
- expect(x.operands[1]).to eq(false)
737
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
738
+ expect(x.operands[0].value).to eq(true)
739
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
740
+ expect(x.operands[1].value).to eq(false)
646
741
  end
647
742
 
648
743
  constants.find{|x| x.id == "orOrExpression"}.expression.tap do |x|
649
744
  expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
650
745
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::Or)
746
+ expect(x.operands).to be_instance_of(Array)
747
+ expect(x.operands.count).to eq(2)
651
748
  expect(x.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
652
749
  expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Or)
653
750
  expect(x.operands[0].operands).to be_instance_of(Array)
654
751
  expect(x.operands[0].operands.count).to eq(2)
655
- expect(x.operands[0].operands[0]).to eq(true)
656
- expect(x.operands[0].operands[1]).to eq(false)
657
- expect(x.operands[1]).to eq(true)
752
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
753
+ expect(x.operands[0].operands[0].value).to eq(true)
754
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
755
+ expect(x.operands[0].operands[1].value).to eq(false)
756
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
757
+ expect(x.operands[1].value).to eq(true)
658
758
  end
659
759
 
660
760
  constants.find{|x| x.id == "andAndExpression"}.expression.tap do |x|
@@ -666,9 +766,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
666
766
  expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::And)
667
767
  expect(x.operands[0].operands).to be_instance_of(Array)
668
768
  expect(x.operands[0].operands.count).to eq(2)
669
- expect(x.operands[0].operands[0]).to eq(true)
670
- expect(x.operands[0].operands[1]).to eq(false)
671
- expect(x.operands[1]).to eq(true)
769
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
770
+ expect(x.operands[0].operands[0].value).to eq(true)
771
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
772
+ expect(x.operands[0].operands[1].value).to eq(false)
773
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
774
+ expect(x.operands[1].value).to eq(true)
672
775
  end
673
776
 
674
777
  constants.find{|x| x.id == "orAndExpression"}.expression.tap do |x|
@@ -676,13 +779,16 @@ RSpec.describe Expressir::ExpressExp::Parser do
676
779
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::Or)
677
780
  expect(x.operands).to be_instance_of(Array)
678
781
  expect(x.operands.count).to eq(2)
679
- expect(x.operands[0]).to eq(true)
782
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
783
+ expect(x.operands[0].value).to eq(true)
680
784
  expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
681
785
  expect(x.operands[1].operator).to be_instance_of(Expressir::Model::Operators::And)
682
786
  expect(x.operands[1].operands).to be_instance_of(Array)
683
787
  expect(x.operands[1].operands.count).to eq(2)
684
- expect(x.operands[1].operands[0]).to eq(false)
685
- expect(x.operands[1].operands[1]).to eq(true)
788
+ expect(x.operands[1].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
789
+ expect(x.operands[1].operands[0].value).to eq(false)
790
+ expect(x.operands[1].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
791
+ expect(x.operands[1].operands[1].value).to eq(true)
686
792
  end
687
793
 
688
794
  constants.find{|x| x.id == "andOrExpression"}.expression.tap do |x|
@@ -694,9 +800,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
694
800
  expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::And)
695
801
  expect(x.operands[0].operands).to be_instance_of(Array)
696
802
  expect(x.operands[0].operands.count).to eq(2)
697
- expect(x.operands[0].operands[0]).to eq(true)
698
- expect(x.operands[0].operands[1]).to eq(false)
699
- expect(x.operands[1]).to eq(true)
803
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
804
+ expect(x.operands[0].operands[0].value).to eq(true)
805
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
806
+ expect(x.operands[0].operands[1].value).to eq(false)
807
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
808
+ expect(x.operands[1].value).to eq(true)
700
809
  end
701
810
 
702
811
  constants.find{|x| x.id == "parenthesisOrAndExpression"}.expression.tap do |x|
@@ -708,9 +817,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
708
817
  expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Or)
709
818
  expect(x.operands[0].operands).to be_instance_of(Array)
710
819
  expect(x.operands[0].operands.count).to eq(2)
711
- expect(x.operands[0].operands[0]).to eq(true)
712
- expect(x.operands[0].operands[1]).to eq(false)
713
- expect(x.operands[1]).to eq(true)
820
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
821
+ expect(x.operands[0].operands[0].value).to eq(true)
822
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
823
+ expect(x.operands[0].operands[1].value).to eq(false)
824
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
825
+ expect(x.operands[1].value).to eq(true)
714
826
  end
715
827
 
716
828
  constants.find{|x| x.id == "andParenthesisOrExpression"}.expression.tap do |x|
@@ -718,57 +830,73 @@ RSpec.describe Expressir::ExpressExp::Parser do
718
830
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::And)
719
831
  expect(x.operands).to be_instance_of(Array)
720
832
  expect(x.operands.count).to eq(2)
721
- expect(x.operands[0]).to eq(true)
833
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
834
+ expect(x.operands[0].value).to eq(true)
722
835
  expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
723
836
  expect(x.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Or)
724
837
  expect(x.operands[1].operands).to be_instance_of(Array)
725
838
  expect(x.operands[1].operands.count).to eq(2)
726
- expect(x.operands[1].operands[0]).to eq(false)
727
- expect(x.operands[1].operands[1]).to eq(true)
839
+ expect(x.operands[1].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
840
+ expect(x.operands[1].operands[0].value).to eq(false)
841
+ expect(x.operands[1].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
842
+ expect(x.operands[1].operands[1].value).to eq(true)
728
843
  end
729
844
 
730
845
  # aggregate initializers
731
- constants.find{|x| x.id == "aggregateExpression"}.expression.tap do |x|
732
- expect(x).to be_instance_of(Array)
733
- expect(x.count).to eq(1)
734
- expect(x[0]).to eq("xxx")
735
- end
736
-
737
- constants.find{|x| x.id == "aggregateRepeatedExpression"}.expression.tap do |x|
738
- expect(x).to be_instance_of(Array)
739
- expect(x.count).to eq(1)
740
- expect(x[0]).to be_instance_of(Expressir::Model::Expressions::AggregateElement)
741
- expect(x[0].expression).to eq("xxx")
742
- expect(x[0].repetition).to eq(2)
743
- end
744
-
745
- constants.find{|x| x.id == "aggregateComplexExpression"}.expression.tap do |x|
746
- expect(x).to be_instance_of(Array)
747
- expect(x.count).to eq(1)
748
- expect(x[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
749
- expect(x[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
750
- expect(x[0].operands).to be_instance_of(Array)
751
- expect(x[0].operands.count).to eq(2)
752
- expect(x[0].operands[0]).to eq(4)
753
- expect(x[0].operands[1]).to eq(2)
754
- end
755
-
756
- constants.find{|x| x.id == "aggregateComplexRepeatedExpression"}.expression.tap do |x|
757
- expect(x).to be_instance_of(Array)
758
- expect(x.count).to eq(1)
759
- expect(x[0]).to be_instance_of(Expressir::Model::Expressions::AggregateElement)
760
- expect(x[0].expression).to be_instance_of(Expressir::Model::Expressions::Expression)
761
- expect(x[0].expression.operator).to be_instance_of(Expressir::Model::Operators::Addition)
762
- expect(x[0].expression.operands).to be_instance_of(Array)
763
- expect(x[0].expression.operands.count).to eq(2)
764
- expect(x[0].expression.operands[0]).to eq(4)
765
- expect(x[0].expression.operands[1]).to eq(2)
766
- expect(x[0].repetition).to be_instance_of(Expressir::Model::Expressions::Expression)
767
- expect(x[0].repetition.operator).to be_instance_of(Expressir::Model::Operators::Addition)
768
- expect(x[0].repetition.operands).to be_instance_of(Array)
769
- expect(x[0].repetition.operands.count).to eq(2)
770
- expect(x[0].repetition.operands[0]).to eq(4)
771
- expect(x[0].repetition.operands[1]).to eq(2)
846
+ constants.find{|x| x.id == "aggregateInitializerExpression"}.expression.tap do |x|
847
+ expect(x).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
848
+ expect(x.items).to be_instance_of(Array)
849
+ expect(x.items.count).to eq(1)
850
+ expect(x.items[0]).to be_instance_of(Expressir::Model::Literals::String)
851
+ expect(x.items[0].value).to eq("xxx")
852
+ end
853
+
854
+ constants.find{|x| x.id == "repeatedAggregateInitializerExpression"}.expression.tap do |x|
855
+ expect(x).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
856
+ expect(x.items).to be_instance_of(Array)
857
+ expect(x.items.count).to eq(1)
858
+ expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::AggregateElement)
859
+ expect(x.items[0].expression).to be_instance_of(Expressir::Model::Literals::String)
860
+ expect(x.items[0].expression.value).to eq("xxx")
861
+ expect(x.items[0].repetition).to be_instance_of(Expressir::Model::Literals::Integer)
862
+ expect(x.items[0].repetition.value).to eq("2")
863
+ end
864
+
865
+ constants.find{|x| x.id == "complexAggregateInitializerExpression"}.expression.tap do |x|
866
+ expect(x).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
867
+ expect(x.items).to be_instance_of(Array)
868
+ expect(x.items.count).to eq(1)
869
+ expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
870
+ expect(x.items[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
871
+ expect(x.items[0].operands).to be_instance_of(Array)
872
+ expect(x.items[0].operands.count).to eq(2)
873
+ expect(x.items[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
874
+ expect(x.items[0].operands[0].value).to eq("4")
875
+ expect(x.items[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
876
+ expect(x.items[0].operands[1].value).to eq("2")
877
+ end
878
+
879
+ constants.find{|x| x.id == "complexRepeatedAggregateInitializerExpression"}.expression.tap do |x|
880
+ expect(x).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
881
+ expect(x.items).to be_instance_of(Array)
882
+ expect(x.items.count).to eq(1)
883
+ expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::AggregateElement)
884
+ expect(x.items[0].expression).to be_instance_of(Expressir::Model::Expressions::Expression)
885
+ expect(x.items[0].expression.operator).to be_instance_of(Expressir::Model::Operators::Addition)
886
+ expect(x.items[0].expression.operands).to be_instance_of(Array)
887
+ expect(x.items[0].expression.operands.count).to eq(2)
888
+ expect(x.items[0].expression.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
889
+ expect(x.items[0].expression.operands[0].value).to eq("4")
890
+ expect(x.items[0].expression.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
891
+ expect(x.items[0].expression.operands[1].value).to eq("2")
892
+ expect(x.items[0].repetition).to be_instance_of(Expressir::Model::Expressions::Expression)
893
+ expect(x.items[0].repetition.operator).to be_instance_of(Expressir::Model::Operators::Addition)
894
+ expect(x.items[0].repetition.operands).to be_instance_of(Array)
895
+ expect(x.items[0].repetition.operands.count).to eq(2)
896
+ expect(x.items[0].repetition.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
897
+ expect(x.items[0].repetition.operands[0].value).to eq("4")
898
+ expect(x.items[0].repetition.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
899
+ expect(x.items[0].repetition.operands[1].value).to eq("2")
772
900
  end
773
901
 
774
902
  # entity constructors
@@ -778,7 +906,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
778
906
  expect(x.entity.id).to eq("explicitAttributeEntity")
779
907
  expect(x.parameters).to be_instance_of(Array)
780
908
  expect(x.parameters.count).to eq(1)
781
- expect(x.parameters[0]).to eq(true)
909
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
910
+ expect(x.parameters[0].value).to eq(true)
782
911
  end
783
912
 
784
913
  # enumeration references
@@ -801,38 +930,50 @@ RSpec.describe Expressir::ExpressExp::Parser do
801
930
  # intervals
802
931
  constants.find{|x| x.id == "ltLtIntervalExpression"}.expression.tap do |x|
803
932
  expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
804
- expect(x.low).to eq(1)
933
+ expect(x.low).to be_instance_of(Expressir::Model::Literals::Integer)
934
+ expect(x.low.value).to eq("1")
805
935
  expect(x.operator1).to be_instance_of(Expressir::Model::Operators::LessThan)
806
- expect(x.item).to eq(5)
936
+ expect(x.item).to be_instance_of(Expressir::Model::Literals::Integer)
937
+ expect(x.item.value).to eq("5")
807
938
  expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThan)
808
- expect(x.high).to eq(9)
939
+ expect(x.high).to be_instance_of(Expressir::Model::Literals::Integer)
940
+ expect(x.high.value).to eq("9")
809
941
  end
810
942
 
811
943
  constants.find{|x| x.id == "lteLtIntervalExpression"}.expression.tap do |x|
812
944
  expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
813
- expect(x.low).to eq(1)
945
+ expect(x.low).to be_instance_of(Expressir::Model::Literals::Integer)
946
+ expect(x.low.value).to eq("1")
814
947
  expect(x.operator1).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
815
- expect(x.item).to eq(5)
948
+ expect(x.item).to be_instance_of(Expressir::Model::Literals::Integer)
949
+ expect(x.item.value).to eq("5")
816
950
  expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThan)
817
- expect(x.high).to eq(9)
951
+ expect(x.high).to be_instance_of(Expressir::Model::Literals::Integer)
952
+ expect(x.high.value).to eq("9")
818
953
  end
819
954
 
820
955
  constants.find{|x| x.id == "ltLteIntervalExpression"}.expression.tap do |x|
821
956
  expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
822
- expect(x.low).to eq(1)
957
+ expect(x.low).to be_instance_of(Expressir::Model::Literals::Integer)
958
+ expect(x.low.value).to eq("1")
823
959
  expect(x.operator1).to be_instance_of(Expressir::Model::Operators::LessThan)
824
- expect(x.item).to eq(5)
960
+ expect(x.item).to be_instance_of(Expressir::Model::Literals::Integer)
961
+ expect(x.item.value).to eq("5")
825
962
  expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
826
- expect(x.high).to eq(9)
963
+ expect(x.high).to be_instance_of(Expressir::Model::Literals::Integer)
964
+ expect(x.high.value).to eq("9")
827
965
  end
828
966
 
829
967
  constants.find{|x| x.id == "lteLteIntervalExpression"}.expression.tap do |x|
830
968
  expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
831
- expect(x.low).to eq(1)
969
+ expect(x.low).to be_instance_of(Expressir::Model::Literals::Integer)
970
+ expect(x.low.value).to eq("1")
832
971
  expect(x.operator1).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
833
- expect(x.item).to eq(5)
972
+ expect(x.item).to be_instance_of(Expressir::Model::Literals::Integer)
973
+ expect(x.item.value).to eq("5")
834
974
  expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
835
- expect(x.high).to eq(9)
975
+ expect(x.high).to be_instance_of(Expressir::Model::Literals::Integer)
976
+ expect(x.high.value).to eq("9")
836
977
  end
837
978
 
838
979
  constants.find{|x| x.id == "combineExpression"}.expression.tap do |x|
@@ -851,10 +992,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
851
992
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::In)
852
993
  expect(x.operands).to be_instance_of(Array)
853
994
  expect(x.operands.count).to eq(2)
854
- expect(x.operands[0]).to eq(true)
855
- expect(x.operands[1]).to be_instance_of(Array)
856
- expect(x.operands[1].count).to eq(1)
857
- expect(x.operands[1][0]).to eq(true)
995
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
996
+ expect(x.operands[0].value).to eq(true)
997
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
998
+ expect(x.operands[1].items).to be_instance_of(Array)
999
+ expect(x.operands[1].items.count).to eq(1)
1000
+ expect(x.operands[1].items[0]).to be_instance_of(Expressir::Model::Literals::Logical)
1001
+ expect(x.operands[1].items[0].value).to eq(true)
858
1002
  end
859
1003
 
860
1004
  constants.find{|x| x.id == "likeExpression"}.expression.tap do |x|
@@ -862,8 +1006,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
862
1006
  expect(x.operator).to be_instance_of(Expressir::Model::Operators::Like)
863
1007
  expect(x.operands).to be_instance_of(Array)
864
1008
  expect(x.operands.count).to eq(2)
865
- expect(x.operands[0]).to eq("xxx")
866
- expect(x.operands[1]).to eq("xxx")
1009
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::String)
1010
+ expect(x.operands[0].value).to eq("xxx")
1011
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::String)
1012
+ expect(x.operands[1].value).to eq("xxx")
867
1013
  end
868
1014
 
869
1015
  # queries
@@ -872,7 +1018,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
872
1018
  expect(x.id).to eq("test")
873
1019
  expect(x.source).to be_instance_of(Expressir::Model::Ref)
874
1020
  expect(x.source.id).to eq("test2")
875
- expect(x.expression).to eq(true)
1021
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
1022
+ expect(x.expression.value).to eq(true)
876
1023
  end
877
1024
 
878
1025
  # types
@@ -887,7 +1034,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
887
1034
  expect(x.where).to be_instance_of(Array)
888
1035
  expect(x.where.count).to eq(1)
889
1036
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
890
- expect(x.where[0].expression).to eq(true)
1037
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
1038
+ expect(x.where[0].expression.value).to eq(true)
891
1039
  end
892
1040
 
893
1041
  types.find{|x| x.id == "integerWhereLabelType"}.tap do |x|
@@ -897,7 +1045,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
897
1045
  expect(x.where.count).to eq(1)
898
1046
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
899
1047
  expect(x.where[0].id).to eq("WR1")
900
- expect(x.where[0].expression).to eq(true)
1048
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
1049
+ expect(x.where[0].expression.value).to eq(true)
901
1050
  end
902
1051
 
903
1052
  # simple types
@@ -907,12 +1056,14 @@ RSpec.describe Expressir::ExpressExp::Parser do
907
1056
 
908
1057
  types.find{|x| x.id == "binaryWidthType"}.type.tap do |x|
909
1058
  expect(x).to be_instance_of(Expressir::Model::Types::Binary)
910
- expect(x.width).to eq(3)
1059
+ expect(x.width).to be_instance_of(Expressir::Model::Literals::Integer)
1060
+ expect(x.width.value).to eq("3")
911
1061
  end
912
1062
 
913
1063
  types.find{|x| x.id == "binaryWidthFixedType"}.type.tap do |x|
914
1064
  expect(x).to be_instance_of(Expressir::Model::Types::Binary)
915
- expect(x.width).to eq(3)
1065
+ expect(x.width).to be_instance_of(Expressir::Model::Literals::Integer)
1066
+ expect(x.width.value).to eq("3")
916
1067
  expect(x.fixed).to eq(true)
917
1068
  end
918
1069
 
@@ -938,7 +1089,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
938
1089
 
939
1090
  types.find{|x| x.id == "realPrecisionType"}.type.tap do |x|
940
1091
  expect(x).to be_instance_of(Expressir::Model::Types::Real)
941
- expect(x.precision).to eq(3)
1092
+ expect(x.precision).to be_instance_of(Expressir::Model::Literals::Integer)
1093
+ expect(x.precision.value).to eq("3")
942
1094
  end
943
1095
 
944
1096
  types.find{|x| x.id == "stringType"}.type.tap do |x|
@@ -947,43 +1099,53 @@ RSpec.describe Expressir::ExpressExp::Parser do
947
1099
 
948
1100
  types.find{|x| x.id == "stringWidthType"}.type.tap do |x|
949
1101
  expect(x).to be_instance_of(Expressir::Model::Types::String)
950
- expect(x.width).to eq(3)
1102
+ expect(x.width).to be_instance_of(Expressir::Model::Literals::Integer)
1103
+ expect(x.width.value).to eq("3")
951
1104
  end
952
1105
 
953
1106
  types.find{|x| x.id == "stringWidthFixedType"}.type.tap do |x|
954
1107
  expect(x).to be_instance_of(Expressir::Model::Types::String)
955
- expect(x.width).to eq(3)
1108
+ expect(x.width).to be_instance_of(Expressir::Model::Literals::Integer)
1109
+ expect(x.width.value).to eq("3")
956
1110
  expect(x.fixed).to eq(true)
957
1111
  end
958
1112
 
959
1113
  # aggregation types
960
1114
  types.find{|x| x.id == "arrayType"}.type.tap do |x|
961
1115
  expect(x).to be_instance_of(Expressir::Model::Types::Array)
962
- expect(x.bound1).to eq(1)
963
- expect(x.bound2).to eq(9)
1116
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
1117
+ expect(x.bound1.value).to eq("1")
1118
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
1119
+ expect(x.bound2.value).to eq("9")
964
1120
  expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
965
1121
  end
966
1122
 
967
1123
  types.find{|x| x.id == "arrayOptionalType"}.type.tap do |x|
968
1124
  expect(x).to be_instance_of(Expressir::Model::Types::Array)
969
- expect(x.bound1).to eq(1)
970
- expect(x.bound2).to eq(9)
1125
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
1126
+ expect(x.bound1.value).to eq("1")
1127
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
1128
+ expect(x.bound2.value).to eq("9")
971
1129
  expect(x.optional).to eq(true)
972
1130
  expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
973
1131
  end
974
1132
 
975
1133
  types.find{|x| x.id == "arrayUniqueType"}.type.tap do |x|
976
1134
  expect(x).to be_instance_of(Expressir::Model::Types::Array)
977
- expect(x.bound1).to eq(1)
978
- expect(x.bound2).to eq(9)
1135
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
1136
+ expect(x.bound1.value).to eq("1")
1137
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
1138
+ expect(x.bound2.value).to eq("9")
979
1139
  expect(x.unique).to eq(true)
980
1140
  expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
981
1141
  end
982
1142
 
983
1143
  types.find{|x| x.id == "arrayOptionalUniqueType"}.type.tap do |x|
984
1144
  expect(x).to be_instance_of(Expressir::Model::Types::Array)
985
- expect(x.bound1).to eq(1)
986
- expect(x.bound2).to eq(9)
1145
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
1146
+ expect(x.bound1.value).to eq("1")
1147
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
1148
+ expect(x.bound2.value).to eq("9")
987
1149
  expect(x.optional).to eq(true)
988
1150
  expect(x.unique).to eq(true)
989
1151
  expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
@@ -996,8 +1158,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
996
1158
 
997
1159
  types.find{|x| x.id == "bagBoundType"}.type.tap do |x|
998
1160
  expect(x).to be_instance_of(Expressir::Model::Types::Bag)
999
- expect(x.bound1).to eq(1)
1000
- expect(x.bound2).to eq(9)
1161
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
1162
+ expect(x.bound1.value).to eq("1")
1163
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
1164
+ expect(x.bound2.value).to eq("9")
1001
1165
  expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
1002
1166
  end
1003
1167
 
@@ -1008,8 +1172,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
1008
1172
 
1009
1173
  types.find{|x| x.id == "listBoundType"}.type.tap do |x|
1010
1174
  expect(x).to be_instance_of(Expressir::Model::Types::List)
1011
- expect(x.bound1).to eq(1)
1012
- expect(x.bound2).to eq(9)
1175
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
1176
+ expect(x.bound1.value).to eq("1")
1177
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
1178
+ expect(x.bound2.value).to eq("9")
1013
1179
  expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
1014
1180
  end
1015
1181
 
@@ -1021,8 +1187,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
1021
1187
 
1022
1188
  types.find{|x| x.id == "listBoundUniqueType"}.type.tap do |x|
1023
1189
  expect(x).to be_instance_of(Expressir::Model::Types::List)
1024
- expect(x.bound1).to eq(1)
1025
- expect(x.bound2).to eq(9)
1190
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
1191
+ expect(x.bound1.value).to eq("1")
1192
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
1193
+ expect(x.bound2.value).to eq("9")
1026
1194
  expect(x.unique).to eq(true)
1027
1195
  expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
1028
1196
  end
@@ -1034,8 +1202,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
1034
1202
 
1035
1203
  types.find{|x| x.id == "setBoundType"}.type.tap do |x|
1036
1204
  expect(x).to be_instance_of(Expressir::Model::Types::Set)
1037
- expect(x.bound1).to eq(1)
1038
- expect(x.bound2).to eq(9)
1205
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
1206
+ expect(x.bound1.value).to eq("1")
1207
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
1208
+ expect(x.bound2.value).to eq("9")
1039
1209
  expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
1040
1210
  end
1041
1211
 
@@ -1057,10 +1227,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
1057
1227
 
1058
1228
  types.find{|x| x.id == "selectListType"}.type.tap do |x|
1059
1229
  expect(x).to be_instance_of(Expressir::Model::Types::Select)
1060
- expect(x.list).to be_instance_of(Array)
1061
- expect(x.list.count).to eq(1)
1062
- expect(x.list[0]).to be_instance_of(Expressir::Model::Ref)
1063
- expect(x.list[0].id).to eq("test")
1230
+ expect(x.items).to be_instance_of(Array)
1231
+ expect(x.items.count).to eq(1)
1232
+ expect(x.items[0]).to be_instance_of(Expressir::Model::Ref)
1233
+ expect(x.items[0].id).to eq("test")
1064
1234
  end
1065
1235
 
1066
1236
  types.find{|x| x.id == "selectExtensionTypeRefType"}.type.tap do |x|
@@ -1073,10 +1243,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
1073
1243
  expect(x).to be_instance_of(Expressir::Model::Types::Select)
1074
1244
  expect(x.extension_type).to be_instance_of(Expressir::Model::Ref)
1075
1245
  expect(x.extension_type.id).to eq("selectType")
1076
- expect(x.extension_list).to be_instance_of(Array)
1077
- expect(x.extension_list.count).to eq(1)
1078
- expect(x.extension_list[0]).to be_instance_of(Expressir::Model::Ref)
1079
- expect(x.extension_list[0].id).to eq("test")
1246
+ expect(x.extension_items).to be_instance_of(Array)
1247
+ expect(x.extension_items.count).to eq(1)
1248
+ expect(x.extension_items[0]).to be_instance_of(Expressir::Model::Ref)
1249
+ expect(x.extension_items[0].id).to eq("test")
1080
1250
  end
1081
1251
 
1082
1252
  types.find{|x| x.id == "enumerationType"}.type.tap do |x|
@@ -1090,9 +1260,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
1090
1260
 
1091
1261
  types.find{|x| x.id == "enumerationListType"}.type.tap do |x|
1092
1262
  expect(x).to be_instance_of(Expressir::Model::Types::Enumeration)
1093
- expect(x.list).to be_instance_of(Array)
1094
- expect(x.list.count).to eq(1)
1095
- expect(x.list[0]).to eq("test")
1263
+ expect(x.items).to be_instance_of(Array)
1264
+ expect(x.items.count).to eq(1)
1265
+ expect(x.items[0]).to be_instance_of(Expressir::Model::EnumerationItem)
1266
+ expect(x.items[0].id).to eq("test")
1096
1267
  end
1097
1268
 
1098
1269
  types.find{|x| x.id == "enumerationExtensionTypeRefType"}.type.tap do |x|
@@ -1105,9 +1276,9 @@ RSpec.describe Expressir::ExpressExp::Parser do
1105
1276
  expect(x).to be_instance_of(Expressir::Model::Types::Enumeration)
1106
1277
  expect(x.extension_type).to be_instance_of(Expressir::Model::Ref)
1107
1278
  expect(x.extension_type.id).to eq("enumerationType")
1108
- expect(x.extension_list).to be_instance_of(Array)
1109
- expect(x.extension_list.count).to eq(1)
1110
- expect(x.extension_list[0]).to eq("test")
1279
+ expect(x.extension_items).to be_instance_of(Array)
1280
+ expect(x.extension_items[0]).to be_instance_of(Expressir::Model::EnumerationItem)
1281
+ expect(x.extension_items[0].id).to eq("test")
1111
1282
  end
1112
1283
 
1113
1284
  # entities
@@ -1199,24 +1370,42 @@ RSpec.describe Expressir::ExpressExp::Parser do
1199
1370
  expect(x.explicit[1].type).to be_instance_of(Expressir::Model::Types::Boolean)
1200
1371
  end
1201
1372
 
1202
- entities.find{|x| x.id == "explicitAttributeRenamedEntity"}.tap do |x|
1373
+ entities.find{|x| x.id == "explicitAttributeRedeclaredEntity"}.tap do |x|
1374
+ expect(x).to be_instance_of(Expressir::Model::Entity)
1375
+ expect(x.explicit).to be_instance_of(Array)
1376
+ expect(x.explicit.count).to eq(1)
1377
+ expect(x.explicit[0]).to be_instance_of(Expressir::Model::Explicit)
1378
+ expect(x.explicit[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
1379
+ expect(x.explicit[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
1380
+ expect(x.explicit[0].supertype_attribute.ref.id).to eq("SELF")
1381
+ expect(x.explicit[0].supertype_attribute.qualifiers).to be_instance_of(Array)
1382
+ expect(x.explicit[0].supertype_attribute.qualifiers.count).to eq(2)
1383
+ expect(x.explicit[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
1384
+ expect(x.explicit[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
1385
+ expect(x.explicit[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
1386
+ expect(x.explicit[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
1387
+ expect(x.explicit[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
1388
+ expect(x.explicit[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
1389
+ expect(x.explicit[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
1390
+ end
1391
+
1392
+ entities.find{|x| x.id == "explicitAttributeRedeclaredRenamedEntity"}.tap do |x|
1203
1393
  expect(x).to be_instance_of(Expressir::Model::Entity)
1204
1394
  expect(x.explicit).to be_instance_of(Array)
1205
1395
  expect(x.explicit.count).to eq(1)
1206
1396
  expect(x.explicit[0]).to be_instance_of(Expressir::Model::Explicit)
1207
- expect(x.explicit[0].id).to be_instance_of(Expressir::Model::RenamedRef)
1208
- expect(x.explicit[0].id.ref).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
1209
- expect(x.explicit[0].id.ref.ref).to be_instance_of(Expressir::Model::Ref)
1210
- expect(x.explicit[0].id.ref.ref.id).to eq("SELF")
1211
- expect(x.explicit[0].id.ref.qualifiers).to be_instance_of(Array)
1212
- expect(x.explicit[0].id.ref.qualifiers.count).to eq(2)
1213
- expect(x.explicit[0].id.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
1214
- expect(x.explicit[0].id.ref.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
1215
- expect(x.explicit[0].id.ref.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
1216
- expect(x.explicit[0].id.ref.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
1217
- expect(x.explicit[0].id.ref.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
1218
- expect(x.explicit[0].id.ref.qualifiers[1].attribute.id).to eq("test")
1219
- expect(x.explicit[0].id.id).to eq("test2")
1397
+ expect(x.explicit[0].id).to eq("test2")
1398
+ expect(x.explicit[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
1399
+ expect(x.explicit[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
1400
+ expect(x.explicit[0].supertype_attribute.ref.id).to eq("SELF")
1401
+ expect(x.explicit[0].supertype_attribute.qualifiers).to be_instance_of(Array)
1402
+ expect(x.explicit[0].supertype_attribute.qualifiers.count).to eq(2)
1403
+ expect(x.explicit[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
1404
+ expect(x.explicit[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
1405
+ expect(x.explicit[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
1406
+ expect(x.explicit[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
1407
+ expect(x.explicit[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
1408
+ expect(x.explicit[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
1220
1409
  expect(x.explicit[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
1221
1410
  end
1222
1411
 
@@ -1227,7 +1416,51 @@ RSpec.describe Expressir::ExpressExp::Parser do
1227
1416
  expect(x.derived[0]).to be_instance_of(Expressir::Model::Derived)
1228
1417
  expect(x.derived[0].id).to eq("test")
1229
1418
  expect(x.derived[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
1230
- expect(x.derived[0].expression).to eq(true)
1419
+ expect(x.derived[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
1420
+ expect(x.derived[0].expression.value).to eq(true)
1421
+ end
1422
+
1423
+ entities.find{|x| x.id == "derivedAttributeRedeclaredEntity"}.tap do |x|
1424
+ expect(x).to be_instance_of(Expressir::Model::Entity)
1425
+ expect(x.derived).to be_instance_of(Array)
1426
+ expect(x.derived.count).to eq(1)
1427
+ expect(x.derived[0]).to be_instance_of(Expressir::Model::Derived)
1428
+ expect(x.derived[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
1429
+ expect(x.derived[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
1430
+ expect(x.derived[0].supertype_attribute.ref.id).to eq("SELF")
1431
+ expect(x.derived[0].supertype_attribute.qualifiers).to be_instance_of(Array)
1432
+ expect(x.derived[0].supertype_attribute.qualifiers.count).to eq(2)
1433
+ expect(x.derived[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
1434
+ expect(x.derived[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
1435
+ expect(x.derived[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
1436
+ expect(x.derived[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
1437
+ expect(x.derived[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
1438
+ expect(x.derived[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
1439
+ expect(x.derived[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
1440
+ expect(x.derived[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
1441
+ expect(x.derived[0].expression.value).to eq(true)
1442
+ end
1443
+
1444
+ entities.find{|x| x.id == "derivedAttributeRedeclaredRenamedEntity"}.tap do |x|
1445
+ expect(x).to be_instance_of(Expressir::Model::Entity)
1446
+ expect(x.derived).to be_instance_of(Array)
1447
+ expect(x.derived.count).to eq(1)
1448
+ expect(x.derived[0]).to be_instance_of(Expressir::Model::Derived)
1449
+ expect(x.derived[0].id).to eq("test2")
1450
+ expect(x.derived[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
1451
+ expect(x.derived[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
1452
+ expect(x.derived[0].supertype_attribute.ref.id).to eq("SELF")
1453
+ expect(x.derived[0].supertype_attribute.qualifiers).to be_instance_of(Array)
1454
+ expect(x.derived[0].supertype_attribute.qualifiers.count).to eq(2)
1455
+ expect(x.derived[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
1456
+ expect(x.derived[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
1457
+ expect(x.derived[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
1458
+ expect(x.derived[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
1459
+ expect(x.derived[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
1460
+ expect(x.derived[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
1461
+ expect(x.derived[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
1462
+ expect(x.derived[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
1463
+ expect(x.derived[0].expression.value).to eq(true)
1231
1464
  end
1232
1465
 
1233
1466
  entities.find{|x| x.id == "inverseAttributeEntity"}.tap do |x|
@@ -1280,8 +1513,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
1280
1513
  expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
1281
1514
  expect(x.inverse[0].id).to eq("test")
1282
1515
  expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Types::Set)
1283
- expect(x.inverse[0].type.bound1).to eq(1)
1284
- expect(x.inverse[0].type.bound2).to eq(9)
1516
+ expect(x.inverse[0].type.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
1517
+ expect(x.inverse[0].type.bound1.value).to eq("1")
1518
+ expect(x.inverse[0].type.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
1519
+ expect(x.inverse[0].type.bound2.value).to eq("9")
1285
1520
  expect(x.inverse[0].type.base_type).to be_instance_of(Expressir::Model::Ref)
1286
1521
  expect(x.inverse[0].type.base_type.id).to eq("explicitAttributeEntity")
1287
1522
  expect(x.inverse[0].attribute).to be_instance_of(Expressir::Model::Ref)
@@ -1308,14 +1543,61 @@ RSpec.describe Expressir::ExpressExp::Parser do
1308
1543
  expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
1309
1544
  expect(x.inverse[0].id).to eq("test")
1310
1545
  expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Types::Bag)
1311
- expect(x.inverse[0].type.bound1).to eq(1)
1312
- expect(x.inverse[0].type.bound2).to eq(9)
1546
+ expect(x.inverse[0].type.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
1547
+ expect(x.inverse[0].type.bound1.value).to eq("1")
1548
+ expect(x.inverse[0].type.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
1549
+ expect(x.inverse[0].type.bound2.value).to eq("9")
1313
1550
  expect(x.inverse[0].type.base_type).to be_instance_of(Expressir::Model::Ref)
1314
1551
  expect(x.inverse[0].type.base_type.id).to eq("explicitAttributeEntity")
1315
1552
  expect(x.inverse[0].attribute).to be_instance_of(Expressir::Model::Ref)
1316
1553
  expect(x.inverse[0].attribute.id).to eq("test")
1317
1554
  end
1318
1555
 
1556
+ entities.find{|x| x.id == "inverseAttributeRedeclaredEntity"}.tap do |x|
1557
+ expect(x).to be_instance_of(Expressir::Model::Entity)
1558
+ expect(x.inverse).to be_instance_of(Array)
1559
+ expect(x.inverse.count).to eq(1)
1560
+ expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
1561
+ expect(x.inverse[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
1562
+ expect(x.inverse[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
1563
+ expect(x.inverse[0].supertype_attribute.ref.id).to eq("SELF")
1564
+ expect(x.inverse[0].supertype_attribute.qualifiers).to be_instance_of(Array)
1565
+ expect(x.inverse[0].supertype_attribute.qualifiers.count).to eq(2)
1566
+ expect(x.inverse[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
1567
+ expect(x.inverse[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
1568
+ expect(x.inverse[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
1569
+ expect(x.inverse[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
1570
+ expect(x.inverse[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
1571
+ expect(x.inverse[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
1572
+ expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Ref)
1573
+ expect(x.inverse[0].type.id).to eq("explicitAttributeEntity")
1574
+ expect(x.inverse[0].attribute).to be_instance_of(Expressir::Model::Ref)
1575
+ expect(x.inverse[0].attribute.id).to eq("test")
1576
+ end
1577
+
1578
+ entities.find{|x| x.id == "inverseAttributeRedeclaredRenamedEntity"}.tap do |x|
1579
+ expect(x).to be_instance_of(Expressir::Model::Entity)
1580
+ expect(x.inverse).to be_instance_of(Array)
1581
+ expect(x.inverse.count).to eq(1)
1582
+ expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
1583
+ expect(x.inverse[0].id).to eq("test2")
1584
+ expect(x.inverse[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
1585
+ expect(x.inverse[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
1586
+ expect(x.inverse[0].supertype_attribute.ref.id).to eq("SELF")
1587
+ expect(x.inverse[0].supertype_attribute.qualifiers).to be_instance_of(Array)
1588
+ expect(x.inverse[0].supertype_attribute.qualifiers.count).to eq(2)
1589
+ expect(x.inverse[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
1590
+ expect(x.inverse[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
1591
+ expect(x.inverse[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
1592
+ expect(x.inverse[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
1593
+ expect(x.inverse[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
1594
+ expect(x.inverse[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
1595
+ expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Ref)
1596
+ expect(x.inverse[0].type.id).to eq("explicitAttributeEntity")
1597
+ expect(x.inverse[0].attribute).to be_instance_of(Expressir::Model::Ref)
1598
+ expect(x.inverse[0].attribute.id).to eq("test")
1599
+ end
1600
+
1319
1601
  entities.find{|x| x.id == "uniqueEntity"}.tap do |x|
1320
1602
  expect(x).to be_instance_of(Expressir::Model::Entity)
1321
1603
  expect(x.unique).to be_instance_of(Array)
@@ -1397,7 +1679,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
1397
1679
  expect(x.where).to be_instance_of(Array)
1398
1680
  expect(x.where.count).to eq(1)
1399
1681
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
1400
- expect(x.where[0].expression).to eq(true)
1682
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
1683
+ expect(x.where[0].expression.value).to eq(true)
1401
1684
  end
1402
1685
 
1403
1686
  entities.find{|x| x.id == "whereLabelEntity"}.tap do |x|
@@ -1406,7 +1689,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
1406
1689
  expect(x.where.count).to eq(1)
1407
1690
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
1408
1691
  expect(x.where[0].id).to eq("WR1")
1409
- expect(x.where[0].expression).to eq(true)
1692
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
1693
+ expect(x.where[0].expression.value).to eq(true)
1410
1694
  end
1411
1695
 
1412
1696
  # subtype constraints
@@ -1770,7 +2054,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
1770
2054
  expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
1771
2055
  expect(x.constants[0].id).to eq("test")
1772
2056
  expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
1773
- expect(x.constants[0].expression).to eq("xxx")
2057
+ expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2058
+ expect(x.constants[0].expression.value).to eq("xxx")
1774
2059
  expect(x.statements).to be_instance_of(Array)
1775
2060
  expect(x.statements.count).to eq(1)
1776
2061
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -1784,11 +2069,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
1784
2069
  expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
1785
2070
  expect(x.constants[0].id).to eq("test")
1786
2071
  expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
1787
- expect(x.constants[0].expression).to eq("xxx")
2072
+ expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2073
+ expect(x.constants[0].expression.value).to eq("xxx")
1788
2074
  expect(x.constants[1]).to be_instance_of(Expressir::Model::Constant)
1789
2075
  expect(x.constants[1].id).to eq("test2")
1790
2076
  expect(x.constants[1].type).to be_instance_of(Expressir::Model::Types::String)
1791
- expect(x.constants[1].expression).to eq("xxx")
2077
+ expect(x.constants[1].expression).to be_instance_of(Expressir::Model::Literals::String)
2078
+ expect(x.constants[1].expression.value).to eq("xxx")
1792
2079
  expect(x.statements).to be_instance_of(Array)
1793
2080
  expect(x.statements.count).to eq(1)
1794
2081
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -1847,7 +2134,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
1847
2134
  expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
1848
2135
  expect(x.locals[0].id).to eq("test")
1849
2136
  expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
1850
- expect(x.locals[0].expression).to eq("xxx")
2137
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2138
+ expect(x.locals[0].expression.value).to eq("xxx")
1851
2139
  expect(x.statements).to be_instance_of(Array)
1852
2140
  expect(x.statements.count).to eq(1)
1853
2141
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -1861,11 +2149,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
1861
2149
  expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
1862
2150
  expect(x.locals[0].id).to eq("test")
1863
2151
  expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
1864
- expect(x.locals[0].expression).to eq("xxx")
2152
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2153
+ expect(x.locals[0].expression.value).to eq("xxx")
1865
2154
  expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
1866
2155
  expect(x.locals[1].id).to eq("test2")
1867
2156
  expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
1868
- expect(x.locals[1].expression).to eq("xxx")
2157
+ expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
2158
+ expect(x.locals[1].expression.value).to eq("xxx")
1869
2159
  expect(x.statements).to be_instance_of(Array)
1870
2160
  expect(x.statements.count).to eq(1)
1871
2161
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -1879,11 +2169,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
1879
2169
  expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
1880
2170
  expect(x.locals[0].id).to eq("test")
1881
2171
  expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
1882
- expect(x.locals[0].expression).to eq("xxx")
2172
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2173
+ expect(x.locals[0].expression.value).to eq("xxx")
1883
2174
  expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
1884
2175
  expect(x.locals[1].id).to eq("test2")
1885
2176
  expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
1886
- expect(x.locals[1].expression).to eq("xxx")
2177
+ expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
2178
+ expect(x.locals[1].expression.value).to eq("xxx")
1887
2179
  expect(x.statements).to be_instance_of(Array)
1888
2180
  expect(x.statements.count).to eq(1)
1889
2181
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2000,7 +2292,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2000
2292
  expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
2001
2293
  expect(x.constants[0].id).to eq("test")
2002
2294
  expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
2003
- expect(x.constants[0].expression).to eq("xxx")
2295
+ expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2296
+ expect(x.constants[0].expression.value).to eq("xxx")
2004
2297
  end
2005
2298
 
2006
2299
  procedures.find{|x| x.id == "multipleConstantProcedure"}.tap do |x|
@@ -2010,11 +2303,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
2010
2303
  expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
2011
2304
  expect(x.constants[0].id).to eq("test")
2012
2305
  expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
2013
- expect(x.constants[0].expression).to eq("xxx")
2306
+ expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2307
+ expect(x.constants[0].expression.value).to eq("xxx")
2014
2308
  expect(x.constants[1]).to be_instance_of(Expressir::Model::Constant)
2015
2309
  expect(x.constants[1].id).to eq("test2")
2016
2310
  expect(x.constants[1].type).to be_instance_of(Expressir::Model::Types::String)
2017
- expect(x.constants[1].expression).to eq("xxx")
2311
+ expect(x.constants[1].expression).to be_instance_of(Expressir::Model::Literals::String)
2312
+ expect(x.constants[1].expression.value).to eq("xxx")
2018
2313
  end
2019
2314
 
2020
2315
  procedures.find{|x| x.id == "localProcedure"}.tap do |x|
@@ -2057,7 +2352,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2057
2352
  expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
2058
2353
  expect(x.locals[0].id).to eq("test")
2059
2354
  expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
2060
- expect(x.locals[0].expression).to eq("xxx")
2355
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2356
+ expect(x.locals[0].expression.value).to eq("xxx")
2061
2357
  end
2062
2358
 
2063
2359
  procedures.find{|x| x.id == "multipleLocalExpressionProcedure"}.tap do |x|
@@ -2067,11 +2363,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
2067
2363
  expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
2068
2364
  expect(x.locals[0].id).to eq("test")
2069
2365
  expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
2070
- expect(x.locals[0].expression).to eq("xxx")
2366
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2367
+ expect(x.locals[0].expression.value).to eq("xxx")
2071
2368
  expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
2072
2369
  expect(x.locals[1].id).to eq("test2")
2073
2370
  expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
2074
- expect(x.locals[1].expression).to eq("xxx")
2371
+ expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
2372
+ expect(x.locals[1].expression.value).to eq("xxx")
2075
2373
  end
2076
2374
 
2077
2375
  procedures.find{|x| x.id == "multipleShorthandLocalExpressionProcedure"}.tap do |x|
@@ -2081,11 +2379,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
2081
2379
  expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
2082
2380
  expect(x.locals[0].id).to eq("test")
2083
2381
  expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
2084
- expect(x.locals[0].expression).to eq("xxx")
2382
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2383
+ expect(x.locals[0].expression.value).to eq("xxx")
2085
2384
  expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
2086
2385
  expect(x.locals[1].id).to eq("test2")
2087
2386
  expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
2088
- expect(x.locals[1].expression).to eq("xxx")
2387
+ expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
2388
+ expect(x.locals[1].expression.value).to eq("xxx")
2089
2389
  end
2090
2390
 
2091
2391
  # rules
@@ -2098,7 +2398,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2098
2398
  expect(x.where).to be_instance_of(Array)
2099
2399
  expect(x.where.count).to eq(1)
2100
2400
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
2101
- expect(x.where[0].expression).to eq(true)
2401
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2402
+ expect(x.where[0].expression.value).to eq(true)
2102
2403
  end
2103
2404
 
2104
2405
  rules.find{|x| x.id == "typeRule"}.tap do |x|
@@ -2115,7 +2416,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2115
2416
  expect(x.where).to be_instance_of(Array)
2116
2417
  expect(x.where.count).to eq(1)
2117
2418
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
2118
- expect(x.where[0].expression).to eq(true)
2419
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2420
+ expect(x.where[0].expression.value).to eq(true)
2119
2421
  end
2120
2422
 
2121
2423
  rules.find{|x| x.id == "constantRule"}.tap do |x|
@@ -2129,11 +2431,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
2129
2431
  expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
2130
2432
  expect(x.constants[0].id).to eq("test")
2131
2433
  expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
2132
- expect(x.constants[0].expression).to eq("xxx")
2434
+ expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2435
+ expect(x.constants[0].expression.value).to eq("xxx")
2133
2436
  expect(x.where).to be_instance_of(Array)
2134
2437
  expect(x.where.count).to eq(1)
2135
2438
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
2136
- expect(x.where[0].expression).to eq(true)
2439
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2440
+ expect(x.where[0].expression.value).to eq(true)
2137
2441
  end
2138
2442
 
2139
2443
  rules.find{|x| x.id == "multipleConstantRule"}.tap do |x|
@@ -2147,15 +2451,18 @@ RSpec.describe Expressir::ExpressExp::Parser do
2147
2451
  expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
2148
2452
  expect(x.constants[0].id).to eq("test")
2149
2453
  expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
2150
- expect(x.constants[0].expression).to eq("xxx")
2454
+ expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2455
+ expect(x.constants[0].expression.value).to eq("xxx")
2151
2456
  expect(x.constants[1]).to be_instance_of(Expressir::Model::Constant)
2152
2457
  expect(x.constants[1].id).to eq("test2")
2153
2458
  expect(x.constants[1].type).to be_instance_of(Expressir::Model::Types::String)
2154
- expect(x.constants[1].expression).to eq("xxx")
2459
+ expect(x.constants[1].expression).to be_instance_of(Expressir::Model::Literals::String)
2460
+ expect(x.constants[1].expression.value).to eq("xxx")
2155
2461
  expect(x.where).to be_instance_of(Array)
2156
2462
  expect(x.where.count).to eq(1)
2157
2463
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
2158
- expect(x.where[0].expression).to eq(true)
2464
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2465
+ expect(x.where[0].expression.value).to eq(true)
2159
2466
  end
2160
2467
 
2161
2468
  rules.find{|x| x.id == "localRule"}.tap do |x|
@@ -2172,7 +2479,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2172
2479
  expect(x.where).to be_instance_of(Array)
2173
2480
  expect(x.where.count).to eq(1)
2174
2481
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
2175
- expect(x.where[0].expression).to eq(true)
2482
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2483
+ expect(x.where[0].expression.value).to eq(true)
2176
2484
  end
2177
2485
 
2178
2486
  rules.find{|x| x.id == "multipleLocalRule"}.tap do |x|
@@ -2192,7 +2500,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2192
2500
  expect(x.where).to be_instance_of(Array)
2193
2501
  expect(x.where.count).to eq(1)
2194
2502
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
2195
- expect(x.where[0].expression).to eq(true)
2503
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2504
+ expect(x.where[0].expression.value).to eq(true)
2196
2505
  end
2197
2506
 
2198
2507
  rules.find{|x| x.id == "multipleShorthandLocalRule"}.tap do |x|
@@ -2212,7 +2521,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2212
2521
  expect(x.where).to be_instance_of(Array)
2213
2522
  expect(x.where.count).to eq(1)
2214
2523
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
2215
- expect(x.where[0].expression).to eq(true)
2524
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2525
+ expect(x.where[0].expression.value).to eq(true)
2216
2526
  end
2217
2527
 
2218
2528
  rules.find{|x| x.id == "localExpressionRule"}.tap do |x|
@@ -2226,11 +2536,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
2226
2536
  expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
2227
2537
  expect(x.locals[0].id).to eq("test")
2228
2538
  expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
2229
- expect(x.locals[0].expression).to eq("xxx")
2539
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2540
+ expect(x.locals[0].expression.value).to eq("xxx")
2230
2541
  expect(x.where).to be_instance_of(Array)
2231
2542
  expect(x.where.count).to eq(1)
2232
2543
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
2233
- expect(x.where[0].expression).to eq(true)
2544
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2545
+ expect(x.where[0].expression.value).to eq(true)
2234
2546
  end
2235
2547
 
2236
2548
  rules.find{|x| x.id == "multipleLocalExpressionRule"}.tap do |x|
@@ -2244,15 +2556,18 @@ RSpec.describe Expressir::ExpressExp::Parser do
2244
2556
  expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
2245
2557
  expect(x.locals[0].id).to eq("test")
2246
2558
  expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
2247
- expect(x.locals[0].expression).to eq("xxx")
2559
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2560
+ expect(x.locals[0].expression.value).to eq("xxx")
2248
2561
  expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
2249
2562
  expect(x.locals[1].id).to eq("test2")
2250
2563
  expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
2251
- expect(x.locals[1].expression).to eq("xxx")
2564
+ expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
2565
+ expect(x.locals[1].expression.value).to eq("xxx")
2252
2566
  expect(x.where).to be_instance_of(Array)
2253
2567
  expect(x.where.count).to eq(1)
2254
2568
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
2255
- expect(x.where[0].expression).to eq(true)
2569
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2570
+ expect(x.where[0].expression.value).to eq(true)
2256
2571
  end
2257
2572
 
2258
2573
  rules.find{|x| x.id == "multipleShorthandLocalExpressionRule"}.tap do |x|
@@ -2266,15 +2581,18 @@ RSpec.describe Expressir::ExpressExp::Parser do
2266
2581
  expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
2267
2582
  expect(x.locals[0].id).to eq("test")
2268
2583
  expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
2269
- expect(x.locals[0].expression).to eq("xxx")
2584
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
2585
+ expect(x.locals[0].expression.value).to eq("xxx")
2270
2586
  expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
2271
2587
  expect(x.locals[1].id).to eq("test2")
2272
2588
  expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
2273
- expect(x.locals[1].expression).to eq("xxx")
2589
+ expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
2590
+ expect(x.locals[1].expression.value).to eq("xxx")
2274
2591
  expect(x.where).to be_instance_of(Array)
2275
2592
  expect(x.where.count).to eq(1)
2276
2593
  expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
2277
- expect(x.where[0].expression).to eq(true)
2594
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2595
+ expect(x.where[0].expression.value).to eq(true)
2278
2596
  end
2279
2597
 
2280
2598
  # statements
@@ -2329,7 +2647,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2329
2647
  expect(x.expression.qualifiers).to be_instance_of(Array)
2330
2648
  expect(x.expression.qualifiers.count).to eq(1)
2331
2649
  expect(x.expression.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::IndexQualifier)
2332
- expect(x.expression.qualifiers[0].index1).to eq(1)
2650
+ expect(x.expression.qualifiers[0].index1).to be_instance_of(Expressir::Model::Literals::Integer)
2651
+ expect(x.expression.qualifiers[0].index1.value).to eq("1")
2333
2652
  expect(x.statements).to be_instance_of(Array)
2334
2653
  expect(x.statements.count).to eq(1)
2335
2654
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2344,8 +2663,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
2344
2663
  expect(x.expression.qualifiers).to be_instance_of(Array)
2345
2664
  expect(x.expression.qualifiers.count).to eq(1)
2346
2665
  expect(x.expression.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::IndexQualifier)
2347
- expect(x.expression.qualifiers[0].index1).to eq(1)
2348
- expect(x.expression.qualifiers[0].index2).to eq(9)
2666
+ expect(x.expression.qualifiers[0].index1).to be_instance_of(Expressir::Model::Literals::Integer)
2667
+ expect(x.expression.qualifiers[0].index1.value).to eq("1")
2668
+ expect(x.expression.qualifiers[0].index2).to be_instance_of(Expressir::Model::Literals::Integer)
2669
+ expect(x.expression.qualifiers[0].index2.value).to eq("9")
2349
2670
  expect(x.statements).to be_instance_of(Array)
2350
2671
  expect(x.statements.count).to eq(1)
2351
2672
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2355,7 +2676,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2355
2676
  expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
2356
2677
  expect(x.ref).to be_instance_of(Expressir::Model::Ref)
2357
2678
  expect(x.ref.id).to eq("test")
2358
- expect(x.expression).to eq(true)
2679
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
2680
+ expect(x.expression.value).to eq(true)
2359
2681
  end
2360
2682
 
2361
2683
  functions.find{|x| x.id == "assignmentAttributeStatement"}.statements[0].tap do |x|
@@ -2368,7 +2690,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2368
2690
  expect(x.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
2369
2691
  expect(x.ref.qualifiers[0].attribute).to be_instance_of(Expressir::Model::Ref)
2370
2692
  expect(x.ref.qualifiers[0].attribute.id).to eq("test")
2371
- expect(x.expression).to eq(true)
2693
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
2694
+ expect(x.expression.value).to eq(true)
2372
2695
  end
2373
2696
 
2374
2697
  functions.find{|x| x.id == "assignmentGroupStatement"}.statements[0].tap do |x|
@@ -2381,7 +2704,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2381
2704
  expect(x.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
2382
2705
  expect(x.ref.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
2383
2706
  expect(x.ref.qualifiers[0].entity.id).to eq("test")
2384
- expect(x.expression).to eq(true)
2707
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
2708
+ expect(x.expression.value).to eq(true)
2385
2709
  end
2386
2710
 
2387
2711
  functions.find{|x| x.id == "assignmentIndexStatement"}.statements[0].tap do |x|
@@ -2392,8 +2716,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
2392
2716
  expect(x.ref.qualifiers).to be_instance_of(Array)
2393
2717
  expect(x.ref.qualifiers.count).to eq(1)
2394
2718
  expect(x.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::IndexQualifier)
2395
- expect(x.ref.qualifiers[0].index1).to eq(1)
2396
- expect(x.expression).to eq(true)
2719
+ expect(x.ref.qualifiers[0].index1).to be_instance_of(Expressir::Model::Literals::Integer)
2720
+ expect(x.ref.qualifiers[0].index1.value).to eq("1")
2721
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
2722
+ expect(x.expression.value).to eq(true)
2397
2723
  end
2398
2724
 
2399
2725
  functions.find{|x| x.id == "assignmentIndex2Statement"}.statements[0].tap do |x|
@@ -2404,9 +2730,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
2404
2730
  expect(x.ref.qualifiers).to be_instance_of(Array)
2405
2731
  expect(x.ref.qualifiers.count).to eq(1)
2406
2732
  expect(x.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::IndexQualifier)
2407
- expect(x.ref.qualifiers[0].index1).to eq(1)
2408
- expect(x.ref.qualifiers[0].index2).to eq(9)
2409
- expect(x.expression).to eq(true)
2733
+ expect(x.ref.qualifiers[0].index1).to be_instance_of(Expressir::Model::Literals::Integer)
2734
+ expect(x.ref.qualifiers[0].index1.value).to eq("1")
2735
+ expect(x.ref.qualifiers[0].index2).to be_instance_of(Expressir::Model::Literals::Integer)
2736
+ expect(x.ref.qualifiers[0].index2.value).to eq("9")
2737
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
2738
+ expect(x.expression.value).to eq(true)
2410
2739
  end
2411
2740
 
2412
2741
  functions.find{|x| x.id == "caseStatement"}.statements[0].tap do |x|
@@ -2416,7 +2745,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2416
2745
  expect(x.actions).to be_instance_of(Array)
2417
2746
  expect(x.actions.count).to eq(1)
2418
2747
  expect(x.actions[0]).to be_instance_of(Expressir::Model::Statements::CaseAction)
2419
- expect(x.actions[0].label).to eq(true)
2748
+ expect(x.actions[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2749
+ expect(x.actions[0].expression.value).to eq(true)
2420
2750
  expect(x.actions[0].statement).to be_instance_of(Expressir::Model::Statements::Null)
2421
2751
  end
2422
2752
 
@@ -2427,10 +2757,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
2427
2757
  expect(x.actions).to be_instance_of(Array)
2428
2758
  expect(x.actions.count).to eq(2)
2429
2759
  expect(x.actions[0]).to be_instance_of(Expressir::Model::Statements::CaseAction)
2430
- expect(x.actions[0].label).to eq(true)
2760
+ expect(x.actions[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2761
+ expect(x.actions[0].expression.value).to eq(true)
2431
2762
  expect(x.actions[0].statement).to be_instance_of(Expressir::Model::Statements::Null)
2432
2763
  expect(x.actions[1]).to be_instance_of(Expressir::Model::Statements::CaseAction)
2433
- expect(x.actions[1].label).to eq(true)
2764
+ expect(x.actions[1].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2765
+ expect(x.actions[1].expression.value).to eq(true)
2434
2766
  expect(x.actions[1].statement).to be_instance_of(Expressir::Model::Statements::Null)
2435
2767
  end
2436
2768
 
@@ -2441,10 +2773,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
2441
2773
  expect(x.actions).to be_instance_of(Array)
2442
2774
  expect(x.actions.count).to eq(2)
2443
2775
  expect(x.actions[0]).to be_instance_of(Expressir::Model::Statements::CaseAction)
2444
- expect(x.actions[0].label).to eq(true)
2776
+ expect(x.actions[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2777
+ expect(x.actions[0].expression.value).to eq(true)
2445
2778
  expect(x.actions[0].statement).to be_instance_of(Expressir::Model::Statements::Null)
2446
2779
  expect(x.actions[1]).to be_instance_of(Expressir::Model::Statements::CaseAction)
2447
- expect(x.actions[1].label).to eq(true)
2780
+ expect(x.actions[1].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2781
+ expect(x.actions[1].expression.value).to eq(true)
2448
2782
  expect(x.actions[1].statement).to be_instance_of(Expressir::Model::Statements::Null)
2449
2783
  end
2450
2784
 
@@ -2455,7 +2789,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2455
2789
  expect(x.actions).to be_instance_of(Array)
2456
2790
  expect(x.actions.count).to eq(1)
2457
2791
  expect(x.actions[0]).to be_instance_of(Expressir::Model::Statements::CaseAction)
2458
- expect(x.actions[0].label).to eq(true)
2792
+ expect(x.actions[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
2793
+ expect(x.actions[0].expression.value).to eq(true)
2459
2794
  expect(x.actions[0].statement).to be_instance_of(Expressir::Model::Statements::Null)
2460
2795
  expect(x.otherwise_statement).to be_instance_of(Expressir::Model::Statements::Null)
2461
2796
  end
@@ -2473,7 +2808,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2473
2808
 
2474
2809
  functions.find{|x| x.id == "ifStatement"}.statements[0].tap do |x|
2475
2810
  expect(x).to be_instance_of(Expressir::Model::Statements::If)
2476
- expect(x.condition).to eq(true)
2811
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
2812
+ expect(x.expression.value).to eq(true)
2477
2813
  expect(x.statements).to be_instance_of(Array)
2478
2814
  expect(x.statements.count).to eq(1)
2479
2815
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2481,7 +2817,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2481
2817
 
2482
2818
  functions.find{|x| x.id == "if2Statement"}.statements[0].tap do |x|
2483
2819
  expect(x).to be_instance_of(Expressir::Model::Statements::If)
2484
- expect(x.condition).to eq(true)
2820
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
2821
+ expect(x.expression.value).to eq(true)
2485
2822
  expect(x.statements).to be_instance_of(Array)
2486
2823
  expect(x.statements.count).to eq(2)
2487
2824
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2490,7 +2827,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2490
2827
 
2491
2828
  functions.find{|x| x.id == "ifElseStatement"}.statements[0].tap do |x|
2492
2829
  expect(x).to be_instance_of(Expressir::Model::Statements::If)
2493
- expect(x.condition).to eq(true)
2830
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
2831
+ expect(x.expression.value).to eq(true)
2494
2832
  expect(x.statements).to be_instance_of(Array)
2495
2833
  expect(x.statements.count).to eq(1)
2496
2834
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2501,7 +2839,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2501
2839
 
2502
2840
  functions.find{|x| x.id == "if2ElseStatement"}.statements[0].tap do |x|
2503
2841
  expect(x).to be_instance_of(Expressir::Model::Statements::If)
2504
- expect(x.condition).to eq(true)
2842
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
2843
+ expect(x.expression.value).to eq(true)
2505
2844
  expect(x.statements).to be_instance_of(Array)
2506
2845
  expect(x.statements.count).to eq(2)
2507
2846
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2513,7 +2852,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2513
2852
 
2514
2853
  functions.find{|x| x.id == "ifElse2Statement"}.statements[0].tap do |x|
2515
2854
  expect(x).to be_instance_of(Expressir::Model::Statements::If)
2516
- expect(x.condition).to eq(true)
2855
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
2856
+ expect(x.expression.value).to eq(true)
2517
2857
  expect(x.statements).to be_instance_of(Array)
2518
2858
  expect(x.statements.count).to eq(1)
2519
2859
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2525,7 +2865,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2525
2865
 
2526
2866
  functions.find{|x| x.id == "if2Else2Statement"}.statements[0].tap do |x|
2527
2867
  expect(x).to be_instance_of(Expressir::Model::Statements::If)
2528
- expect(x.condition).to eq(true)
2868
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
2869
+ expect(x.expression.value).to eq(true)
2529
2870
  expect(x.statements).to be_instance_of(Array)
2530
2871
  expect(x.statements.count).to eq(2)
2531
2872
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2552,7 +2893,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2552
2893
  expect(x.procedure.id).to eq("emptyProcedure")
2553
2894
  expect(x.parameters).to be_instance_of(Array)
2554
2895
  expect(x.parameters.count).to eq(1)
2555
- expect(x.parameters[0]).to eq(true)
2896
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
2897
+ expect(x.parameters[0].value).to eq(true)
2556
2898
  end
2557
2899
 
2558
2900
  functions.find{|x| x.id == "procedureCallParameter2Statement"}.statements[0].tap do |x|
@@ -2561,8 +2903,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
2561
2903
  expect(x.procedure.id).to eq("emptyProcedure")
2562
2904
  expect(x.parameters).to be_instance_of(Array)
2563
2905
  expect(x.parameters.count).to eq(2)
2564
- expect(x.parameters[0]).to eq(true)
2565
- expect(x.parameters[1]).to eq(true)
2906
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
2907
+ expect(x.parameters[0].value).to eq(true)
2908
+ expect(x.parameters[1]).to be_instance_of(Expressir::Model::Literals::Logical)
2909
+ expect(x.parameters[1].value).to eq(true)
2566
2910
  end
2567
2911
 
2568
2912
  functions.find{|x| x.id == "procedureCallInsertStatement"}.statements[0].tap do |x|
@@ -2586,9 +2930,11 @@ RSpec.describe Expressir::ExpressExp::Parser do
2586
2930
 
2587
2931
  functions.find{|x| x.id == "repeatVariableStatement"}.statements[0].tap do |x|
2588
2932
  expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
2589
- expect(x.variable).to eq("test")
2590
- expect(x.bound1).to eq(1)
2591
- expect(x.bound2).to eq(9)
2933
+ expect(x.id).to eq("test")
2934
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
2935
+ expect(x.bound1.value).to eq("1")
2936
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
2937
+ expect(x.bound2.value).to eq("9")
2592
2938
  expect(x.statements).to be_instance_of(Array)
2593
2939
  expect(x.statements.count).to eq(1)
2594
2940
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2596,10 +2942,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
2596
2942
 
2597
2943
  functions.find{|x| x.id == "repeatVariableIncrementStatement"}.statements[0].tap do |x|
2598
2944
  expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
2599
- expect(x.variable).to eq("test")
2600
- expect(x.bound1).to eq(1)
2601
- expect(x.bound2).to eq(9)
2602
- expect(x.increment).to eq(2)
2945
+ expect(x.id).to eq("test")
2946
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
2947
+ expect(x.bound1.value).to eq("1")
2948
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
2949
+ expect(x.bound2.value).to eq("9")
2950
+ expect(x.increment).to be_instance_of(Expressir::Model::Literals::Integer)
2951
+ expect(x.increment.value).to eq("2")
2603
2952
  expect(x.statements).to be_instance_of(Array)
2604
2953
  expect(x.statements.count).to eq(1)
2605
2954
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2607,7 +2956,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2607
2956
 
2608
2957
  functions.find{|x| x.id == "repeatWhileStatement"}.statements[0].tap do |x|
2609
2958
  expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
2610
- expect(x.while_expression).to eq(true)
2959
+ expect(x.while_expression).to be_instance_of(Expressir::Model::Literals::Logical)
2960
+ expect(x.while_expression.value).to eq(true)
2611
2961
  expect(x.statements).to be_instance_of(Array)
2612
2962
  expect(x.statements.count).to eq(1)
2613
2963
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2615,7 +2965,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2615
2965
 
2616
2966
  functions.find{|x| x.id == "repeatUntilStatement"}.statements[0].tap do |x|
2617
2967
  expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
2618
- expect(x.until_expression).to eq(true)
2968
+ expect(x.until_expression).to be_instance_of(Expressir::Model::Literals::Logical)
2969
+ expect(x.until_expression.value).to eq(true)
2619
2970
  expect(x.statements).to be_instance_of(Array)
2620
2971
  expect(x.statements.count).to eq(1)
2621
2972
  expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -2623,7 +2974,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
2623
2974
 
2624
2975
  functions.find{|x| x.id == "returnStatement"}.statements[0].tap do |x|
2625
2976
  expect(x).to be_instance_of(Expressir::Model::Statements::Return)
2626
- expect(x.expression).to eq(true)
2977
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
2978
+ expect(x.expression.value).to eq(true)
2627
2979
  end
2628
2980
 
2629
2981
  functions.find{|x| x.id == "skipStatement"}.statements[0].tap do |x|