expressir 1.4.2 → 2.0.0

data/lib/expressir/express/formatter.rb

@@ -1,9 +1,9 @@
-require 'expressir/model'
+require "expressir/model"
 
 module Expressir
   module Express
     class Formatter
-      INDENT_CHAR = ' '
+      INDENT_CHAR = " "
       INDENT_WIDTH = 2
       INDENT = INDENT_CHAR * INDENT_WIDTH
       OPERATOR_PRECEDENCE = {
@@ -184,14 +184,14 @@ module Expressir
           format_supertype_expressions_oneof_supertype_expression(node)
         else
           STDERR.puts "#{node.class.name} format not implemented"
-          ''
+          ""
         end
       end
 
       private
 
       def format_repository(node)
-        node.schemas.map{|x| format(x)}.join("\n\n")
+        node.schemas.map { |x| format(x) }.join("\n\n")
       end
 
       def format_declarations_attribute(node)
@@ -199,252 +199,252 @@ module Expressir
           *if node.supertype_attribute
             [
               format(node.supertype_attribute),
-              ' ',
-            ].join('')
+              " ",
+            ].join("")
           end,
           *if node.supertype_attribute and node.id
             [
-              'RENAMED',
-              ' '
-            ].join('')
+              "RENAMED",
+              " ",
+            ].join("")
           end,
           *if node.id
             [
               node.id,
-              ' '
-            ].join('')
+              " ",
+            ].join("")
           end,
-          ':',
+          ":",
           *if node.optional
             [
-              ' ',
-              'OPTIONAL'
-            ].join('')
+              " ",
+              "OPTIONAL",
+            ].join("")
           end,
-          ' ',
+          " ",
           format(node.type),
           *if node.kind == Model::Declarations::Attribute::DERIVED
             [
-              ' ',
-              ':=',
-              ' ',
-              format(node.expression)
-            ].join('')
+              " ",
+              ":=",
+              " ",
+              format(node.expression),
+            ].join("")
           elsif node.kind == Model::Declarations::Attribute::INVERSE
             [
-              ' ',
-              'FOR',
-              ' ',
-              format(node.expression)
-            ].join('')
+              " ",
+              "FOR",
+              " ",
+              format(node.expression),
+            ].join("")
           end,
-          ';',
-        ].join('')
+          ";",
+        ].join("")
       end
 
       def format_declarations_constant(node)
         [
           node.id,
-          ' ',
-          ':',
-          ' ',
+          " ",
+          ":",
+          " ",
           format(node.type),
-          ' ',
-          ':=',
-          ' ',
+          " ",
+          ":=",
+          " ",
           format(node.expression),
-          ';'
-        ].join('')
+          ";",
+        ].join("")
       end
 
       def format_declarations_entity(node)
-        explicit_attributes = node.attributes.select{|x| x.kind == Model::Declarations::Attribute::EXPLICIT}
-        derived_attributes = node.attributes.select{|x| x.kind == Model::Declarations::Attribute::DERIVED}
-        inverse_attributes = node.attributes.select{|x| x.kind == Model::Declarations::Attribute::INVERSE}
+        explicit_attributes = node.attributes.select { |x| x.kind == Model::Declarations::Attribute::EXPLICIT }
+        derived_attributes = node.attributes.select { |x| x.kind == Model::Declarations::Attribute::DERIVED }
+        inverse_attributes = node.attributes.select { |x| x.kind == Model::Declarations::Attribute::INVERSE }
 
         [
           [
-            'ENTITY',
-            ' ',
+            "ENTITY",
+            " ",
             node.id,
             *if node.abstract and !node.supertype_expression
               [
                 "\n",
                 indent([
-                  'ABSTRACT',
-                  ' ',
-                  'SUPERTYPE'
-                ].join(''))
-              ].join('')
+                  "ABSTRACT",
+                  " ",
+                  "SUPERTYPE",
+                ].join("")),
+              ].join("")
             end,
             *if node.abstract and node.supertype_expression
               [
                 "\n",
                 indent([
-                  'ABSTRACT',
-                  ' ',
-                  'SUPERTYPE',
-                  ' ',
-                  'OF',
-                  ' ',
-                  '(',
+                  "ABSTRACT",
+                  " ",
+                  "SUPERTYPE",
+                  " ",
+                  "OF",
+                  " ",
+                  "(",
                   format(node.supertype_expression),
-                  ')'
-                ].join(''))
-              ].join('')
+                  ")",
+                ].join("")),
+              ].join("")
             end,
             *if !node.abstract and node.supertype_expression
               [
                 "\n",
                 indent([
-                  'SUPERTYPE',
-                  ' ',
-                  'OF',
-                  ' ',
-                  '(',
+                  "SUPERTYPE",
+                  " ",
+                  "OF",
+                  " ",
+                  "(",
                   format(node.supertype_expression),
-                  ')'
-                ].join(''))
-              ].join('')
+                  ")",
+                ].join("")),
+              ].join("")
             end,
             *if node.subtype_of.length > 0
               [
                 "\n",
                 indent([
-                  'SUBTYPE',
-                  ' ',
-                  'OF',
-                  ' ',
-                  '(',
-                  node.subtype_of.map{|x| format(x)}.join(', '),
-                  ')'
-                ].join(''))
-              ].join('')
+                  "SUBTYPE",
+                  " ",
+                  "OF",
+                  " ",
+                  "(",
+                  node.subtype_of.map { |x| format(x) }.join(", "),
+                  ")",
+                ].join("")),
+              ].join("")
             end,
-            ';'
-          ].join(''),
+            ";",
+          ].join(""),
           *if explicit_attributes and explicit_attributes.length > 0
