expressir 2.1.0 → 2.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (95) hide show
  1. checksums.yaml +4 -4
  2. data/.rubocop.yml +8 -13
  3. data/.rubocop_todo.yml +69 -6
  4. data/Gemfile +1 -1
  5. data/README.adoc +46 -0
  6. data/exe/expressir-format-test +2 -1
  7. data/expressir.gemspec +2 -3
  8. data/lib/expressir/express/cache.rb +6 -6
  9. data/lib/expressir/express/formatter.rb +754 -741
  10. data/lib/expressir/express/hyperlink_formatter.rb +2 -2
  11. data/lib/expressir/express/model_visitor.rb +1 -1
  12. data/lib/expressir/express/parser.rb +224 -100
  13. data/lib/expressir/express/resolve_references_model_visitor.rb +6 -6
  14. data/lib/expressir/express/schema_head_formatter.rb +3 -3
  15. data/lib/expressir/express/visitor.rb +353 -344
  16. data/lib/expressir/model/cache.rb +3 -3
  17. data/lib/expressir/model/data_type.rb +1 -1
  18. data/lib/expressir/model/data_types/aggregate.rb +3 -3
  19. data/lib/expressir/model/data_types/array.rb +6 -6
  20. data/lib/expressir/model/data_types/bag.rb +4 -4
  21. data/lib/expressir/model/data_types/binary.rb +3 -3
  22. data/lib/expressir/model/data_types/boolean.rb +1 -1
  23. data/lib/expressir/model/data_types/enumeration.rb +4 -4
  24. data/lib/expressir/model/data_types/enumeration_item.rb +2 -2
  25. data/lib/expressir/model/data_types/generic.rb +2 -2
  26. data/lib/expressir/model/data_types/generic_entity.rb +2 -2
  27. data/lib/expressir/model/data_types/integer.rb +1 -1
  28. data/lib/expressir/model/data_types/list.rb +5 -5
  29. data/lib/expressir/model/data_types/logical.rb +1 -1
  30. data/lib/expressir/model/data_types/number.rb +1 -1
  31. data/lib/expressir/model/data_types/real.rb +2 -2
  32. data/lib/expressir/model/data_types/select.rb +5 -5
  33. data/lib/expressir/model/data_types/set.rb +4 -4
  34. data/lib/expressir/model/data_types/string.rb +3 -3
  35. data/lib/expressir/model/declaration.rb +1 -1
  36. data/lib/expressir/model/declarations/attribute.rb +7 -7
  37. data/lib/expressir/model/declarations/constant.rb +4 -4
  38. data/lib/expressir/model/declarations/entity.rb +9 -9
  39. data/lib/expressir/model/declarations/function.rb +13 -13
  40. data/lib/expressir/model/declarations/interface.rb +4 -4
  41. data/lib/expressir/model/declarations/interface_item.rb +3 -3
  42. data/lib/expressir/model/declarations/interfaced_item.rb +6 -6
  43. data/lib/expressir/model/declarations/parameter.rb +4 -4
  44. data/lib/expressir/model/declarations/procedure.rb +12 -12
  45. data/lib/expressir/model/declarations/remark_item.rb +3 -3
  46. data/lib/expressir/model/declarations/rule.rb +14 -14
  47. data/lib/expressir/model/declarations/schema.rb +18 -18
  48. data/lib/expressir/model/declarations/schema_version.rb +3 -3
  49. data/lib/expressir/model/declarations/schema_version_item.rb +3 -3
  50. data/lib/expressir/model/declarations/subtype_constraint.rb +6 -6
  51. data/lib/expressir/model/declarations/type.rb +5 -5
  52. data/lib/expressir/model/declarations/unique_rule.rb +3 -3
  53. data/lib/expressir/model/declarations/variable.rb +4 -4
  54. data/lib/expressir/model/declarations/where_rule.rb +3 -3
  55. data/lib/expressir/model/expression.rb +1 -1
  56. data/lib/expressir/model/expressions/aggregate_initializer.rb +2 -2
  57. data/lib/expressir/model/expressions/aggregate_initializer_item.rb +3 -3
  58. data/lib/expressir/model/expressions/binary_expression.rb +12 -5
  59. data/lib/expressir/model/expressions/entity_constructor.rb +3 -3
  60. data/lib/expressir/model/expressions/function_call.rb +3 -3
  61. data/lib/expressir/model/expressions/interval.rb +6 -6
  62. data/lib/expressir/model/expressions/query_expression.rb +4 -4
  63. data/lib/expressir/model/expressions/unary_expression.rb +3 -3
  64. data/lib/expressir/model/identifier.rb +5 -5
  65. data/lib/expressir/model/literal.rb +1 -1
  66. data/lib/expressir/model/literals/binary.rb +2 -2
  67. data/lib/expressir/model/literals/integer.rb +2 -2
  68. data/lib/expressir/model/literals/logical.rb +2 -2
  69. data/lib/expressir/model/literals/real.rb +2 -2
  70. data/lib/expressir/model/literals/string.rb +3 -3
  71. data/lib/expressir/model/model_element.rb +35 -41
  72. data/lib/expressir/model/reference.rb +1 -1
  73. data/lib/expressir/model/references/attribute_reference.rb +3 -3
  74. data/lib/expressir/model/references/group_reference.rb +3 -3
  75. data/lib/expressir/model/references/index_reference.rb +4 -4
  76. data/lib/expressir/model/references/simple_reference.rb +3 -3
  77. data/lib/expressir/model/repository.rb +3 -4
  78. data/lib/expressir/model/statement.rb +1 -1
  79. data/lib/expressir/model/statements/alias.rb +4 -4
  80. data/lib/expressir/model/statements/assignment.rb +3 -3
  81. data/lib/expressir/model/statements/case.rb +4 -4
  82. data/lib/expressir/model/statements/case_action.rb +3 -3
  83. data/lib/expressir/model/statements/compound.rb +2 -2
  84. data/lib/expressir/model/statements/escape.rb +1 -1
  85. data/lib/expressir/model/statements/if.rb +4 -4
  86. data/lib/expressir/model/statements/null.rb +1 -1
  87. data/lib/expressir/model/statements/procedure_call.rb +3 -3
  88. data/lib/expressir/model/statements/repeat.rb +8 -8
  89. data/lib/expressir/model/statements/return.rb +2 -2
  90. data/lib/expressir/model/statements/skip.rb +1 -1
  91. data/lib/expressir/model/supertype_expression.rb +1 -1
  92. data/lib/expressir/model/supertype_expressions/binary_supertype_expression.rb +4 -4
  93. data/lib/expressir/model/supertype_expressions/oneof_supertype_expression.rb +2 -2
  94. data/lib/expressir/version.rb +1 -1
  95. metadata +12 -12
data/lib/expressir/express/formatter.rb CHANGED
@@ -3,7 +3,7 @@ require "expressir/model"
3
3
  module Expressir
4
4
  module Express
5
5
  class Formatter
6
- INDENT_CHAR = " "
6
+ INDENT_CHAR = " ".freeze
7
7
  INDENT_WIDTH = 2
8
8
  INDENT = INDENT_CHAR * INDENT_WIDTH
9
9
  OPERATOR_PRECEDENCE = {
@@ -28,11 +28,11 @@ module Expressir
28
28
  Model::Expressions::BinaryExpression::INSTANCE_NOT_EQUAL => 4,
29
29
  Model::Expressions::BinaryExpression::IN => 4,
30
30
  Model::Expressions::BinaryExpression::LIKE => 4,
31
- }
31
+ }.freeze
32
32
  SUPERTYPE_OPERATOR_PRECEDENCE = {
33
33
  Model::SupertypeExpressions::BinarySupertypeExpression::AND => 1,
34
34
  Model::SupertypeExpressions::BinarySupertypeExpression::ANDOR => 2,
35
- }
35
+ }.freeze
36
36
 
37
37
  private_constant :INDENT_CHAR
38
38
  private_constant :INDENT_WIDTH
@@ -44,7 +44,7 @@ module Expressir
44
44
  # @param [Model::ModelElement] node
45
45
  # @return [String]
46
46
  def self.format(node)
47
- formatter = self.new
47
+ formatter = new
48
48
  formatter.format(node)
49
49
  end
50
50
 
@@ -52,138 +52,139 @@ module Expressir
52
52
  # @param [Model::ModelElement] node
53
53
  # @return [String]
54
54
  def format(node)
55
- if node.is_a? Model::Repository
55
+ case node
56
+ when Model::Repository
56
57
  format_repository(node)
57
- elsif node.is_a? Model::Declarations::Attribute
58
+ when Model::Declarations::Attribute
58
59
  format_declarations_attribute(node)
59
- elsif node.is_a? Model::Declarations::Constant
60
+ when Model::Declarations::Constant
60
61
  format_declarations_constant(node)
61
- elsif node.is_a? Model::Declarations::Entity
62
+ when Model::Declarations::Entity
62
63
  format_declarations_entity(node)