-            indent(explicit_attributes.map{|x| format(x)}.join("\n"))
+            indent(explicit_attributes.map { |x| format(x) }.join("\n"))
           end,
           *if derived_attributes and derived_attributes.length > 0
             [
-              'DERIVE',
-              indent(derived_attributes.map{|x| format(x)}.join("\n")),
+              "DERIVE",
+              indent(derived_attributes.map { |x| format(x) }.join("\n")),
             ]
           end,
           *if inverse_attributes and inverse_attributes.length > 0
             [
-              'INVERSE',
-              indent(inverse_attributes.map{|x| format(x)}.join("\n")),
+              "INVERSE",
+              indent(inverse_attributes.map { |x| format(x) }.join("\n")),
             ]
           end,
           *if node.unique_rules.length > 0
             [
-              'UNIQUE',
-              indent(node.unique_rules.map{|x| format(x)}.join("\n"))
+              "UNIQUE",
+              indent(node.unique_rules.map { |x| format(x) }.join("\n")),
             ]
           end,
           *if node.where_rules.length > 0
             [
-              'WHERE',
-              indent(node.where_rules.map{|x| format(x)}.join("\n")),
+              "WHERE",
+              indent(node.where_rules.map { |x| format(x) }.join("\n")),
             ]
           end,
           [
-            'END_ENTITY',
-            ';'
-          ].join('')
+            "END_ENTITY",
+            ";",
+          ].join(""),
         ].join("\n")
       end
 
       def format_declarations_function(node)
         [
           [
-            'FUNCTION',
-            ' ',
+            "FUNCTION",
+            " ",
             node.id,
             *if node.parameters.length > 0
               parameter_indent = INDENT_CHAR * "FUNCTION #{node.id}(".length
               [
-                '(',
-                node.parameters.map{|x| format(x)}.join(";\n#{parameter_indent}"),
-                ')'
-              ].join('')
+                "(",
+                node.parameters.map { |x| format(x) }.join(";\n#{parameter_indent}"),
+                ")",
+              ].join("")
             end,
-            ' ',
-            ':',
-            ' ',
+            " ",
+            ":",
+            " ",
             format(node.return_type),
-            ';'
-          ].join(''),
+            ";",
+          ].join(""),
           *if node.types.length > 0
-            indent(node.types.map{|x| format(x)}.join("\n"))
+            indent(node.types.map { |x| format(x) }.join("\n"))
           end,
           *if node.entities.length > 0
-            indent(node.entities.map{|x| format(x)}.join("\n"))
+            indent(node.entities.map { |x| format(x) }.join("\n"))
           end,
           *if node.subtype_constraints.length > 0
-            indent(node.subtype_constraints.map{|x| format(x)}.join("\n"))
+            indent(node.subtype_constraints.map { |x| format(x) }.join("\n"))
           end,
           *if node.functions.length > 0
-            indent(node.functions.map{|x| format(x)}.join("\n"))
+            indent(node.functions.map { |x| format(x) }.join("\n"))
           end,
           *if node.procedures.length > 0
-            indent(node.procedures.map{|x| format(x)}.join("\n"))
+            indent(node.procedures.map { |x| format(x) }.join("\n"))
           end,
           *if node.constants.length > 0
             indent([
-              'CONSTANT',
-              indent(node.constants.map{|x| format(x)}.join("\n")),
+              "CONSTANT",
+              indent(node.constants.map { |x| format(x) }.join("\n")),
               [
-                'END_CONSTANT',
-                ';'
-              ].join('')
+                "END_CONSTANT",
+                ";",
+              ].join(""),
             ].join("\n"))
           end,
           *if node.variables.length > 0
             indent([
-              'LOCAL',
-              indent(node.variables.map{|x| format(x)}.join("\n")),
+              "LOCAL",
+              indent(node.variables.map { |x| format(x) }.join("\n")),
               [
-                'END_LOCAL',
-                ';'
-              ].join('')
+                "END_LOCAL",
+                ";",
+              ].join(""),
             ].join("\n"))
           end,
           *if node.statements.length > 0
-            indent(node.statements.map{|x| format(x)}.join("\n"))
+            indent(node.statements.map { |x| format(x) }.join("\n"))
           end,
           [
-            'END_FUNCTION',
-            ';'
-          ].join('')
+            "END_FUNCTION",
+            ";",
+          ].join(""),
         ].join("\n")
       end
 
       def format_declarations_interface(node)
         [
           case node.kind
-            when Model::Declarations::Interface::USE then 'USE'
-            when Model::Declarations::Interface::REFERENCE then 'REFERENCE'
+          when Model::Declarations::Interface::USE then "USE"
+          when Model::Declarations::Interface::REFERENCE then "REFERENCE"
           end,
-          ' ',
-          'FROM',
-          ' ',
+          " ",
+          "FROM",
+          " ",
           format(node.schema),
           *if node.items.length > 0
-            item_indent = INDENT_CHAR * '('.length
+            item_indent = INDENT_CHAR * "(".length
             [
               "\n",
               indent([
-                '(',
-                node.items.map{|x| format(x)}.join(",\n#{item_indent}"),
-                ')'
-              ].join(''))
-            ].join('')
+                "(",
+                node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
+                ")",
+              ].join("")),
+            ].join("")
           end,
-          ';',
-        ].join('')
+          ";",
+        ].join("")
       end
 
       def format_declarations_interface_item(node)
@@ -452,177 +452,177 @@ module Expressir
           format(node.ref),
           *if node.id
             [
-              ' ',
-              'AS',
-              ' ',
-              node.id
+              " ",
+              "AS",
+              " ",
+              node.id,
             ]
-          end
-        ].join('')
+          end,
+        ].join("")
       end
 
       def format_declarations_parameter(node)
         [
           *if node.var
             [
-              'VAR',
-              ' '
-            ].join('')
+              "VAR",
+              " ",
+            ].join("")
           end,
           node.id,
-          ' ',
-          ':',
-          ' ',
-          format(node.type)
-        ].join('')
+          " ",
+          ":",
+          " ",
+          format(node.type),
+        ].join("")
       end
 
       def format_declarations_procedure(node)
         [
           [
-            'PROCEDURE',
-            ' ',
+            "PROCEDURE",
+            " ",
             node.id,
             *if node.parameters.length > 0
               parameter_indent = INDENT_CHAR * "PROCEDURE #{node.id}(".length
               [
-                '(',
-                node.parameters.map{|x| format(x)}.join(";\n#{parameter_indent}"),
-                ')'
-              ].join('')
+                "(",
+                node.parameters.map { |x| format(x) }.join(";\n#{parameter_indent}"),
+                ")",
+              ].join("")
             end,
-            ';'
-          ].join(''),
+            ";",
+          ].join(""),
           *if node.types.length > 0
-            indent(node.types.map{|x| format(x)}.join("\n"))
+            indent(node.types.map { |x| format(x) }.join("\n"))
           end,
           *if node.entities.length > 0
-            indent(node.entities.map{|x| format(x)}.join("\n"))
+            indent(node.entities.map { |x| format(x) }.join("\n"))
           end,
           *if node.subtype_constraints.length > 0
-            indent(node.subtype_constraints.map{|x| format(x)}.join("\n"))
+            indent(node.subtype_constraints.map { |x| format(x) }.join("\n"))
           end,
           *if node.functions.length > 0
-            indent(node.functions.map{|x| format(x)}.join("\n"))
+            indent(node.functions.map { |x| format(x) }.join("\n"))
           end,
           *if node.procedures.length > 0
-            indent(node.procedures.map{|x| format(x)}.join("\n"))
+            indent(node.procedures.map { |x| format(x) }.join("\n"))
           end,
           *if node.constants.length > 0
             indent([
-              'CONSTANT',
-              indent(node.constants.map{|x| format(x)}.join("\n")),
+              "CONSTANT",
+              indent(node.constants.map { |x| format(x) }.join("\n")),
               [
-                'END_CONSTANT',
-                ';'
-              ].join('')
+                "END_CONSTANT",
+                ";",
+              ].join(""),
             ].join("\n"))
           end,
           *if node.variables.length > 0
             indent([
-              'LOCAL',
-              indent(node.variables.map{|x| format(x)}.join("\n")),
+              "LOCAL",
+              indent(node.variables.map { |x| format(x) }.join("\n")),
               [
-                'END_LOCAL',
-                ';'
-              ].join('')
+                "END_LOCAL",
+                ";",
+              ].join(""),
             ].join("\n"))
           end,
           *if node.statements.length > 0
-            indent(node.statements.map{|x| format(x)}.join("\n"))
+            indent(node.statements.map { |x| format(x) }.join("\n"))
           end,
           [
-            'END_PROCEDURE',
-            ';'
-          ].join('')
+            "END_PROCEDURE",
+            ";",
+          ].join(""),
         ].join("\n")
       end
 
       def format_declarations_rule(node)
         [
           [
-            'RULE',
-            ' ',
+            "RULE",
+            " ",
             node.id,
-            ' ',
-            'FOR',
-            ' ',
-            '(',
-            node.applies_to.map{|x| format(x)}.join(', '),
-            ')',
-            ';'
-          ].join(''),
+            " ",
+            "FOR",
+            " ",
+            "(",
+            node.applies_to.map { |x| format(x) }.join(", "),
+            ")",
+            ";",
+          ].join(""),
           *if node.types.length > 0
-            indent(node.types.map{|x| format(x)}.join("\n"))
+            indent(node.types.map { |x| format(x) }.join("\n"))
           end,
           *if node.entities.length > 0
-            indent(node.entities.map{|x| format(x)}.join("\n"))
+            indent(node.entities.map { |x| format(x) }.join("\n"))
           end,
           *if node.subtype_constraints.length > 0
-            indent(node.subtype_constraints.map{|x| format(x)}.join("\n"))
+            indent(node.subtype_constraints.map { |x| format(x) }.join("\n"))
           end,
           *if node.functions.length > 0
-            indent(node.functions.map{|x| format(x)}.join("\n"))
+            indent(node.functions.map { |x| format(x) }.join("\n"))
           end,
           *if node.procedures.length > 0
-            indent(node.procedures.map{|x| format(x)}.join("\n"))
+            indent(node.procedures.map { |x| format(x) }.join("\n"))
           end,
           *if node.constants.length > 0
             indent([
-              'CONSTANT',
-              indent(node.constants.map{|x| format(x)}.join("\n")),
+              "CONSTANT",
+              indent(node.constants.map { |x| format(x) }.join("\n")),
               [
-                'END_CONSTANT',
-                ';'
-              ].join('')
+                "END_CONSTANT",
+                ";",
+              ].join(""),
             ].join("\n"))
           end,
           *if node.variables.length > 0
             indent([
-              'LOCAL',
-              indent(node.variables.map{|x| format(x)}.join("\n")),
+              "LOCAL",
+              indent(node.variables.map { |x| format(x) }.join("\n")),
               [
-                'END_LOCAL',
-                ';'
-              ].join('')
+                "END_LOCAL",
+                ";",
+              ].join(""),
             ].join("\n"))
           end,
           *if node.statements.length > 0
-            indent(node.statements.map{|x| format(x)}.join("\n"))
+            indent(node.statements.map { |x| format(x) }.join("\n"))
           end,
           *if node.where_rules.length > 0
             [
-              'WHERE',
-              indent(node.where_rules.map{|x| format(x)}.join("\n"))
+              "WHERE",
+              indent(node.where_rules.map { |x| format(x) }.join("\n")),
             ]
           end,
           [
-            'END_RULE',
-            ';'
-          ].join('')
+            "END_RULE",
+            ";",
+          ].join(""),
         ].join("\n")
       end
 
       def format_declarations_schema_head(node)
         [
           [
-            'SCHEMA',
-            ' ',
+            "SCHEMA",
+            " ",
             node.id,
             *if node.version
               [
-                ' ',
+                " ",
                 format(node.version),
-              ].join('')
+              ].join("")
             end,
-            ';'
-          ].join(''),
+            ";",
+          ].join(""),
           *if node.interfaces.length > 0
             [
-              '',
-              node.interfaces.map{|x| format(x)}.join("\n")
+              "",
+              node.interfaces.map { |x| format(x) }.join("\n"),
             ]
-          end
+          end,
         ].join("\n")
       end
 
@@ -630,48 +630,48 @@ module Expressir
         schema_declarations = [
           *if node.constants.length > 0
             [
-              'CONSTANT',
-              indent(node.constants.map{|x| format(x)}.join("\n")),
+              "CONSTANT",
+              indent(node.constants.map { |x| format(x) }.join("\n")),
               [
-                'END_CONSTANT',
-                ';'
-              ].join('')
+                "END_CONSTANT",
+                ";",
+              ].join(""),
             ].join("\n")
           end,
           *if node.types.length > 0
-            node.types.map{|x| format(x)}
+            node.types.map { |x| format(x) }
           end,
           *if node.entities.length > 0
-            node.entities.map{|x| format(x)}
+            node.entities.map { |x| format(x) }
           end,
           *if node.subtype_constraints.length > 0
-            node.subtype_constraints.map{|x| format(x)}
+            node.subtype_constraints.map { |x| format(x) }
           end,
           *if node.functions.length > 0
-            node.functions.map{|x| format(x)}
+            node.functions.map { |x| format(x) }
           end,
           *if node.rules.length > 0
-            node.rules.map{|x| format(x)}
+            node.rules.map { |x| format(x) }
           end,
           *if node.procedures and node.procedures.length > 0
-            node.procedures.map{|x| format(x)}
-          end
+            node.procedures.map { |x| format(x) }
+          end,
         ]
 
         [
           format_declarations_schema_head(node),
           *if schema_declarations.length > 0
             [
-              '',
+              "",
               schema_declarations.join("\n\n"),
-              ''
+              "",
             ]
           end,
           [
-            'END_SCHEMA',
-            ';'
-          ].join(''),
-          *format_scope_remarks(node)
+            "END_SCHEMA",
+            ";",
+          ].join(""),
+          *format_scope_remarks(node),
         ].join("\n")
       end
 