63
- elsif node.is_a? Model::Declarations::Function
64
+ when Model::Declarations::Function
64
65
  format_declarations_function(node)
65
- elsif node.is_a? Model::Declarations::Interface
66
+ when Model::Declarations::Interface
66
67
  format_declarations_interface(node)
67
- elsif node.is_a? Model::Declarations::InterfaceItem
68
+ when Model::Declarations::InterfaceItem
68
69
  format_declarations_interface_item(node)
69
- elsif node.is_a? Model::Declarations::Parameter
70
+ when Model::Declarations::Parameter
70
71
  format_declarations_parameter(node)
71
- elsif node.is_a? Model::Declarations::Procedure
72
+ when Model::Declarations::Procedure
72
73
  format_declarations_procedure(node)
73
- elsif node.is_a? Model::Declarations::Rule
74
+ when Model::Declarations::Rule
74
75
  format_declarations_rule(node)
75
- elsif node.is_a? Model::Declarations::Schema
76
+ when Model::Declarations::Schema
76
77
  format_declarations_schema(node)
77
- elsif node.is_a? Model::Declarations::SchemaVersion
78
+ when Model::Declarations::SchemaVersion
78
79
  format_declarations_schema_version(node)
79
- elsif node.is_a? Model::Declarations::SubtypeConstraint
80
+ when Model::Declarations::SubtypeConstraint
80
81
  format_declarations_subtype_constraint(node)
81
- elsif node.is_a? Model::Declarations::Type
82
+ when Model::Declarations::Type
82
83
  format_declarations_type(node)
83
- elsif node.is_a? Model::Declarations::UniqueRule
84
+ when Model::Declarations::UniqueRule
84
85
  format_declarations_unique_rule(node)
85
- elsif node.is_a? Model::Declarations::Variable
86
+ when Model::Declarations::Variable
86
87
  format_declarations_variable(node)
87
- elsif node.is_a? Model::Declarations::WhereRule
88
+ when Model::Declarations::WhereRule
88
89
  format_declarations_where_rule(node)
89
- elsif node.is_a? Model::DataTypes::Aggregate
90
+ when Model::DataTypes::Aggregate
90
91
  format_data_types_aggregate(node)
91
- elsif node.is_a? Model::DataTypes::Array
92
+ when Model::DataTypes::Array
92
93
  format_data_types_array(node)
93
- elsif node.is_a? Model::DataTypes::Bag
94
+ when Model::DataTypes::Bag
94
95
  format_data_types_bag(node)
95
- elsif node.is_a? Model::DataTypes::Binary
96
+ when Model::DataTypes::Binary
96
97
  format_data_types_binary(node)
97
- elsif node.is_a? Model::DataTypes::Boolean
98
+ when Model::DataTypes::Boolean
98
99
  format_data_types_boolean(node)
99
- elsif node.is_a? Model::DataTypes::Enumeration
100
+ when Model::DataTypes::Enumeration
100
101
  format_data_types_enumeration(node)
101
- elsif node.is_a? Model::DataTypes::EnumerationItem
102
+ when Model::DataTypes::EnumerationItem
102
103
  format_data_types_enumeration_item(node)
103
- elsif node.is_a? Model::DataTypes::GenericEntity
104
+ when Model::DataTypes::GenericEntity
104
105
  format_data_types_generic_entity(node)
105
- elsif node.is_a? Model::DataTypes::Generic
106
+ when Model::DataTypes::Generic
106
107
  format_data_types_generic(node)
107
- elsif node.is_a? Model::DataTypes::Integer
108
+ when Model::DataTypes::Integer
108
109
  format_data_types_integer(node)
109
- elsif node.is_a? Model::DataTypes::List
110
+ when Model::DataTypes::List
110
111
  format_data_types_list(node)
111
- elsif node.is_a? Model::DataTypes::Logical
112
+ when Model::DataTypes::Logical
112
113
  format_data_types_logical(node)
113
- elsif node.is_a? Model::DataTypes::Number
114
+ when Model::DataTypes::Number
114
115
  format_data_types_number(node)
115
- elsif node.is_a? Model::DataTypes::Real
116
+ when Model::DataTypes::Real
116
117
  format_data_types_real(node)
117
- elsif node.is_a? Model::DataTypes::Select
118
+ when Model::DataTypes::Select
118
119
  format_data_types_select(node)
119
- elsif node.is_a? Model::DataTypes::Set
120
+ when Model::DataTypes::Set
120
121
  format_data_types_set(node)
121
- elsif node.is_a? Model::DataTypes::String
122
+ when Model::DataTypes::String
122
123
  format_data_types_string(node)
123
- elsif node.is_a? Model::Expressions::AggregateInitializer
124
+ when Model::Expressions::AggregateInitializer
124
125
  format_expressions_aggregate_initializer(node)
125
- elsif node.is_a? Model::Expressions::AggregateInitializerItem
126
+ when Model::Expressions::AggregateInitializerItem
126
127
  format_expressions_aggregate_initializer_item(node)
127
- elsif node.is_a? Model::Expressions::BinaryExpression
128
+ when Model::Expressions::BinaryExpression
128
129
  format_expressions_binary_expression(node)
129
- elsif node.is_a? Model::Expressions::EntityConstructor
130
+ when Model::Expressions::EntityConstructor
130
131
  format_expressions_entity_constructor(node)
131
- elsif node.is_a? Model::Expressions::FunctionCall
132
+ when Model::Expressions::FunctionCall
132
133
  format_expressions_function_call(node)
133
- elsif node.is_a? Model::Expressions::Interval
134
+ when Model::Expressions::Interval
134
135
  format_expressions_interval(node)
135
- elsif node.is_a? Model::Expressions::QueryExpression
136
+ when Model::Expressions::QueryExpression
136
137
  format_expressions_query_expression(node)
137
- elsif node.is_a? Model::Expressions::UnaryExpression
138
+ when Model::Expressions::UnaryExpression
138
139
  format_expressions_unary_expression(node)
139
- elsif node.is_a? Model::Literals::Binary
140
+ when Model::Literals::Binary
140
141
  format_literals_binary(node)
141
- elsif node.is_a? Model::Literals::Integer
142
+ when Model::Literals::Integer
142
143
  format_literals_integer(node)
143
- elsif node.is_a? Model::Literals::Logical
144
+ when Model::Literals::Logical
144
145
  format_literals_logical(node)
145
- elsif node.is_a? Model::Literals::Real
146
+ when Model::Literals::Real
146
147
  format_literals_real(node)
147
- elsif node.is_a? Model::Literals::String
148
+ when Model::Literals::String
148
149
  format_literals_string(node)
149
- elsif node.is_a? Model::References::AttributeReference
150
+ when Model::References::AttributeReference
150
151
  format_references_attribute_reference(node)
151
- elsif node.is_a? Model::References::GroupReference
152
+ when Model::References::GroupReference
152
153
  format_references_group_reference(node)
153
- elsif node.is_a? Model::References::IndexReference
154
+ when Model::References::IndexReference
154
155
  format_references_index_reference(node)
155
- elsif node.is_a? Model::References::SimpleReference
156
+ when Model::References::SimpleReference
156
157
  format_references_simple_reference(node)
157
- elsif node.is_a? Model::Statements::Alias
158
+ when Model::Statements::Alias
158
159
  format_statements_alias(node)
159
- elsif node.is_a? Model::Statements::Assignment
160
+ when Model::Statements::Assignment
160
161
  format_statements_assignment(node)
161
- elsif node.is_a? Model::Statements::Case
162
+ when Model::Statements::Case
162
163
  format_statements_case(node)
163
- elsif node.is_a? Model::Statements::CaseAction
164
+ when Model::Statements::CaseAction
164
165
  format_statements_case_action(node)
165
- elsif node.is_a? Model::Statements::Compound
166
+ when Model::Statements::Compound
166
167
  format_statements_compound(node)
167
- elsif node.is_a? Model::Statements::Escape
168
+ when Model::Statements::Escape
168
169
  format_statements_escape(node)
169
- elsif node.is_a? Model::Statements::If
170
+ when Model::Statements::If
170
171
  format_statements_if(node)
171
- elsif node.is_a? Model::Statements::Null
172
+ when Model::Statements::Null
172
173
  format_statements_null(node)
173
- elsif node.is_a? Model::Statements::ProcedureCall
174
+ when Model::Statements::ProcedureCall
174
175
  format_statements_procedure_call(node)
175
- elsif node.is_a? Model::Statements::Repeat
176
+ when Model::Statements::Repeat
176
177
  format_statements_repeat(node)
177
- elsif node.is_a? Model::Statements::Return
178
+ when Model::Statements::Return
178
179
  format_statements_return(node)
179
- elsif node.is_a? Model::Statements::Skip
180
+ when Model::Statements::Skip
180
181
  format_statements_skip(node)
181
- elsif node.is_a? Model::SupertypeExpressions::BinarySupertypeExpression
182
+ when Model::SupertypeExpressions::BinarySupertypeExpression
182
183
  format_supertype_expressions_binary_supertype_expression(node)