@@ -679,74 +679,74 @@ module Expressir
         [
           "'",
           node.value,
-          "'"
-        ].join('')
+          "'",
+        ].join("")
       end
 
       def format_declarations_subtype_constraint(node)
         [
           [
-            'SUBTYPE_CONSTRAINT',
-            ' ',
+            "SUBTYPE_CONSTRAINT",
+            " ",
             node.id,
-            ' ',
-            'FOR',
-            ' ',
+            " ",
+            "FOR",
+            " ",
             format(node.applies_to),
-            ';'
-          ].join(''),
+            ";",
+          ].join(""),
           *if node.abstract
             indent([
-              'ABSTRACT',
-              ' ',
-              'SUPERTYPE',
-              ';'
-            ].join(''))
+              "ABSTRACT",
+              " ",
+              "SUPERTYPE",
+              ";",
+            ].join(""))
           end,
           *if node.total_over.length > 0
             indent([
-              'TOTAL_OVER',
-              '(',
-              node.total_over.map{|x| format(x)}.join(', '),
-              ')',
-              ';'
-            ].join(''))
+              "TOTAL_OVER",
+              "(",
+              node.total_over.map { |x| format(x) }.join(", "),
+              ")",
+              ";",
+            ].join(""))
           end,
           *if node.supertype_expression
             indent([
               format(node.supertype_expression),
-              ';'
-            ].join(''))
+              ";",
+            ].join(""))
           end,
           [
-            'END_SUBTYPE_CONSTRAINT',
-            ';'
-          ].join('')
+            "END_SUBTYPE_CONSTRAINT",
+            ";",
+          ].join(""),
         ].join("\n")
       end
 
       def format_declarations_type(node)
         [
           [
-            'TYPE',
-            ' ',
+            "TYPE",
+            " ",
             node.id,
-            ' ',
-            '=',
-            ' ',
+            " ",
+            "=",
+            " ",
             format(node.underlying_type),
-            ';',
-          ].join(''),
+            ";",
+          ].join(""),
           *if node.where_rules.length > 0
             [
-              'WHERE',
-              indent(node.where_rules.map{|x| format(x)}.join("\n"))
+              "WHERE",
+              indent(node.where_rules.map { |x| format(x) }.join("\n")),
             ]
           end,
           [
-            'END_TYPE',
-            ';'
-          ].join('')
+            "END_TYPE",
+            ";",
+          ].join(""),
         ].join("\n")
       end
 
@@ -755,32 +755,32 @@ module Expressir
           *if node.id
             [
               node.id,
-              ':',
-              ' '
-            ].join('')
+              ":",
+              " ",
+            ].join("")
           end,
-          node.attributes.map{|x| format(x)}.join(', '),
-          ';'
-        ].join('')
+          node.attributes.map { |x| format(x) }.join(", "),
+          ";",
+        ].join("")
       end
 
       def format_declarations_variable(node)
         [
           node.id,
-          ' ',
-          ':',
-          ' ',
+          " ",
+          ":",
+          " ",
           format(node.type),
           *if node.expression
             [
-              ' ',
-              ':=',
-              ' ',
+              " ",
+              ":=",
+              " ",
               format(node.expression),
-            ].join('')
+            ].join("")
           end,
-          ';'
-        ].join('')
+          ";",
+        ].join("")
       end
 
       def format_declarations_where_rule(node)
@@ -788,158 +788,158 @@ module Expressir
           *if node.id
             [
               node.id,
-              ':',
-              ' '
-            ].join('')
+              ":",
+              " ",
+            ].join("")
           end,
           format(node.expression),
-          ';'
-        ].join('')
+          ";",
+        ].join("")
       end
 
       def format_expressions_aggregate_initializer(node)
         [
-          '[',
-          node.items.map{|x| format(x)}.join(', '),
-          ']'
-        ].join('')
+          "[",
+          node.items.map { |x| format(x) }.join(", "),
+          "]",
+        ].join("")
       end
 
       def format_expressions_aggregate_initializer_item(node)
         [
           format(node.expression),
-          ':',
-          format(node.repetition)
-        ].join('')
+          ":",
+          format(node.repetition),
+        ].join("")
       end
 
       def format_expressions_binary_expression(node)
         [
           *if node.operand1.is_a? Model::Expressions::BinaryExpression and OPERATOR_PRECEDENCE[node.operand1.operator] > OPERATOR_PRECEDENCE[node.operator]
-            '('
+            "("
           end,
           format(node.operand1),
           *if node.operand1.is_a? Model::Expressions::BinaryExpression and OPERATOR_PRECEDENCE[node.operand1.operator] > OPERATOR_PRECEDENCE[node.operator]
-            ')'
+            ")"
           end,
-          ' ',
+          " ",
           case node.operator
-            when Model::Expressions::BinaryExpression::ADDITION then '+'
-            when Model::Expressions::BinaryExpression::AND then 'AND'
-            when Model::Expressions::BinaryExpression::COMBINE then '||'
-            when Model::Expressions::BinaryExpression::EQUAL then '='
-            when Model::Expressions::BinaryExpression::EXPONENTIATION then '**'
-            when Model::Expressions::BinaryExpression::GREATER_THAN then '>'
-            when Model::Expressions::BinaryExpression::GREATER_THAN_OR_EQUAL then '>='
-            when Model::Expressions::BinaryExpression::IN then 'IN'
-            when Model::Expressions::BinaryExpression::INSTANCE_EQUAL then ':=:'
-            when Model::Expressions::BinaryExpression::INSTANCE_NOT_EQUAL then ':<>:'
-            when Model::Expressions::BinaryExpression::INTEGER_DIVISION then 'DIV'
-            when Model::Expressions::BinaryExpression::LESS_THAN then '<'
-            when Model::Expressions::BinaryExpression::LESS_THAN_OR_EQUAL then '<='
-            when Model::Expressions::BinaryExpression::LIKE then 'LIKE'
-            when Model::Expressions::BinaryExpression::MODULO then 'MOD'
-            when Model::Expressions::BinaryExpression::MULTIPLICATION then '*'
-            when Model::Expressions::BinaryExpression::NOT_EQUAL then '<>'
-            when Model::Expressions::BinaryExpression::OR then 'OR'
-            when Model::Expressions::BinaryExpression::REAL_DIVISION then '/'
-            when Model::Expressions::BinaryExpression::SUBTRACTION then '-'
-            when Model::Expressions::BinaryExpression::XOR then 'XOR'
-          end,
-          ' ',
+          when Model::Expressions::BinaryExpression::ADDITION then "+"
+          when Model::Expressions::BinaryExpression::AND then "AND"
+          when Model::Expressions::BinaryExpression::COMBINE then "||"
+          when Model::Expressions::BinaryExpression::EQUAL then "="
+          when Model::Expressions::BinaryExpression::EXPONENTIATION then "**"
+          when Model::Expressions::BinaryExpression::GREATER_THAN then ">"
+          when Model::Expressions::BinaryExpression::GREATER_THAN_OR_EQUAL then ">="
+          when Model::Expressions::BinaryExpression::IN then "IN"
+          when Model::Expressions::BinaryExpression::INSTANCE_EQUAL then ":=:"
+          when Model::Expressions::BinaryExpression::INSTANCE_NOT_EQUAL then ":<>:"
+          when Model::Expressions::BinaryExpression::INTEGER_DIVISION then "DIV"
+          when Model::Expressions::BinaryExpression::LESS_THAN then "<"
+          when Model::Expressions::BinaryExpression::LESS_THAN_OR_EQUAL then "<="
+          when Model::Expressions::BinaryExpression::LIKE then "LIKE"
+          when Model::Expressions::BinaryExpression::MODULO then "MOD"
+          when Model::Expressions::BinaryExpression::MULTIPLICATION then "*"
+          when Model::Expressions::BinaryExpression::NOT_EQUAL then "<>"
+          when Model::Expressions::BinaryExpression::OR then "OR"
+          when Model::Expressions::BinaryExpression::REAL_DIVISION then "/"
+          when Model::Expressions::BinaryExpression::SUBTRACTION then "-"
+          when Model::Expressions::BinaryExpression::XOR then "XOR"
+          end,
+          " ",
           *if node.operand2.is_a? Model::Expressions::BinaryExpression and OPERATOR_PRECEDENCE[node.operand2.operator] > OPERATOR_PRECEDENCE[node.operator]
-            '('
+            "("
           end,
           format(node.operand2),
           *if node.operand2.is_a? Model::Expressions::BinaryExpression and OPERATOR_PRECEDENCE[node.operand2.operator] > OPERATOR_PRECEDENCE[node.operator]
-            ')'
+            ")"
           end,
-        ].join('')
+        ].join("")
       end
 
       def format_expressions_entity_constructor(node)
         [
           format(node.entity),
-          '(',
-          node.parameters.map{|x| format(x)}.join(', '),
-          ')'
-        ].join('')
+          "(",
+          node.parameters.map { |x| format(x) }.join(", "),
+          ")",
+        ].join("")
       end
 
       def format_expressions_function_call(node)
         [
           format(node.function),
-          '(',
-          node.parameters.map{|x| format(x)}.join(', '),
-          ')'
-        ].join('')
+          "(",
+          node.parameters.map { |x| format(x) }.join(", "),
+          ")",
+        ].join("")
       end
 
       def format_expressions_interval(node)
         [
-          '{',
+          "{",
           format(node.low),
-          ' ',
+          " ",
           case node.operator1
-            when Model::Expressions::Interval::LESS_THAN then '<'
-            when Model::Expressions::Interval::LESS_THAN_OR_EQUAL then '<='
+          when Model::Expressions::Interval::LESS_THAN then "<"
+          when Model::Expressions::Interval::LESS_THAN_OR_EQUAL then "<="
           end,
-          ' ',
+          " ",
           format(node.item),
-          ' ',
+          " ",
           case node.operator2
-            when Model::Expressions::Interval::LESS_THAN then '<'
-            when Model::Expressions::Interval::LESS_THAN_OR_EQUAL then '<='
+          when Model::Expressions::Interval::LESS_THAN then "<"
+          when Model::Expressions::Interval::LESS_THAN_OR_EQUAL then "<="
           end,
-          ' ',
+          " ",
           format(node.high),
-          '}'
-        ].join('')
+          "}",
+        ].join("")
       end
 
       def format_expressions_query_expression(node)
         [
-          'QUERY',
-          '(',
+          "QUERY",
+          "(",
           node.id,
-          ' ',
-          '<*',
-          ' ',
+          " ",
+          "<*",
+          " ",
           format(node.aggregate_source),
-          ' ',
-          '|',
-          ' ',
+          " ",
+          "|",
+          " ",
           format(node.expression),
-          *format_remarks(node).instance_eval{|x| x.length > 0 ? ["\n", *x, "\n"] : x},
-          ')'
-        ].join('')
+          *format_remarks(node).instance_eval { |x| x.length > 0 ? ["\n", *x, "\n"] : x },
+          ")",
+        ].join("")
       end
 
       def format_expressions_unary_expression(node)
         [
           case node.operator
-            when Model::Expressions::UnaryExpression::MINUS then '-'
-            when Model::Expressions::UnaryExpression::NOT then 'NOT'
-            when Model::Expressions::UnaryExpression::PLUS then '+'
+          when Model::Expressions::UnaryExpression::MINUS then "-"
+          when Model::Expressions::UnaryExpression::NOT then "NOT"
+          when Model::Expressions::UnaryExpression::PLUS then "+"
           end,
           if node.operator == Model::Expressions::UnaryExpression::NOT
-            ' '
+            " "
           end,
           *if node.operand.is_a? Model::Expressions::BinaryExpression
-            '('
+            "("
           end,
           format(node.operand),
           *if node.operand.is_a? Model::Expressions::BinaryExpression
-            ')'
-          end
-        ].join('')
+            ")"
+          end,
+        ].join("")
       end
 
       def format_literals_binary(node)
         [
-          '%',
-          node.value
-        ].join('')
+          "%",
+          node.value,
+        ].join("")
       end
 
       def format_literals_integer(node)
@@ -948,9 +948,9 @@ module Expressir
 
       def format_literals_logical(node)
         case node.value
-          when Model::Literals::Logical::TRUE then 'TRUE'
-          when Model::Literals::Logical::FALSE then 'FALSE'
-          when Model::Literals::Logical::UNKNOWN then 'UNKNOWN'
+        when Model::Literals::Logical::TRUE then "TRUE"
+        when Model::Literals::Logical::FALSE then "FALSE"
+        when Model::Literals::Logical::UNKNOWN then "UNKNOWN"
         end
       end
 