183
- elsif node.is_a? Model::SupertypeExpressions::OneofSupertypeExpression
184
+ when Model::SupertypeExpressions::OneofSupertypeExpression
184
185
  format_supertype_expressions_oneof_supertype_expression(node)
185
186
  else
186
- STDERR.puts "#{node.class.name} format not implemented"
187
+ warn "#{node.class.name} format not implemented"
187
188
  ""
188
189
  end
189
190
  end
@@ -197,47 +198,47 @@ module Expressir
197
198
  def format_declarations_attribute(node)
198
199
  [
199
200
  *if node.supertype_attribute
200
- [
201
- format(node.supertype_attribute),
202
- " ",
203
- ].join("")
204
- end,
205
- *if node.supertype_attribute and node.id
206
- [
207
- "RENAMED",
208
- " ",
209
- ].join("")
210
- end,
201
+ [
202
+ format(node.supertype_attribute),
203
+ " ",
204
+ ].join("")
205
+ end,
206
+ *if node.supertype_attribute && node.id
207
+ [
208
+ "RENAMED",
209
+ " ",
210
+ ].join("")
211
+ end,
211
212
  *if node.id
212
- [
213
- node.id,
214
- " ",
215
- ].join("")
216
- end,
213
+ [
214
+ node.id,
215
+ " ",
216
+ ].join("")
217
+ end,
217
218
  ":",
218
219
  *if node.optional
219
- [
220
- " ",
221
- "OPTIONAL",
222
- ].join("")
223
- end,
220
+ [
221
+ " ",
222
+ "OPTIONAL",
223
+ ].join("")
224
+ end,
224
225
  " ",
225
226
  format(node.type),
226
227
  *if node.kind == Model::Declarations::Attribute::DERIVED
227
- [
228
- " ",
229
- ":=",
230
- " ",
231
- format(node.expression),
232
- ].join("")
233
- elsif node.kind == Model::Declarations::Attribute::INVERSE
234
- [
235
- " ",
236
- "FOR",
237
- " ",
238
- format(node.expression),
239
- ].join("")
240
- end,
228
+ [
229
+ " ",
230
+ ":=",
231
+ " ",
232
+ format(node.expression),
233
+ ].join("")
234
+ elsif node.kind == Model::Declarations::Attribute::INVERSE
235
+ [
236
+ " ",
237
+ "FOR",
238
+ " ",
239
+ format(node.expression),
240
+ ].join("")
241
+ end,
241
242
  ";",
242
243
  ].join("")
243
244
  end
@@ -267,89 +268,89 @@ module Expressir
267
268
  "ENTITY",
268
269
  " ",
269
270
  node.id,
270
- *if node.abstract and !node.supertype_expression
271
- [
272
- "\n",
273
- indent([
274
- "ABSTRACT",
275
- " ",
276
- "SUPERTYPE",
277
- ].join("")),
278
- ].join("")
279
- end,
280
- *if node.abstract and node.supertype_expression
281
- [
282
- "\n",
283
- indent([
284
- "ABSTRACT",
285
- " ",
286
- "SUPERTYPE",
287
- " ",
288
- "OF",
289
- " ",
290
- "(",
291
- format(node.supertype_expression),
292
- ")",
293
- ].join("")),
294
- ].join("")
295
- end,
296
- *if !node.abstract and node.supertype_expression
297
- [
298
- "\n",
299
- indent([
300
- "SUPERTYPE",
301
- " ",
302
- "OF",
303
- " ",
304
- "(",
305
- format(node.supertype_expression),
306
- ")",
307
- ].join("")),
308
- ].join("")
309
- end,
310
- *if node.subtype_of.length > 0
311
- [
312
- "\n",
313
- indent([
314
- "SUBTYPE",
315
- " ",
316
- "OF",
317
- " ",
318
- "(",
319
- node.subtype_of.map { |x| format(x) }.join(", "),
320
- ")",
321
- ].join("")),
322
- ].join("")
323
- end,
271
+ *if node.abstract && !node.supertype_expression
272
+ [
273
+ "\n",
274
+ indent([
275
+ "ABSTRACT",
276
+ " ",
277
+ "SUPERTYPE",
278
+ ].join("")),
279
+ ].join("")
280
+ end,
281
+ *if node.abstract && node.supertype_expression
282
+ [
283
+ "\n",
284
+ indent([
285
+ "ABSTRACT",
286
+ " ",
287
+ "SUPERTYPE",
288
+ " ",
289
+ "OF",
290
+ " ",
291
+ "(",
292
+ format(node.supertype_expression),
293
+ ")",
294
+ ].join("")),
295
+ ].join("")
296
+ end,
297
+ *if !node.abstract && node.supertype_expression
298
+ [
299
+ "\n",
300
+ indent([
301
+ "SUPERTYPE",
302
+ " ",
303
+ "OF",
304
+ " ",
305
+ "(",
306
+ format(node.supertype_expression),
307
+ ")",
308
+ ].join("")),
309
+ ].join("")
310
+ end,
311
+ *if node.subtype_of.length.positive?
312
+ [
313
+ "\n",
314
+ indent([
315
+ "SUBTYPE",
316
+ " ",
317
+ "OF",
318
+ " ",
319
+ "(",
320
+ node.subtype_of.map { |x| format(x) }.join(", "),
321
+ ")",
322
+ ].join("")),
323
+ ].join("")
324
+ end,
324
325
  ";",
325
326
  ].join(""),
326
- *if explicit_attributes and explicit_attributes.length > 0
327
- indent(explicit_attributes.map { |x| format(x) }.join("\n"))
328
- end,
329
- *if derived_attributes and derived_attributes.length > 0
330
- [
331
- "DERIVE",
332
- indent(derived_attributes.map { |x| format(x) }.join("\n")),
333
- ]
334
- end,
335
- *if inverse_attributes and inverse_attributes.length > 0
336
- [
337
- "INVERSE",
338
- indent(inverse_attributes.map { |x| format(x) }.join("\n")),
339
- ]
340
- end,
341
- *if node.unique_rules.length > 0
342
- [
343
- "UNIQUE",
344
- indent(node.unique_rules.map { |x| format(x) }.join("\n")),
345
- ]
346
- end,
347
- *if node.where_rules.length > 0
348
- [
349
- "WHERE",
350
- indent(node.where_rules.map { |x| format(x) }.join("\n")),
351
- ]
352
- end,
327
+ *if explicit_attributes&.length&.positive?
328
+ indent(explicit_attributes.map { |x| format(x) }.join("\n"))
329
+ end,
330
+ *if derived_attributes&.length&.positive?
331
+ [
332
+ "DERIVE",
333
+ indent(derived_attributes.map { |x| format(x) }.join("\n")),
334
+ ]
335
+ end,
336
+ *if inverse_attributes&.length&.positive?
337
+ [
338
+ "INVERSE",
339
+ indent(inverse_attributes.map { |x| format(x) }.join("\n")),
340
+ ]
341
+ end,
342
+ *if node.unique_rules.length.positive?
343
+ [
344
+ "UNIQUE",
345
+ indent(node.unique_rules.map { |x| format(x) }.join("\n")),
346
+ ]
347
+ end,
348
+ *if node.where_rules.length.positive?
349
+ [
350
+ "WHERE",
351
+ indent(node.where_rules.map { |x| format(x) }.join("\n")),
352
+ ]
353
+ end,
353
354
  [
354
355
  "END_ENTITY",
355
356
  ";",
@@ -363,58 +364,58 @@ module Expressir
363
364
  "FUNCTION",
364
365
  " ",
365
366
  node.id,
366
- *if node.parameters.length > 0
367
- parameter_indent = INDENT_CHAR * "FUNCTION #{node.id}(".length
368
- [
369
- "(",
370
- node.parameters.map { |x| format(x) }.join(";\n#{parameter_indent}"),
371
- ")",
372
- ].join("")
373
- end,
367
+ *if node.parameters.length.positive?
368
+ parameter_indent = INDENT_CHAR * "FUNCTION #{node.id}(".length
369
+ [
370
+ "(",
371
+ node.parameters.map { |x| format(x) }.join(";\n#{parameter_indent}"),
372
+ ")",
373
+ ].join("")
374
+ end,
374
375
  " ",
375
376
  ":",
376
377
  " ",
377
378
  format(node.return_type),
378
379
  ";",
379
380
  ].join(""),