@@ -963,46 +963,46 @@ module Expressir
           [
             "\"",
             node.value,
-            "\""
-          ].join('')
+            "\"",
+          ].join("")
         else
           [
             "'",
             node.value,
-            "'"
-          ].join('')
+            "'",
+          ].join("")
         end
       end
 
       def format_references_attribute_reference(node)
         [
           format(node.ref),
-          '.',
-          format(node.attribute)
-        ].join('')
+          ".",
+          format(node.attribute),
+        ].join("")
       end
 
       def format_references_group_reference(node)
         [
           format(node.ref),
           '\\',
-          format(node.entity)
-        ].join('')
+          format(node.entity),
+        ].join("")
       end
 
       def format_references_index_reference(node)
         [
           format(node.ref),
-          '[',
+          "[",
           format(node.index1),
           *if node.index2
             [
-              ':',
-              format(node.index2)
-            ].join('')
+              ":",
+              format(node.index2),
+            ].join("")
           end,
-          ']'
-        ].join('')
+          "]",
+        ].join("")
       end
 
       def format_references_simple_reference(node)
@@ -1012,35 +1012,35 @@ module Expressir
       def format_statements_alias(node)
         [
           [
-            'ALIAS',
-            ' ',
+            "ALIAS",
+            " ",
             node.id,
-            ' ',
-            'FOR',
-            ' ',
+            " ",
+            "FOR",
+            " ",
             format(node.expression),
-            ';'
-          ].join(''),
+            ";",
+          ].join(""),
           *if node.statements.length > 0
-            indent(node.statements.map{|x| format(x)}.join("\n"))
+            indent(node.statements.map { |x| format(x) }.join("\n"))
           end,
           *format_remarks(node),
           [
-            'END_ALIAS',
-            ';'
-          ].join('')
+            "END_ALIAS",
+            ";",
+          ].join(""),
         ].join("\n")
       end
 
       def format_statements_assignment(node)
         [
           format(node.ref),
-          ' ',
-          ':=',
-          ' ',
+          " ",
+          ":=",
+          " ",
           format(node.expression),
-          ';'
-        ].join('')
+          ";",
+        ].join("")
       end
 
       def format_statements_procedure_call(node)
@@ -1048,342 +1048,342 @@ module Expressir
           format(node.procedure),
           *if node.parameters.length > 0
             [
-              '(',
-              node.parameters.map{|x| format(x)}.join(', '),
-              ')'
-            ].join('')
+              "(",
+              node.parameters.map { |x| format(x) }.join(", "),
+              ")",
+            ].join("")
           end,
-          ';'
-        ].join('')
+          ";",
+        ].join("")
       end
 
       def format_statements_case(node)
         [
           [
-            'CASE',
-            ' ',
+            "CASE",
+            " ",
             format(node.expression),
-            ' ',
-            'OF'
-          ].join(''),
+            " ",
+            "OF",
+          ].join(""),
           *if node.actions.length > 0
-            node.actions.map{|x| format(x)}
+            node.actions.map { |x| format(x) }
           end,
           *if node.otherwise_statement
             [
               [
-                'OTHERWISE',
-                ' ',
-                ':'
-              ].join(''),
-              indent(format(node.otherwise_statement))
+                "OTHERWISE",
+                " ",
+                ":",
+              ].join(""),
+              indent(format(node.otherwise_statement)),
             ]
           end,
           [
-            'END_CASE',
-            ';'
-          ].join('')
+            "END_CASE",
+            ";",
+          ].join(""),
         ].join("\n")
       end
 
       def format_statements_case_action(node)
         [
           [
-            node.labels.map{|x| format(x)}.join(', '),
-            ' ',
-            ':'
-          ].join(''),
-          indent(format(node.statement))
+            node.labels.map { |x| format(x) }.join(", "),
+            " ",
+            ":",
+          ].join(""),
+          indent(format(node.statement)),
         ].join("\n")
       end
 
       def format_statements_compound(node)
         [
-          'BEGIN',
+          "BEGIN",
           *if node.statements.length > 0
-            indent(node.statements.map{|x| format(x)}.join("\n"))
+            indent(node.statements.map { |x| format(x) }.join("\n"))
           end,
           [
-            'END',
-            ';'
-          ].join('')
+            "END",
+            ";",
+          ].join(""),
         ].join("\n")
       end
 
       def format_statements_escape(node)
         [
-          'ESCAPE',
-          ';'
-        ].join('')
+          "ESCAPE",
+          ";",
+        ].join("")
       end
 
       def format_statements_if(node)
         [
           [
-            'IF',
-            ' ',
+            "IF",
+            " ",
             format(node.expression),
-            ' ',
-            'THEN'
-          ].join(''),
+            " ",
+            "THEN",
+          ].join(""),
           *if node.statements.length > 0
-            indent(node.statements.map{|x| format(x)}.join("\n"))
+            indent(node.statements.map { |x| format(x) }.join("\n"))
           end,
           *if node.else_statements.length > 0
             [
-              'ELSE',
-              indent(node.else_statements.map{|x| format(x)}.join("\n")),
+              "ELSE",
+              indent(node.else_statements.map { |x| format(x) }.join("\n")),
             ].join("\n")
           end,
           [
-            'END_IF',
-            ';'
-          ].join('')
+            "END_IF",
+            ";",
+          ].join(""),
         ].join("\n")
       end
 
       def format_statements_null(node)
-        ';'
+        ";"
       end
 
       def format_statements_repeat(node)
         [
           [
-            'REPEAT',
+            "REPEAT",
             *if node.id
               [
-                ' ',
+                " ",
                 node.id,
-                ' ',
-                ':=',
-                ' ',
+                " ",
+                ":=",
+                " ",
                 format(node.bound1),
-                ' ',
-                'TO',
-                ' ',
+                " ",
+                "TO",
+                " ",
                 format(node.bound2),
                 *if node.increment
                   [
-                    ' ',
-                    'BY',
-                    ' ',
-                    format(node.increment)
-                  ].join('')
-                end
-              ].join('')
+                    " ",
+                    "BY",
+                    " ",
+                    format(node.increment),
+                  ].join("")
+                end,
+              ].join("")
             end,
             *if node.while_expression
               [
-                ' ',
-                'WHILE',
-                ' ',
-                format(node.while_expression)
-              ].join('')
+                " ",
+                "WHILE",
+                " ",
+                format(node.while_expression),
+              ].join("")
             end,
             *if node.until_expression
               [
-                ' ',
-                'UNTIL',
-                ' ',
-                format(node.until_expression)
-              ].join('')
+                " ",
+                "UNTIL",
+                " ",
+                format(node.until_expression),
+              ].join("")
             end,
-            ';'
-          ].join(''),
+            ";",
+          ].join(""),
           *if node.statements.length > 0
-            indent(node.statements.map{|x| format(x)}.join("\n"))
+            indent(node.statements.map { |x| format(x) }.join("\n"))
           end,
           *format_remarks(node),
           [
-            'END_REPEAT',
-            ';'
-          ].join('')
+            "END_REPEAT",
+            ";",
+          ].join(""),
         ].join("\n")
       end
 
       def format_statements_return(node)
         [
-          'RETURN',
+          "RETURN",
           *if node.expression
             [
-              ' ',
-              '(',
+              " ",
+              "(",
               format(node.expression),
-              ')'
-            ].join('')
+              ")",
+            ].join("")
           end,
-          ';'
-        ].join('')
+          ";",
+        ].join("")
       end
 
       def format_statements_skip(node)
         [
-          'SKIP',
-          ';'
-        ].join('')
+          "SKIP",
+          ";",
+        ].join("")
       end
 
       def format_supertype_expressions_binary_supertype_expression(node)
         [
           *if node.operand1.is_a? Model::SupertypeExpressions::BinarySupertypeExpression and SUPERTYPE_OPERATOR_PRECEDENCE[node.operand1.operator] > SUPERTYPE_OPERATOR_PRECEDENCE[node.operator]
-            '('
+            "("
           end,
           format(node.operand1),
           *if node.operand1.is_a? Model::SupertypeExpressions::BinarySupertypeExpression and SUPERTYPE_OPERATOR_PRECEDENCE[node.operand1.operator] > SUPERTYPE_OPERATOR_PRECEDENCE[node.operator]
-            ')'
+            ")"
           end,
-          ' ',
+          " ",
           case node.operator
-            when Model::SupertypeExpressions::BinarySupertypeExpression::AND then 'AND'
-            when Model::SupertypeExpressions::BinarySupertypeExpression::ANDOR then 'ANDOR'
+          when Model::SupertypeExpressions::BinarySupertypeExpression::AND then "AND"
+          when Model::SupertypeExpressions::BinarySupertypeExpression::ANDOR then "ANDOR"
           end,
-          ' ',
+          " ",
           *if node.operand2.is_a? Model::SupertypeExpressions::BinarySupertypeExpression and SUPERTYPE_OPERATOR_PRECEDENCE[node.operand2.operator] > SUPERTYPE_OPERATOR_PRECEDENCE[node.operator]
-            '('
+            "("
           end,
           format(node.operand2),
           *if node.operand2.is_a? Model::SupertypeExpressions::BinarySupertypeExpression and SUPERTYPE_OPERATOR_PRECEDENCE[node.operand2.operator] > SUPERTYPE_OPERATOR_PRECEDENCE[node.operator]
-            ')'
+            ")"
           end,
-        ].join('')
+        ].join("")
       end
 
       def format_supertype_expressions_oneof_supertype_expression(node)
         [
-          'ONEOF',
-          '(',
-          node.operands.map{|x| format(x)}.join(', '),
-          ')'
-        ].join('')
+          "ONEOF",
+          "(",
+          node.operands.map { |x| format(x) }.join(", "),
+          ")",
+        ].join("")
       end
 
       def format_data_types_aggregate(node)
-        'AGGREGATE'
+        "AGGREGATE"
       end
 
       def format_data_types_array(node)
         [
-          'ARRAY',
+          "ARRAY",
           *if node.bound1 and node.bound2
             [
-              ' ',
-              '[',
+              " ",
+              "[",
               format(node.bound1),
-              ':',
+              ":",
               format(node.bound2),
-              ']',
-            ].join('')
+              "]",
+            ].join("")
           end,
-          ' ',
-          'OF',
+          " ",
+          "OF",
           *if node.optional
             [
-              ' ',
-              'OPTIONAL'
-            ].join('')
+              " ",
+              "OPTIONAL",
+            ].join("")
           end,
           *if node.unique
             [
-              ' ',
-              'UNIQUE'
-            ].join('')
+              " ",
+              "UNIQUE",
+            ].join("")
           end,
-          ' ',
-          format(node.base_type)
-        ].join('')
+          " ",
+          format(node.base_type),
+        ].join("")
       end
 
       def format_data_types_bag(node)
         [
-          'BAG',
+          "BAG",
           *if node.bound1 and node.bound2
             [
-              ' ',
-              '[',
+              " ",
+              "[",
               format(node.bound1),
-              ':',
+              ":",
               format(node.bound2),
-              ']',
-            ].join('')
+              "]",
+            ].join("")
           end,
-          ' ',
-          'OF',
-          ' ',
-          format(node.base_type)
-        ].join('')
+          " ",
+          "OF",
+          " ",
+          format(node.base_type),
+        ].join("")
       end
 
       def format_data_types_binary(node)
         [
-          'BINARY',
+          "BINARY",
           *if node.width
             [
-              ' ',
-              '(',
+              " ",
+              "(",
               format(node.width),
-              ')'
-            ].join('')
+              ")",
+            ].join("")
           end,
           *if node.fixed
             [
-              ' ',
-              'FIXED'
-            ].join('')
-          end
-        ].join('')
+              " ",
+              "FIXED",
+            ].join("")
+          end,
+        ].join("")
       end
 
       def format_data_types_boolean(node)
-        'BOOLEAN'
+        "BOOLEAN"
       end
 
       def format_data_types_enumeration(node)
         [
           *if node.extensible
             [
-              'EXTENSIBLE',
-              ' '
-            ].join('')
+              "EXTENSIBLE",
+              " ",
+            ].join("")
           end,
-          'ENUMERATION',
+          "ENUMERATION",
           *if node.based_on
             [
-              ' ',
-              'BASED_ON',
-              ' ',
+              " ",
+              "BASED_ON",
+              " ",
               format(node.based_on),
               *if node.items.length > 0
-                item_indent = INDENT_CHAR * '('.length
+                item_indent = INDENT_CHAR * "(".length
                 [
-                  ' ',
-                  'WITH',
+                  " ",
+                  "WITH",
                   "\n",
                   indent([
-                    '(',
-                    node.items.map{|x| format(x)}.join(",\n#{item_indent}"),
-                    ')'
-                  ].join(''))
-                ].join('')
-              end
-            ].join('')
+                    "(",
+                    node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
+                    ")",
+                  ].join("")),
+                ].join("")
+              end,
+            ].join("")
           else
             [
               *if node.items.length > 0
-                item_indent = INDENT_CHAR * '('.length
+                item_indent = INDENT_CHAR * "(".length
                 [
-                  ' ',
-                  'OF',
+                  " ",
+                  "OF",
                   "\n",
                   indent([
-                    '(',
-                    node.items.map{|x| format(x)}.join(",\n#{item_indent}"),
-                    ')'
-                  ].join(''))
-                ].join('')
-              end
-            ].join('')
-          end
-        ].join('')
+                    "(",
+                    node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
+                    ")",
+                  ].join("")),
+                ].join("")
+              end,
+            ].join("")
+          end,
+        ].join("")
       end
 
       def format_data_types_enumeration_item(node)