380
- *if node.types.length > 0
381
- indent(node.types.map { |x| format(x) }.join("\n"))
382
- end,
383
- *if node.entities.length > 0
384
- indent(node.entities.map { |x| format(x) }.join("\n"))
385
- end,
386
- *if node.subtype_constraints.length > 0
387
- indent(node.subtype_constraints.map { |x| format(x) }.join("\n"))
388
- end,
389
- *if node.functions.length > 0
390
- indent(node.functions.map { |x| format(x) }.join("\n"))
391
- end,
392
- *if node.procedures.length > 0
393
- indent(node.procedures.map { |x| format(x) }.join("\n"))
394
- end,
395
- *if node.constants.length > 0
396
- indent([
397
- "CONSTANT",
398
- indent(node.constants.map { |x| format(x) }.join("\n")),
399
- [
400
- "END_CONSTANT",
401
- ";",
402
- ].join(""),
403
- ].join("\n"))
404
- end,
405
- *if node.variables.length > 0
406
- indent([
407
- "LOCAL",
408
- indent(node.variables.map { |x| format(x) }.join("\n")),
409
- [
410
- "END_LOCAL",
411
- ";",
412
- ].join(""),
413
- ].join("\n"))
414
- end,
415
- *if node.statements.length > 0
416
- indent(node.statements.map { |x| format(x) }.join("\n"))
417
- end,
381
+ *if node.types.length.positive?
382
+ indent(node.types.map { |x| format(x) }.join("\n"))
383
+ end,
384
+ *if node.entities.length.positive?
385
+ indent(node.entities.map { |x| format(x) }.join("\n"))
386
+ end,
387
+ *if node.subtype_constraints.length.positive?
388
+ indent(node.subtype_constraints.map { |x| format(x) }.join("\n"))
389
+ end,
390
+ *if node.functions.length.positive?
391
+ indent(node.functions.map { |x| format(x) }.join("\n"))
392
+ end,
393
+ *if node.procedures.length.positive?
394
+ indent(node.procedures.map { |x| format(x) }.join("\n"))
395
+ end,
396
+ *if node.constants.length.positive?
397
+ indent([
398
+ "CONSTANT",
399
+ indent(node.constants.map { |x| format(x) }.join("\n")),
400
+ [
401
+ "END_CONSTANT",
402
+ ";",
403
+ ].join(""),
404
+ ].join("\n"))
405
+ end,
406
+ *if node.variables.length.positive?
407
+ indent([
408
+ "LOCAL",
409
+ indent(node.variables.map { |x| format(x) }.join("\n")),
410
+ [
411
+ "END_LOCAL",
412
+ ";",
413
+ ].join(""),
414
+ ].join("\n"))
415
+ end,
416
+ *if node.statements.length.positive?
417
+ indent(node.statements.map { |x| format(x) }.join("\n"))
418
+ end,
418
419
  [
419
420
  "END_FUNCTION",
420
421
  ";",
@@ -432,17 +433,17 @@ module Expressir
432
433
  "FROM",
433
434
  " ",
434
435
  format(node.schema),
435
- *if node.items.length > 0
436
- item_indent = INDENT_CHAR * "(".length
437
- [
438
- "\n",
439
- indent([
440
- "(",
441
- node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
442
- ")",
443
- ].join("")),
444
- ].join("")
445
- end,
436
+ *if node.items.length.positive?
437
+ item_indent = INDENT_CHAR * "(".length
438
+ [
439
+ "\n",
440
+ indent([
441
+ "(",
442
+ node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
443
+ ")",
444
+ ].join("")),
445
+ ].join("")
446
+ end,
446
447
  ";",
447
448
  ].join("")
448
449
  end
@@ -451,24 +452,24 @@ module Expressir
451
452
  [
452
453
  format(node.ref),
453
454
  *if node.id
454
- [
455
- " ",
456
- "AS",
457
- " ",
458
- node.id,
459
- ]
460
- end,
455
+ [
456
+ " ",
457
+ "AS",
458
+ " ",
459
+ node.id,
460
+ ]
461
+ end,
461
462
  ].join("")
462
463
  end
463
464
 
464
465
  def format_declarations_parameter(node)
465
466
  [
466
467
  *if node.var
467
- [
468
- "VAR",
469
- " ",
470
- ].join("")
471
- end,
468
+ [
469
+ "VAR",
470
+ " ",
471
+ ].join("")
472
+ end,
472
473
  node.id,
473
474
  " ",
474
475
  ":",
@@ -483,54 +484,54 @@ module Expressir
483
484
  "PROCEDURE",
484
485
  " ",
485
486
  node.id,
486
- *if node.parameters.length > 0
487
- parameter_indent = INDENT_CHAR * "PROCEDURE #{node.id}(".length
488
- [
489
- "(",
490
- node.parameters.map { |x| format(x) }.join(";\n#{parameter_indent}"),
491
- ")",
492
- ].join("")
493
- end,
487
+ *if node.parameters.length.positive?
488
+ parameter_indent = INDENT_CHAR * "PROCEDURE #{node.id}(".length
489
+ [
490
+ "(",
491
+ node.parameters.map { |x| format(x) }.join(";\n#{parameter_indent}"),
492
+ ")",
493
+ ].join("")
494
+ end,
494
495
  ";",
495
496
  ].join(""),
496
- *if node.types.length > 0
497
- indent(node.types.map { |x| format(x) }.join("\n"))
498
- end,
499
- *if node.entities.length > 0
500
- indent(node.entities.map { |x| format(x) }.join("\n"))
501
- end,
502
- *if node.subtype_constraints.length > 0
503
- indent(node.subtype_constraints.map { |x| format(x) }.join("\n"))
504
- end,
505
- *if node.functions.length > 0
506
- indent(node.functions.map { |x| format(x) }.join("\n"))
507
- end,
508
- *if node.procedures.length > 0
509
- indent(node.procedures.map { |x| format(x) }.join("\n"))
510
- end,
511
- *if node.constants.length > 0
512
- indent([
513
- "CONSTANT",
514
- indent(node.constants.map { |x| format(x) }.join("\n")),
515
- [
516
- "END_CONSTANT",
517
- ";",
518
- ].join(""),
519
- ].join("\n"))
520
- end,
521
- *if node.variables.length > 0
522
- indent([
523
- "LOCAL",
524
- indent(node.variables.map { |x| format(x) }.join("\n")),
525
- [
526
- "END_LOCAL",
527
- ";",
528
- ].join(""),
529
- ].join("\n"))
530
- end,
531
- *if node.statements.length > 0
532
- indent(node.statements.map { |x| format(x) }.join("\n"))
533
- end,
497
+ *if node.types.length.positive?
498
+ indent(node.types.map { |x| format(x) }.join("\n"))
499
+ end,
500
+ *if node.entities.length.positive?
501
+ indent(node.entities.map { |x| format(x) }.join("\n"))
502
+ end,
503
+ *if node.subtype_constraints.length.positive?
504
+ indent(node.subtype_constraints.map { |x| format(x) }.join("\n"))
505
+ end,
506
+ *if node.functions.length.positive?
507
+ indent(node.functions.map { |x| format(x) }.join("\n"))
508
+ end,
509
+ *if node.procedures.length.positive?
510
+ indent(node.procedures.map { |x| format(x) }.join("\n"))
511
+ end,
512
+ *if node.constants.length.positive?
513
+ indent([
514
+ "CONSTANT",
515
+ indent(node.constants.map { |x| format(x) }.join("\n")),
516
+ [
517
+ "END_CONSTANT",
518
+ ";",
519
+ ].join(""),
520
+ ].join("\n"))
521
+ end,
522
+ *if node.variables.length.positive?
523
+ indent([
524
+ "LOCAL",
525
+ indent(node.variables.map { |x| format(x) }.join("\n")),
526
+ [
527
+ "END_LOCAL",
528
+ ";",
529
+ ].join(""),
530
+ ].join("\n"))
531
+ end,
532
+ *if node.statements.length.positive?
533
+ indent(node.statements.map { |x| format(x) }.join("\n"))
534
+ end,
534
535
  [
535
536
  "END_PROCEDURE",
536
537
  ";",
@@ -552,50 +553,50 @@ module Expressir
552
553
  ")",
553
554
  ";",
554
555
  ].join(""),