@@ -1392,198 +1392,198 @@ module Expressir
 
       def format_data_types_generic_entity(node)
         [
-          'GENERIC_ENTITY',
+          "GENERIC_ENTITY",
           *if node.id
             [
-              ':',
-              node.id
+              ":",
+              node.id,
             ]
-          end
-        ].join('')
+          end,
+        ].join("")
       end
 
       def format_data_types_generic(node)
         [
-          'GENERIC',
+          "GENERIC",
           *if node.id
             [
-              ':',
-              node.id
+              ":",
+              node.id,
             ]
-          end
-        ].join('')
+          end,
+        ].join("")
       end
 
       def format_data_types_integer(node)
-        'INTEGER'
+        "INTEGER"
       end
 
       def format_data_types_list(node)
         [
-          'LIST',
+          "LIST",
           *if node.bound1 and node.bound2
             [
-              ' ',
-              '[',
+              " ",
+              "[",
               format(node.bound1),
-              ':',
+              ":",
               format(node.bound2),
-              ']',
-            ].join('')
+              "]",
+            ].join("")
           end,
-          ' ',
-          'OF',
+          " ",
+          "OF",
           *if node.unique
             [
-              ' ',
-              'UNIQUE'
-            ].join('')
+              " ",
+              "UNIQUE",
+            ].join("")
           end,
-          ' ',
-          format(node.base_type)
-        ].join('')
+          " ",
+          format(node.base_type),
+        ].join("")
       end
 
       def format_data_types_logical(node)
-        'LOGICAL'
+        "LOGICAL"
       end
 
       def format_data_types_number(node)
-        'NUMBER'
+        "NUMBER"
       end
 
       def format_data_types_real(node)
         [
-          'REAL',
+          "REAL",
           *if node.precision
             [
-              ' ',
-              '(',
+              " ",
+              "(",
               format(node.precision),
-              ')'
-            ].join('')
-          end
-        ].join('')
+              ")",
+            ].join("")
+          end,
+        ].join("")
       end
 
       def format_data_types_select(node)
         [
           *if node.extensible
             [
-              'EXTENSIBLE',
-              ' '
-            ].join('')
+              "EXTENSIBLE",
+              " ",
+            ].join("")
           end,
           *if node.generic_entity
             [
-              'GENERIC_ENTITY',
-              ' '
-            ].join('')
+              "GENERIC_ENTITY",
+              " ",
+            ].join("")
           end,
-          'SELECT',
+          "SELECT",
           *if node.based_on
             [
-              ' ',
-              'BASED_ON',
-              ' ',
+              " ",
+              "BASED_ON",
+              " ",
               format(node.based_on),
               *if node.items.length > 0
-                item_indent = INDENT_CHAR * '('.length
+                item_indent = INDENT_CHAR * "(".length
                 [
-                  ' ',
-                  'WITH',
+                  " ",
+                  "WITH",
                   "\n",
                   indent([
-                    '(',
-                    node.items.map{|x| format(x)}.join(",\n#{item_indent}"),
-                    ')'
-                  ].join(''))
-                ].join('')
-              end
-            ].join('')
+                    "(",
+                    node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
+                    ")",
+                  ].join("")),
+                ].join("")
+              end,
+            ].join("")
           else
             [
               *if node.items.length > 0
-                item_indent = INDENT_CHAR * '('.length
+                item_indent = INDENT_CHAR * "(".length
                 [
                   "\n",
                   indent([
-                    '(',
-                    node.items.map{|x| format(x)}.join(",\n#{item_indent}"),
-                    ')'
-                  ].join(''))
-                ].join('')
-              end
-            ].join('')
-          end
-        ].join('')
+                    "(",
+                    node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
+                    ")",
+                  ].join("")),
+                ].join("")
+              end,
+            ].join("")
+          end,
+        ].join("")
       end
 
       def format_data_types_set(node)
         [
-          'SET',
+          "SET",
           *if node.bound1 and node.bound2
             [
-              ' ',
-              '[',
+              " ",
+              "[",
               format(node.bound1),
-              ':',
+              ":",
               format(node.bound2),
-              ']',
-            ].join('')
+              "]",
+            ].join("")
           end,
-          ' ',
-          'OF',
-          ' ',
-          format(node.base_type)
-        ].join('')
+          " ",
+          "OF",
+          " ",
+          format(node.base_type),
+        ].join("")
       end
 
       def format_data_types_string(node)
         [
-          'STRING',
+          "STRING",
           *if node.width
             [
-              ' ',
-              '(',
+              " ",
+              "(",
               format(node.width),
-              ')'
-            ].join('')
+              ")",
+            ].join("")
           end,
           *if node.fixed
             [
-              ' ',
-              'FIXED'
-            ].join('')
-          end
-        ].join('')
+              " ",
+              "FIXED",
+            ].join("")
+          end,
+        ].join("")
       end
 
       def indent(str)
-        str.split("\n").map{|x| "#{INDENT}#{x}"}.join("\n")
+        str.split("\n").map { |x| "#{INDENT}#{x}" }.join("\n")
       end
 
       def format_remark(node, remark)
         if remark.include?("\n")
           [
             [
-              '(*',
+              "(*",
               '"',
               node.path || node.id,
               '"',
-            ].join(''),
+            ].join(""),
             remark,
-            '*)'
+            "*)",
           ].join("\n")
         else
           [
-            '--',
+            "--",
             '"',
             node.path || node.id,
             '"',
-            ' ',
-            remark
-          ].join('')
+            " ",
+            remark,
+          ].join("")
         end
       end
 
@@ -1600,9 +1600,9 @@ module Expressir
       def format_scope_remarks(node)
         [
           *format_remarks(node),
-          *node.children.select{|x| !x.is_a? Model::DataTypes::EnumerationItem or node.is_a? Model::Declarations::Type}.flat_map{|x| format_scope_remarks(x)}
+          *node.children.select { |x| !x.is_a? Model::DataTypes::EnumerationItem or node.is_a? Model::Declarations::Type }.flat_map { |x| format_scope_remarks(x) },
         ]
       end
     end
   end
-end
+end