555
- *if node.types.length > 0
556
- indent(node.types.map { |x| format(x) }.join("\n"))
557
- end,
558
- *if node.entities.length > 0
559
- indent(node.entities.map { |x| format(x) }.join("\n"))
560
- end,
561
- *if node.subtype_constraints.length > 0
562
- indent(node.subtype_constraints.map { |x| format(x) }.join("\n"))
563
- end,
564
- *if node.functions.length > 0
565
- indent(node.functions.map { |x| format(x) }.join("\n"))
566
- end,
567
- *if node.procedures.length > 0
568
- indent(node.procedures.map { |x| format(x) }.join("\n"))
569
- end,
570
- *if node.constants.length > 0
571
- indent([
572
- "CONSTANT",
573
- indent(node.constants.map { |x| format(x) }.join("\n")),
574
- [
575
- "END_CONSTANT",
576
- ";",
577
- ].join(""),
578
- ].join("\n"))
579
- end,
580
- *if node.variables.length > 0
581
- indent([
582
- "LOCAL",
583
- indent(node.variables.map { |x| format(x) }.join("\n")),
584
- [
585
- "END_LOCAL",
586
- ";",
587
- ].join(""),
588
- ].join("\n"))
589
- end,
590
- *if node.statements.length > 0
591
- indent(node.statements.map { |x| format(x) }.join("\n"))
592
- end,
593
- *if node.where_rules.length > 0
594
- [
595
- "WHERE",
596
- indent(node.where_rules.map { |x| format(x) }.join("\n")),
597
- ]
598
- end,
556
+ *if node.types.length.positive?
557
+ indent(node.types.map { |x| format(x) }.join("\n"))
558
+ end,
559
+ *if node.entities.length.positive?
560
+ indent(node.entities.map { |x| format(x) }.join("\n"))
561
+ end,
562
+ *if node.subtype_constraints.length.positive?
563
+ indent(node.subtype_constraints.map { |x| format(x) }.join("\n"))
564
+ end,
565
+ *if node.functions.length.positive?
566
+ indent(node.functions.map { |x| format(x) }.join("\n"))
567
+ end,
568
+ *if node.procedures.length.positive?
569
+ indent(node.procedures.map { |x| format(x) }.join("\n"))
570
+ end,
571
+ *if node.constants.length.positive?
572
+ indent([
573
+ "CONSTANT",
574
+ indent(node.constants.map { |x| format(x) }.join("\n")),
575
+ [
576
+ "END_CONSTANT",
577
+ ";",
578
+ ].join(""),
579
+ ].join("\n"))
580
+ end,
581
+ *if node.variables.length.positive?
582
+ indent([
583
+ "LOCAL",
584
+ indent(node.variables.map { |x| format(x) }.join("\n")),
585
+ [
586
+ "END_LOCAL",
587
+ ";",
588
+ ].join(""),
589
+ ].join("\n"))
590
+ end,
591
+ *if node.statements.length.positive?
592
+ indent(node.statements.map { |x| format(x) }.join("\n"))
593
+ end,
594
+ *if node.where_rules.length.positive?
595
+ [
596
+ "WHERE",
597
+ indent(node.where_rules.map { |x| format(x) }.join("\n")),
598
+ ]
599
+ end,
599
600
  [
600
601
  "END_RULE",
601
602
  ";",
@@ -610,63 +611,63 @@ module Expressir
610
611
  " ",
611
612
  node.id,
612
613
  *if node.version
613
- [
614
- " ",
615
- format(node.version),
616
- ].join("")
617
- end,
614
+ [
615
+ " ",
616
+ format(node.version),
617
+ ].join("")
618
+ end,
618
619
  ";",
619
620
  ].join(""),
620
- *if node.interfaces.length > 0
621
- [
622
- "",
623
- node.interfaces.map { |x| format(x) }.join("\n"),
624
- ]
625
- end,
621
+ *if node.interfaces.length.positive?
622
+ [
623
+ "",
624
+ node.interfaces.map { |x| format(x) }.join("\n"),
625
+ ]
626
+ end,
626
627
  ].join("\n")
627
628
  end
628
629
 
629
630
  def format_declarations_schema(node)
630
631
  schema_declarations = [
631
- *if node.constants.length > 0
632
- [
633
- "CONSTANT",
634
- indent(node.constants.map { |x| format(x) }.join("\n")),
635
- [
636
- "END_CONSTANT",
637
- ";",
638
- ].join(""),
639
- ].join("\n")
640
- end,
641
- *if node.types.length > 0
642
- node.types.map { |x| format(x) }
643
- end,
644
- *if node.entities.length > 0
645
- node.entities.map { |x| format(x) }
646
- end,
647
- *if node.subtype_constraints.length > 0
648
- node.subtype_constraints.map { |x| format(x) }
649
- end,
650
- *if node.functions.length > 0
651
- node.functions.map { |x| format(x) }
652
- end,
653
- *if node.rules.length > 0
654
- node.rules.map { |x| format(x) }
655
- end,
656
- *if node.procedures and node.procedures.length > 0
657
- node.procedures.map { |x| format(x) }
658
- end,
632
+ *if node.constants.length.positive?
633
+ [
634
+ "CONSTANT",
635
+ indent(node.constants.map { |x| format(x) }.join("\n")),
636
+ [
637
+ "END_CONSTANT",
638
+ ";",
639
+ ].join(""),
640
+ ].join("\n")
641
+ end,
642
+ *if node.types.length.positive?
643
+ node.types.map { |x| format(x) }
644
+ end,
645
+ *if node.entities.length.positive?
646
+ node.entities.map { |x| format(x) }
647
+ end,
648
+ *if node.subtype_constraints.length.positive?
649
+ node.subtype_constraints.map { |x| format(x) }
650
+ end,
651
+ *if node.functions.length.positive?
652
+ node.functions.map { |x| format(x) }
653
+ end,
654
+ *if node.rules.length.positive?
655
+ node.rules.map { |x| format(x) }
656
+ end,
657
+ *if node.procedures&.length&.positive?
658
+ node.procedures.map { |x| format(x) }
659
+ end,
659
660
  ]
660
661
 
661
662
  [
662
663
  format_declarations_schema_head(node),
663
- *if schema_declarations.length > 0
664
- [
665
- "",
666
- schema_declarations.join("\n\n"),
667
- "",
668
- ]
669
- end,
664
+ *if schema_declarations.length.positive?
665
+ [
666
+ "",
667
+ schema_declarations.join("\n\n"),
668
+ "",
669
+ ]
670
+ end,
670
671
  [
671
672
  "END_SCHEMA",
672
673
  ";",
@@ -696,28 +697,28 @@ module Expressir
696
697
  ";",
697
698
  ].join(""),
698
699
  *if node.abstract
699
- indent([
700
- "ABSTRACT",
701
- " ",
702
- "SUPERTYPE",
703
- ";",
704
- ].join(""))
705
- end,
706
- *if node.total_over.length > 0
707
- indent([
708
- "TOTAL_OVER",
709
- "(",
710
- node.total_over.map { |x| format(x) }.join(", "),
711
- ")",
712
- ";",
713
- ].join(""))
714
- end,
700
+ indent([
701
+ "ABSTRACT",
702
+ " ",
703
+ "SUPERTYPE",
704
+ ";",
705
+ ].join(""))
706
+ end,
707
+ *if node.total_over.length.positive?
708
+ indent([
709
+ "TOTAL_OVER",
710
+ "(",
711
+ node.total_over.map { |x| format(x) }.join(", "),
712
+ ")",
713
+ ";",
714
+ ].join(""))
715
+ end,
715
716
  *if node.supertype_expression
716
- indent([
717
- format(node.supertype_expression),
718
- ";",
719
- ].join(""))
720
- end,
717
+ indent([
718
+ format(node.supertype_expression),
719
+ ";",
720
+ ].join(""))
721
+ end,
721
722
  [
722
723
  "END_SUBTYPE_CONSTRAINT",
723
724
  ";",
@@ -737,12 +738,12 @@ module Expressir
737
738
  format(node.underlying_type),
738
739
  ";",
739
740
  ].join(""),
740
- *if node.where_rules.length > 0
741
- [
742
- "WHERE",
743
- indent(node.where_rules.map { |x| format(x) }.join("\n")),
744
- ]
745
- end,
741
+ *if node.where_rules.length.positive?
742
+ [
743
+ "WHERE",
744
+ indent(node.where_rules.map { |x| format(x) }.join("\n")),
745
+ ]
746
+ end,
746
747
  [
747
748
  "END_TYPE",
748
749
  ";",
@@ -753,12 +754,12 @@ module Expressir
753
754
  def format_declarations_unique_rule(node)
754
755
  [
755
756
  *if node.id
756
- [
757
- node.id,
758
- ":",
759
- " ",
760
- ].join("")
761
- end,
757
+ [
758
+ node.id,
759
+ ":",
760
+ " ",
761
+ ].join("")
762
+ end,
762
763
  node.attributes.map { |x| format(x) }.join(", "),
763
764
  ";",
764
765
  ].join("")
@@ -772,13 +773,13 @@ module Expressir
772
773
  " ",
773
774
  format(node.type),
774
775
  *if node.expression
775
- [
776
- " ",
777
- ":=",
778
- " ",
779
- format(node.expression),
780
- ].join("")
781
- end,
776
+ [
777
+ " ",
778
+ ":=",
779
+ " ",
780
+ format(node.expression),
781
+ ].join("")
782
+ end,
782
783
  ";",
783
784
  ].join("")
784
785
  end
@@ -786,12 +787,12 @@ module Expressir
786
787
  def format_declarations_where_rule(node)
787
788
  [
788
789
  *if node.id
789
- [
790
- node.id,
791
- ":",
792
- " ",
793
- ].join("")
794
- end,
790
+ [
791
+ node.id,
792
+ ":",
793
+ " ",
794
+ ].join("")
795
+ end,
795
796
  format(node.expression),
796
797
  ";",
797
798
  ].join("")
@@ -814,14 +815,19 @@ module Expressir
814
815
  end
815
816
 
816
817
  def format_expressions_binary_expression(node)
818
+ op1_bin_exp = node.operand1.is_a?(Model::Expressions::BinaryExpression) &&
819
+ (OPERATOR_PRECEDENCE[node.operand1.operator] > OPERATOR_PRECEDENCE[node.operator])
820
+ op2_bin_exp = node.operand2.is_a?(Model::Expressions::BinaryExpression) &&
821
+ (OPERATOR_PRECEDENCE[node.operand2.operator] > OPERATOR_PRECEDENCE[node.operator])
822
+
817
823
  [
818
- *if node.operand1.is_a? Model::Expressions::BinaryExpression and OPERATOR_PRECEDENCE[node.operand1.operator] > OPERATOR_PRECEDENCE[node.operator]
819
- "("
820
- end,
824
+ *if op1_bin_exp
825
+ "("
826
+ end,
821
827
  format(node.operand1),
822
- *if node.operand1.is_a? Model::Expressions::BinaryExpression and OPERATOR_PRECEDENCE[node.operand1.operator] > OPERATOR_PRECEDENCE[node.operator]
823
- ")"
824
- end,
828
+ *if op1_bin_exp
829
+ ")"
830
+ end,
825
831
  " ",
826
832
  case node.operator
827
833
  when Model::Expressions::BinaryExpression::ADDITION then "+"
@@ -847,13 +853,13 @@ module Expressir
847
853
  when Model::Expressions::BinaryExpression::XOR then "XOR"
848
854
  end,
849
855
  " ",
850
- *if node.operand2.is_a? Model::Expressions::BinaryExpression and OPERATOR_PRECEDENCE[node.operand2.operator] > OPERATOR_PRECEDENCE[node.operator]
851
- "("
852
- end,
856
+ *if op2_bin_exp
857
+ "("
858
+ end,
853
859
  format(node.operand2),
854
- *if node.operand2.is_a? Model::Expressions::BinaryExpression and OPERATOR_PRECEDENCE[node.operand2.operator] > OPERATOR_PRECEDENCE[node.operator]
855
- ")"
856
- end,
860
+ *if op2_bin_exp
861
+ ")"
862
+ end,
857
863
  ].join("")
858
864
  end
859
865
 
@@ -910,7 +916,7 @@ module Expressir
910
916
  "|",
911
917
  " ",
912
918
  format(node.expression),
913
- *format_remarks(node).instance_eval { |x| x.length > 0 ? ["\n", *x, "\n"] : x },
919
+ *format_remarks(node).instance_eval { |x| x.length.positive? ? ["\n", *x, "\n"] : x },
914
920
  ")",
915
921
  ].join("")
916
922
  end
@@ -926,12 +932,12 @@ module Expressir
926
932
  " "
927
933
  end,
928
934
  *if node.operand.is_a? Model::Expressions::BinaryExpression
929
- "("
930
- end,
935
+ "("
936
+ end,
931
937
  format(node.operand),
932
938
  *if node.operand.is_a? Model::Expressions::BinaryExpression
933
- ")"
934
- end,
939
+ ")"
940
+ end,
935
941
  ].join("")
936
942
  end
937
943
 
@@ -985,7 +991,7 @@ module Expressir
985
991
  def format_references_group_reference(node)
986
992
  [
987
993
  format(node.ref),
988
- '\\',
994
+ "\\",
989
995
  format(node.entity),
990
996
  ].join("")
991
997
  end
@@ -996,11 +1002,11 @@ module Expressir
996
1002
  "[",
997
1003
  format(node.index1),
998
1004
  *if node.index2
999
- [
1000
- ":",
1001
- format(node.index2),
1002
- ].join("")
1003
- end,
1005
+ [
1006
+ ":",
1007
+ format(node.index2),
1008
+ ].join("")
1009
+ end,
1004
1010
  "]",
1005
1011
  ].join("")
1006
1012
  end
@@ -1021,9 +1027,9 @@ module Expressir
1021
1027
  format(node.expression),
1022
1028
  ";",
1023
1029
  ].join(""),
1024
- *if node.statements.length > 0
1025
- indent(node.statements.map { |x| format(x) }.join("\n"))
1026
- end,
1030
+ *if node.statements.length.positive?
1031
+ indent(node.statements.map { |x| format(x) }.join("\n"))
1032
+ end,
1027
1033
  *format_remarks(node),
1028
1034
  [
1029
1035
  "END_ALIAS",
@@ -1046,13 +1052,13 @@ module Expressir
1046
1052
  def format_statements_procedure_call(node)
1047
1053
  [
1048
1054
  format(node.procedure),
1049
- *if node.parameters.length > 0
1050
- [
1051
- "(",
1052
- node.parameters.map { |x| format(x) }.join(", "),
1053
- ")",
1054
- ].join("")
1055
- end,
1055
+ *if node.parameters.length.positive?
1056
+ [
1057
+ "(",
1058
+ node.parameters.map { |x| format(x) }.join(", "),
1059
+ ")",
1060
+ ].join("")
1061
+ end,
1056
1062
  ";",
1057
1063
  ].join("")
1058
1064
  end
@@ -1066,19 +1072,19 @@ module Expressir
1066
1072
  " ",
1067
1073
  "OF",
1068
1074
  ].join(""),
1069
- *if node.actions.length > 0
1070
- node.actions.map { |x| format(x) }
1071
- end,
1075
+ *if node.actions.length.positive?
1076
+ node.actions.map { |x| format(x) }
1077
+ end,
1072
1078
  *if node.otherwise_statement
1073
- [
1074
- [
1075
- "OTHERWISE",
1076
- " ",
1077
- ":",
1078
- ].join(""),
1079
- indent(format(node.otherwise_statement)),
1080
- ]
1081
- end,
1079
+ [
1080
+ [
1081
+ "OTHERWISE",
1082
+ " ",
1083
+ ":",
1084
+ ].join(""),
1085
+ indent(format(node.otherwise_statement)),
1086
+ ]
1087
+ end,
1082
1088
  [
1083
1089
  "END_CASE",
1084
1090
  ";",
@@ -1100,9 +1106,9 @@ module Expressir
1100
1106
  def format_statements_compound(node)
1101
1107
  [
1102
1108
  "BEGIN",
1103
- *if node.statements.length > 0
1104
- indent(node.statements.map { |x| format(x) }.join("\n"))
1105
- end,
1109
+ *if node.statements.length.positive?
1110
+ indent(node.statements.map { |x| format(x) }.join("\n"))
1111
+ end,
1106
1112
  [
1107
1113
  "END",
1108
1114
  ";",
@@ -1110,7 +1116,7 @@ module Expressir
1110
1116
  ].join("\n")
1111
1117
  end
1112
1118
 
1113
- def format_statements_escape(node)
1119
+ def format_statements_escape(_node)
1114
1120
  [
1115
1121
  "ESCAPE",
1116
1122
  ";",
@@ -1126,15 +1132,15 @@ module Expressir
1126
1132
  " ",
1127
1133
  "THEN",
1128
1134
  ].join(""),
1129
- *if node.statements.length > 0
1130
- indent(node.statements.map { |x| format(x) }.join("\n"))
1131
- end,
1132
- *if node.else_statements.length > 0
1133
- [
1134
- "ELSE",
1135
- indent(node.else_statements.map { |x| format(x) }.join("\n")),
1136
- ].join("\n")
1137
- end,
1135
+ *if node.statements.length.positive?
1136
+ indent(node.statements.map { |x| format(x) }.join("\n"))
1137
+ end,
1138
+ *if node.else_statements.length.positive?
1139
+ [
1140
+ "ELSE",
1141
+ indent(node.else_statements.map { |x| format(x) }.join("\n")),
1142
+ ].join("\n")
1143
+ end,
1138
1144
  [
1139
1145
  "END_IF",
1140
1146
  ";",
@@ -1142,7 +1148,7 @@ module Expressir
1142
1148
  ].join("\n")
1143
1149
  end
1144
1150
 
1145
- def format_statements_null(node)
1151
+ def format_statements_null(_node)
1146
1152
  ";"
1147
1153
  end
1148
1154
 
@@ -1151,48 +1157,48 @@ module Expressir
1151
1157
  [
1152
1158
  "REPEAT",
1153
1159
  *if node.id
1154
- [
1155
- " ",
1156
- node.id,
1157
- " ",
1158
- ":=",
1159
- " ",
1160
- format(node.bound1),
1161
- " ",
1162
- "TO",
1163
- " ",
1164
- format(node.bound2),
1165
- *if node.increment
1166
- [
1167
- " ",
1168
- "BY",
1169
- " ",
1170
- format(node.increment),
1171
- ].join("")
1172
- end,
1173
- ].join("")
1174
- end,
1160
+ [
1161
+ " ",
1162
+ node.id,
1163
+ " ",
1164
+ ":=",
1165
+ " ",
1166
+ format(node.bound1),
1167
+ " ",
1168
+ "TO",
1169
+ " ",
1170
+ format(node.bound2),
1171
+ *if node.increment
1172
+ [
1173
+ " ",
1174
+ "BY",
1175
+ " ",
1176
+ format(node.increment),
1177
+ ].join("")
1178
+ end,
1179
+ ].join("")
1180
+ end,
1175
1181
  *if node.while_expression
1176
- [
1177
- " ",
1178
- "WHILE",
1179
- " ",
1180
- format(node.while_expression),
1181
- ].join("")
1182
- end,
1182
+ [
1183
+ " ",
1184
+ "WHILE",
1185
+ " ",
1186
+ format(node.while_expression),
1187
+ ].join("")
1188
+ end,
1183
1189
  *if node.until_expression
1184
- [
1185
- " ",
1186
- "UNTIL",
1187
- " ",
1188
- format(node.until_expression),
1189
- ].join("")
1190
- end,
1190
+ [
1191
+ " ",
1192
+ "UNTIL",
1193
+ " ",
1194
+ format(node.until_expression),
1195
+ ].join("")
1196
+ end,
1191
1197
  ";",
1192
1198
  ].join(""),
1193
- *if node.statements.length > 0
1194
- indent(node.statements.map { |x| format(x) }.join("\n"))
1195
- end,
1199
+ *if node.statements.length.positive?
1200
+ indent(node.statements.map { |x| format(x) }.join("\n"))
1201
+ end,
1196
1202
  *format_remarks(node),
1197
1203
  [
1198
1204
  "END_REPEAT",
@@ -1205,18 +1211,18 @@ module Expressir
1205
1211
  [
1206
1212
  "RETURN",
1207
1213
  *if node.expression
1208
- [
1209
- " ",
1210
- "(",
1211
- format(node.expression),
1212
- ")",
1213
- ].join("")
1214
- end,
1214
+ [
1215
+ " ",
1216
+ "(",
1217
+ format(node.expression),
1218
+ ")",
1219
+ ].join("")
1220
+ end,
1215
1221
  ";",
1216
1222
  ].join("")
1217
1223
  end
1218
1224
 
1219
- def format_statements_skip(node)
1225
+ def format_statements_skip(_node)
1220
1226
  [
1221
1227
  "SKIP",
1222
1228
  ";",
@@ -1224,27 +1230,32 @@ module Expressir
1224
1230
  end
1225
1231
 
1226
1232
  def format_supertype_expressions_binary_supertype_expression(node)
1233
+ op1_higher_precedence = node.operand1.is_a?(Model::SupertypeExpressions::BinarySupertypeExpression) &&
1234
+ (SUPERTYPE_OPERATOR_PRECEDENCE[node.operand1.operator] > SUPERTYPE_OPERATOR_PRECEDENCE[node.operator])
1235
+ op2_higher_precedence = node.operand2.is_a?(Model::SupertypeExpressions::BinarySupertypeExpression) &&
1236
+ (SUPERTYPE_OPERATOR_PRECEDENCE[node.operand2.operator] > SUPERTYPE_OPERATOR_PRECEDENCE[node.operator])
1237
+
1227
1238
  [
1228
- *if node.operand1.is_a? Model::SupertypeExpressions::BinarySupertypeExpression and SUPERTYPE_OPERATOR_PRECEDENCE[node.operand1.operator] > SUPERTYPE_OPERATOR_PRECEDENCE[node.operator]
1229
- "("
1230
- end,
1239
+ *if op1_higher_precedence
1240
+ "("
1241
+ end,
1231
1242
  format(node.operand1),
1232
- *if node.operand1.is_a? Model::SupertypeExpressions::BinarySupertypeExpression and SUPERTYPE_OPERATOR_PRECEDENCE[node.operand1.operator] > SUPERTYPE_OPERATOR_PRECEDENCE[node.operator]
1233
- ")"
1234
- end,
1243
+ *if op1_higher_precedence
1244
+ ")"
1245
+ end,
1235
1246
  " ",
1236
1247
  case node.operator
1237
1248
  when Model::SupertypeExpressions::BinarySupertypeExpression::AND then "AND"
1238
1249
  when Model::SupertypeExpressions::BinarySupertypeExpression::ANDOR then "ANDOR"
1239
1250
  end,
1240
1251
  " ",
1241
- *if node.operand2.is_a? Model::SupertypeExpressions::BinarySupertypeExpression and SUPERTYPE_OPERATOR_PRECEDENCE[node.operand2.operator] > SUPERTYPE_OPERATOR_PRECEDENCE[node.operator]
1242
- "("
1243
- end,
1252
+ *if op2_higher_precedence
1253
+ "("
1254
+ end,
1244
1255
  format(node.operand2),
1245
- *if node.operand2.is_a? Model::SupertypeExpressions::BinarySupertypeExpression and SUPERTYPE_OPERATOR_PRECEDENCE[node.operand2.operator] > SUPERTYPE_OPERATOR_PRECEDENCE[node.operator]
1246
- ")"
1247
- end,
1256
+ *if op2_higher_precedence
1257
+ ")"
1258
+ end,
1248
1259
  ].join("")
1249
1260
  end
1250
1261
 
@@ -1257,37 +1268,37 @@ module Expressir
1257
1268
  ].join("")
1258
1269
  end
1259
1270
 
1260
- def format_data_types_aggregate(node)
1271
+ def format_data_types_aggregate(_node)
1261
1272
  "AGGREGATE"
1262
1273
  end
1263
1274
 
1264
1275
  def format_data_types_array(node)
1265
1276
  [
1266
1277
  "ARRAY",
1267
- *if node.bound1 and node.bound2
1268
- [
1269
- " ",
1270
- "[",
1271
- format(node.bound1),
1272
- ":",
1273
- format(node.bound2),
1274
- "]",
1275
- ].join("")
1276
- end,
1278
+ *if node.bound1 && node.bound2
1279
+ [
1280
+ " ",
1281
+ "[",
1282
+ format(node.bound1),
1283
+ ":",
1284
+ format(node.bound2),
1285
+ "]",
1286
+ ].join("")
1287
+ end,
1277
1288
  " ",
1278
1289
  "OF",
1279
1290
  *if node.optional
1280
- [
1281
- " ",
1282
- "OPTIONAL",
1283
- ].join("")
1284
- end,
1291
+ [
1292
+ " ",
1293
+ "OPTIONAL",
1294
+ ].join("")
1295
+ end,
1285
1296
  *if node.unique
1286
- [
1287
- " ",
1288
- "UNIQUE",
1289
- ].join("")
1290
- end,
1297
+ [
1298
+ " ",
1299
+ "UNIQUE",
1300
+ ].join("")
1301
+ end,
1291
1302
  " ",
1292
1303
  format(node.base_type),
1293
1304
  ].join("")
@@ -1296,16 +1307,16 @@ module Expressir
1296
1307
  def format_data_types_bag(node)
1297
1308
  [
1298
1309
  "BAG",
1299
- *if node.bound1 and node.bound2
1300
- [
1301
- " ",
1302
- "[",
1303
- format(node.bound1),
1304
- ":",
1305
- format(node.bound2),
1306
- "]",
1307
- ].join("")
1308
- end,
1310
+ *if node.bound1 && node.bound2
1311
+ [
1312
+ " ",
1313
+ "[",
1314
+ format(node.bound1),
1315
+ ":",
1316
+ format(node.bound2),
1317
+ "]",
1318
+ ].join("")
1319
+ end,
1309
1320
  " ",
1310
1321
  "OF",
1311
1322
  " ",
@@ -1317,72 +1328,72 @@ module Expressir
1317
1328
  [
1318
1329
  "BINARY",
1319
1330
  *if node.width
1320
- [
1321
- " ",
1322
- "(",
1323
- format(node.width),
1324
- ")",
1325
- ].join("")
1326
- end,
1331
+ [
1332
+ " ",
1333
+ "(",
1334
+ format(node.width),
1335
+ ")",
1336
+ ].join("")
1337
+ end,
1327
1338
  *if node.fixed
1328
- [
1329
- " ",
1330
- "FIXED",
1331
- ].join("")
1332
- end,
1339
+ [
1340
+ " ",
1341
+ "FIXED",
1342
+ ].join("")
1343
+ end,
1333
1344
  ].join("")
1334
1345
  end
1335
1346
 
1336
- def format_data_types_boolean(node)
1347
+ def format_data_types_boolean(_node)
1337
1348
  "BOOLEAN"
1338
1349
  end
1339
1350
 
1340
1351
  def format_data_types_enumeration(node)
1341
1352
  [
1342
1353
  *if node.extensible
1343
- [
1344
- "EXTENSIBLE",
1345
- " ",
1346
- ].join("")
1347
- end,
1354
+ [
1355
+ "EXTENSIBLE",
1356
+ " ",
1357
+ ].join("")
1358
+ end,
1348
1359
  "ENUMERATION",
1349
1360
  *if node.based_on
1350
- [
1351
- " ",
1352
- "BASED_ON",
1353
- " ",
1354
- format(node.based_on),
1355
- *if node.items.length > 0
1356
- item_indent = INDENT_CHAR * "(".length
1357
- [
1358
- " ",
1359
- "WITH",
1360
- "\n",
1361
- indent([
1362
- "(",
1363
- node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
1364
- ")",
1365
- ].join("")),
1366
- ].join("")
1367
- end,
1368
- ].join("")
1369
- else
1370
- [
1371
- *if node.items.length > 0
1372
- item_indent = INDENT_CHAR * "(".length
1373
- [
1374
- " ",
1375
- "OF",
1376
- "\n",
1377
- indent([
1378
- "(",
1379
- node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
1380
- ")",
1381
- ].join("")),
1382
- ].join("")
1383
- end,
1384
- ].join("")
1385
- end,
1361
+ [
1362
+ " ",
1363
+ "BASED_ON",
1364
+ " ",
1365
+ format(node.based_on),
1366
+ *if node.items.length.positive?
1367
+ item_indent = INDENT_CHAR * "(".length
1368
+ [
1369
+ " ",
1370
+ "WITH",
1371
+ "\n",
1372
+ indent([
1373
+ "(",
1374
+ node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
1375
+ ")",
1376
+ ].join("")),
1377
+ ].join("")
1378
+ end,
1379
+ ].join("")
1380
+ else
1381
+ [
1382
+ *if node.items.length.positive?
1383
+ item_indent = INDENT_CHAR * "(".length
1384
+ [
1385
+ " ",
1386
+ "OF",
1387
+ "\n",
1388
+ indent([
1389
+ "(",
1390
+ node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
1391
+ ")",
1392
+ ].join("")),
1393
+ ].join("")
1394
+ end,
1395
+ ].join("")
1396
+ end,
1386
1397
  ].join("")
1387
1398
  end
1388
1399
 
@@ -1394,11 +1405,11 @@ module Expressir
1394
1405
  [
1395
1406
  "GENERIC_ENTITY",
1396
1407
  *if node.id
1397
- [
1398
- ":",
1399
- node.id,
1400
- ]
1401
- end,
1408
+ [
1409
+ ":",
1410
+ node.id,
1411
+ ]
1412
+ end,
1402
1413
  ].join("")
1403
1414
  end
1404
1415
 
@@ -1406,49 +1417,49 @@ module Expressir
1406
1417
  [
1407
1418
  "GENERIC",
1408
1419
  *if node.id
1409
- [
1410
- ":",
1411
- node.id,
1412
- ]
1413
- end,
1420
+ [
1421
+ ":",
1422
+ node.id,
1423
+ ]
1424
+ end,
1414
1425
  ].join("")
1415
1426
  end
1416
1427
 
1417
- def format_data_types_integer(node)
1428
+ def format_data_types_integer(_node)
1418
1429
  "INTEGER"
1419
1430
  end
1420
1431
 
1421
1432
  def format_data_types_list(node)
1422
1433
  [
1423
1434
  "LIST",
1424
- *if node.bound1 and node.bound2
1425
- [
1426
- " ",
1427
- "[",
1428
- format(node.bound1),
1429
- ":",
1430
- format(node.bound2),
1431
- "]",
1432
- ].join("")
1433
- end,
1435
+ *if node.bound1 && node.bound2
1436
+ [
1437
+ " ",
1438
+ "[",
1439
+ format(node.bound1),
1440
+ ":",
1441
+ format(node.bound2),
1442
+ "]",
1443
+ ].join("")
1444
+ end,
1434
1445
  " ",
1435
1446
  "OF",
1436
1447
  *if node.unique
1437
- [
1438
- " ",
1439
- "UNIQUE",
1440
- ].join("")
1441
- end,
1448
+ [
1449
+ " ",
1450
+ "UNIQUE",
1451
+ ].join("")
1452
+ end,
1442
1453
  " ",
1443
1454
  format(node.base_type),
1444
1455
  ].join("")
1445
1456
  end
1446
1457
 
1447
- def format_data_types_logical(node)
1458
+ def format_data_types_logical(_node)
1448
1459
  "LOGICAL"
1449
1460
  end
1450
1461
 
1451
- def format_data_types_number(node)
1462
+ def format_data_types_number(_node)
1452
1463
  "NUMBER"
1453
1464
  end
1454
1465
 
@@ -1456,82 +1467,82 @@ module Expressir
1456
1467
  [
1457
1468
  "REAL",
1458
1469
  *if node.precision
1459
- [
1460
- " ",
1461
- "(",
1462
- format(node.precision),
1463
- ")",
1464
- ].join("")
1465
- end,
1470
+ [
1471
+ " ",
1472
+ "(",
1473
+ format(node.precision),
1474
+ ")",
1475
+ ].join("")
1476
+ end,
1466
1477
  ].join("")
1467
1478
  end
1468
1479
 
1469
1480
  def format_data_types_select(node)
1470
1481
  [
1471
1482
  *if node.extensible
1472
- [
1473
- "EXTENSIBLE",
1474
- " ",
1475
- ].join("")
1476
- end,
1483
+ [
1484
+ "EXTENSIBLE",
1485
+ " ",
1486
+ ].join("")
1487
+ end,
1477
1488
  *if node.generic_entity
1478
- [
1479
- "GENERIC_ENTITY",
1480
- " ",
1481
- ].join("")
1482
- end,
1489
+ [
1490
+ "GENERIC_ENTITY",
1491
+ " ",
1492
+ ].join("")
1493
+ end,
1483
1494
  "SELECT",
1484
1495
  *if node.based_on
1485
- [
1486
- " ",
1487
- "BASED_ON",
1488
- " ",
1489
- format(node.based_on),
1490
- *if node.items.length > 0
1491
- item_indent = INDENT_CHAR * "(".length
1492
- [
1493
- " ",
1494
- "WITH",
1495
- "\n",
1496
- indent([
1497
- "(",
1498
- node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
1499
- ")",
1500
- ].join("")),
1501
- ].join("")
1502
- end,
1503
- ].join("")
1504
- else
1505
- [
1506
- *if node.items.length > 0
1507
- item_indent = INDENT_CHAR * "(".length
1508
- [
1509
- "\n",
1510
- indent([
1511
- "(",
1512
- node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
1513
- ")",
1514
- ].join("")),
1515
- ].join("")
1516
- end,
1517
- ].join("")
1518
- end,
1496
+ [
1497
+ " ",
1498
+ "BASED_ON",
1499
+ " ",
1500
+ format(node.based_on),
1501
+ *if node.items.length.positive?
1502
+ item_indent = INDENT_CHAR * "(".length
1503
+ [
1504
+ " ",
1505
+ "WITH",
1506
+ "\n",
1507
+ indent([
1508
+ "(",
1509
+ node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
1510
+ ")",
1511
+ ].join("")),
1512
+ ].join("")
1513
+ end,
1514
+ ].join("")
1515
+ else
1516
+ [
1517
+ *if node.items.length.positive?
1518
+ item_indent = INDENT_CHAR * "(".length
1519
+ [
1520
+ "\n",
1521
+ indent([
1522
+ "(",
1523
+ node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
1524
+ ")",
1525
+ ].join("")),
1526
+ ].join("")
1527
+ end,
1528
+ ].join("")
1529
+ end,
1519
1530
  ].join("")
1520
1531
  end
1521
1532
 
1522
1533
  def format_data_types_set(node)
1523
1534
  [
1524
1535
  "SET",
1525
- *if node.bound1 and node.bound2
1526
- [
1527
- " ",
1528
- "[",
1529
- format(node.bound1),
1530
- ":",
1531
- format(node.bound2),
1532
- "]",
1533
- ].join("")
1534
- end,
1536
+ *if node.bound1 && node.bound2
1537
+ [
1538
+ " ",
1539
+ "[",
1540
+ format(node.bound1),
1541
+ ":",
1542
+ format(node.bound2),
1543
+ "]",
1544
+ ].join("")
1545
+ end,
1535
1546
  " ",
1536
1547
  "OF",
1537
1548
  " ",
@@ -1543,19 +1554,19 @@ module Expressir
1543
1554
  [
1544
1555
  "STRING",
1545
1556
  *if node.width
1546
- [
1547
- " ",
1548
- "(",
1549
- format(node.width),
1550
- ")",
1551
- ].join("")
1552
- end,
1557
+ [
1558
+ " ",
1559
+ "(",
1560
+ format(node.width),
1561
+ ")",
1562
+ ].join("")
1563
+ end,
1553
1564
  *if node.fixed
1554
- [
1555
- " ",
1556
- "FIXED",
1557
- ].join("")
1558
- end,
1565
+ [
1566
+ " ",
1567
+ "FIXED",
1568
+ ].join("")
1569
+ end,
1559
1570
  ].join("")
1560
1571
  end
1561
1572
 
@@ -1600,7 +1611,9 @@ module Expressir
1600
1611
  def format_scope_remarks(node)
1601
1612
  [
1602
1613
  *format_remarks(node),
1603
- *node.children.select { |x| !x.is_a? Model::DataTypes::EnumerationItem or node.is_a? Model::Declarations::Type }.flat_map { |x| format_scope_remarks(x) },
1614
+ *node.children.select do |x|
1615
+ !x.is_a? Model::DataTypes::EnumerationItem or node.is_a? Model::Declarations::Type
1616
+ end.flat_map { |x| format_scope_remarks(x) },
1604
1617
  ]
1605
1618
  end
1606
1619
  end