expressir 2.2.0 → 2.3.0

data/lib/expressir/express/formatters/statements_formatter.rb

@@ -1,223 +1,225 @@
 module Expressir
   module Express
-    module StatementsFormatter
-      private
+    module Formatters
+      module StatementsFormatter
+        private
 
-      def format_statements_alias(node)
-        [
+        def format_statements_alias(node)
           [
-            "ALIAS",
-            " ",
-            node.id,
+            [
+              "ALIAS",
+              " ",
+              node.id,
+              " ",
+              "FOR",
+              " ",
+              format(node.expression),
+              ";",
+            ].join,
+            *if node.statements&.length&.positive?
+               indent(node.statements.map { |x| format(x) }.join("\n"))
+             end,
+            *format_remarks(node),
+            [
+              "END_ALIAS",
+              ";",
+            ].join,
+          ].join("\n")
+        end
+
+        def format_statements_assignment(node)
+          [
+            format(node.ref),
             " ",
-            "FOR",
+            ":=",
             " ",
             format(node.expression),
             ";",
-          ].join,
-          *if node.statements&.length&.positive?
-             indent(node.statements.map { |x| format(x) }.join("\n"))
-           end,
-          *format_remarks(node),
-          [
-            "END_ALIAS",
-            ";",
-          ].join,
-        ].join("\n")
-      end
+          ].join
+        end
 
-      def format_statements_assignment(node)
-        [
-          format(node.ref),
-          " ",
-          ":=",
-          " ",
-          format(node.expression),
-          ";",
-        ].join
-      end
-
-      def format_statements_procedure_call(node)
-        [
-          format(node.procedure),
-          *if node.parameters&.length&.positive?
-             [
-               "(",
-               node.parameters.map { |x| format(x) }.join(", "),
-               ")",
-             ].join
-           end,
-          ";",
-        ].join
-      end
-
-      def format_statements_case(node)
-        [
+        def format_statements_procedure_call(node)
           [
-            "CASE",
-            " ",
-            format(node.expression),
-            " ",
-            "OF",
-          ].join,
-          *if node.actions&.length&.positive?
-             node.actions.map { |x| format(x) }
-           end,
-          *if node.otherwise_statement
-             [
+            format(node.procedure),
+            *if node.parameters&.length&.positive?
                [
-                 "OTHERWISE",
-                 " ",
-                 ":",
-               ].join,
-               indent(format(node.otherwise_statement)),
-             ]
-           end,
-          [
-            "END_CASE",
+                 "(",
+                 node.parameters.map { |x| format(x) }.join(", "),
+                 ")",
+               ].join
+             end,
             ";",
-          ].join,
-        ].join("\n")
-      end
+          ].join
+        end
 
-      def format_statements_case_action(node)
-        node.labels ||= []
-        [
+        def format_statements_case(node)
           [
-            node.labels.map { |x| format(x) }.join(", "),
-            " ",
-            ":",
-          ].join,
-          indent(format(node.statement)),
-        ].join("\n")
-      end
+            [
+              "CASE",
+              " ",
+              format(node.expression),
+              " ",
+              "OF",
+            ].join,
+            *if node.actions&.length&.positive?
+               node.actions.map { |x| format(x) }
+             end,
+            *if node.otherwise_statement
+               [
+                 [
+                   "OTHERWISE",
+                   " ",
+                   ":",
+                 ].join,
+                 indent(format(node.otherwise_statement)),
+               ]
+             end,
+            [
+              "END_CASE",
+              ";",
+            ].join,
+          ].join("\n")
+        end
 
-      def format_statements_compound(node)
-        node.statements ||= []
-        [
-          "BEGIN",
-          *if node.statements&.length&.positive?
-             indent(node.statements.map { |x| format(x) }.join("\n"))
-           end,
+        def format_statements_case_action(node)
+          node.labels ||= []
           [
-            "END",
-            ";",
-          ].join,
-        ].join("\n")
-      end
+            [
+              node.labels.map { |x| format(x) }.join(", "),
+              " ",
+              ":",
+            ].join,
+            indent(format(node.statement)),
+          ].join("\n")
+        end
 
-      def format_statements_escape(_node)
-        [
-          "ESCAPE",
-          ";",
-        ].join
-      end
-
-      def format_statements_if(node)
-        [
+        def format_statements_compound(node)
+          node.statements ||= []
           [
-            "IF",
-            " ",
-            format(node.expression),
-            " ",
-            "THEN",
-          ].join,
-          *if node.statements&.length&.positive?
-             indent(node.statements.map { |x| format(x) }.join("\n"))
-           end,
-          *if node.else_statements&.length&.positive?
-             [
-               "ELSE",
-               indent(node.else_statements.map { |x| format(x) }.join("\n")),
-             ].join("\n")
-           end,
+            "BEGIN",
+            *if node.statements&.length&.positive?
+               indent(node.statements.map { |x| format(x) }.join("\n"))
+             end,
+            [
+              "END",
+              ";",
+            ].join,
+          ].join("\n")
+        end
+
+        def format_statements_escape(_node)
           [
-            "END_IF",
+            "ESCAPE",
             ";",
-          ].join,
-        ].join("\n")
-      end
-
-      def format_statements_null(_node)
-        ";"
-      end
+          ].join
+        end
 
-      def format_statements_repeat(node)
-        node.statements ||= []
-        [
+        def format_statements_if(node)
           [
-            "REPEAT",
-            *if node.id
-               [
-                 " ",
-                 node.id,
-                 " ",
-                 ":=",
-                 " ",
-                 format(node.bound1),
-                 " ",
-                 "TO",
-                 " ",
-                 format(node.bound2),
-                 *if node.increment
-                    [
-                      " ",
-                      "BY",
-                      " ",
-                      format(node.increment),
-                    ].join
-                  end,
-               ].join
+            [
+              "IF",
+              " ",
+              format(node.expression),
+              " ",
+              "THEN",
+            ].join,
+            *if node.statements&.length&.positive?
+               indent(node.statements.map { |x| format(x) }.join("\n"))
              end,
-            *if node.while_expression
+            *if node.else_statements&.length&.positive?
                [
-                 " ",
-                 "WHILE",
-                 " ",
-                 format(node.while_expression),
-               ].join
+                 "ELSE",
+                 indent(node.else_statements.map { |x| format(x) }.join("\n")),
+               ].join("\n")
              end,
-            *if node.until_expression
+            [
+              "END_IF",
+              ";",
+            ].join,
+          ].join("\n")
+        end
+
+        def format_statements_null(_node)
+          ";"
+        end
+
+        def format_statements_repeat(node)
+          node.statements ||= []
+          [
+            [
+              "REPEAT",
+              *if node.id
+                 [
+                   " ",
+                   node.id,
+                   " ",
+                   ":=",
+                   " ",
+                   format(node.bound1),
+                   " ",
+                   "TO",
+                   " ",
+                   format(node.bound2),
+                   *if node.increment
+                      [
+                        " ",
+                        "BY",
+                        " ",
+                        format(node.increment),
+                      ].join
+                    end,
+                 ].join
+               end,
+              *if node.while_expression
+                 [
+                   " ",
+                   "WHILE",
+                   " ",
+                   format(node.while_expression),
+                 ].join
+               end,
+              *if node.until_expression
+                 [
+                   " ",
+                   "UNTIL",
+                   " ",
+                   format(node.until_expression),
+                 ].join
+               end,
+              ";",
+            ].join,
+            *if node.statements&.length&.positive?
+               indent(node.statements.map { |x| format(x) }.join("\n"))
+             end,
+            *format_remarks(node),
+            [
+              "END_REPEAT",
+              ";",
+            ].join,
+          ].join("\n")
+        end
+
+        def format_statements_return(node)
+          [
+            "RETURN",
+            *if node.expression
                [
                  " ",
-                 "UNTIL",
-                 " ",
-                 format(node.until_expression),
+                 "(",
+                 format(node.expression),
+                 ")",
                ].join
              end,
             ";",
-          ].join,
-          *if node.statements&.length&.positive?
-             indent(node.statements.map { |x| format(x) }.join("\n"))
-           end,
-          *format_remarks(node),
+          ].join
+        end
+
+        def format_statements_skip(_node)
           [
-            "END_REPEAT",
+            "SKIP",
             ";",
-          ].join,
-        ].join("\n")
-      end
-
-      def format_statements_return(node)
-        [
-          "RETURN",
-          *if node.expression
-             [
-               " ",
-               "(",
-               format(node.expression),
-               ")",
-             ].join
-           end,
-          ";",
-        ].join
-      end
-
-      def format_statements_skip(_node)
-        [
-          "SKIP",
-          ";",
-        ].join
+          ].join
+        end
       end
     end
   end

data/lib/expressir/express/formatters/supertype_expressions_formatter.rb

@@ -1,47 +1,49 @@
 module Expressir
   module Express
-    module SupertypeExpressionsFormatter
-      private
+    module Formatters
+      module SupertypeExpressionsFormatter
+        private
 
-      def format_supertype_expressions_binary_supertype_expression(node)
-        supertype_precedence = self.class.const_get(:SUPERTYPE_OPERATOR_PRECEDENCE)
-        op1_higher_precedence = node.operand1.is_a?(Model::SupertypeExpressions::BinarySupertypeExpression) &&
-          (supertype_precedence[node.operand1.operator] > supertype_precedence[node.operator])
-        op2_higher_precedence = node.operand2.is_a?(Model::SupertypeExpressions::BinarySupertypeExpression) &&
-          (supertype_precedence[node.operand2.operator] > supertype_precedence[node.operator])
+        def format_supertype_expressions_binary_supertype_expression(node)
+          supertype_precedence = self.class.const_get(:SUPERTYPE_OPERATOR_PRECEDENCE)
+          op1_higher_precedence = node.operand1.is_a?(Model::SupertypeExpressions::BinarySupertypeExpression) &&
+            (supertype_precedence[node.operand1.operator] > supertype_precedence[node.operator])
+          op2_higher_precedence = node.operand2.is_a?(Model::SupertypeExpressions::BinarySupertypeExpression) &&
+            (supertype_precedence[node.operand2.operator] > supertype_precedence[node.operator])
 
-        [
-          *if op1_higher_precedence
-             "("
-           end,
-          format(node.operand1),
-          *if op1_higher_precedence
-             ")"
-           end,
-          " ",
-          case node.operator
-          when Model::SupertypeExpressions::BinarySupertypeExpression::AND then "AND"
-          when Model::SupertypeExpressions::BinarySupertypeExpression::ANDOR then "ANDOR"
-          end,
-          " ",
-          *if op2_higher_precedence
-             "("
-           end,
-          format(node.operand2),
-          *if op2_higher_precedence
-             ")"
-           end,
-        ].join
-      end
+          [
+            *if op1_higher_precedence
+               "("
+             end,
+            format(node.operand1),
+            *if op1_higher_precedence
+               ")"
+             end,
+            " ",
+            case node.operator
+            when Model::SupertypeExpressions::BinarySupertypeExpression::AND then "AND"
+            when Model::SupertypeExpressions::BinarySupertypeExpression::ANDOR then "ANDOR"
+            end,
+            " ",
+            *if op2_higher_precedence
+               "("
+             end,
+            format(node.operand2),
+            *if op2_higher_precedence
+               ")"
+             end,
+          ].join
+        end
 
-      def format_supertype_expressions_oneof_supertype_expression(node)
-        node.operands ||= []
-        [
-          "ONEOF",
-          "(",
-          node.operands.map { |x| format(x) }.join(", "),
-          ")",
-        ].join
+        def format_supertype_expressions_oneof_supertype_expression(node)
+          node.operands ||= []
+          [
+            "ONEOF",
+            "(",
+            node.operands.map { |x| format(x) }.join(", "),
+            ")",
+          ].join
+        end
       end
     end
   end

data/lib/expressir/express/formatters.rb

@@ -0,0 +1,22 @@
+module Expressir
+  module Express
+    # Formatter mixin modules
+    module Formatters
+      autoload :RemarkItemFormatter,
+               "#{__dir__}/formatters/remark_item_formatter"
+      autoload :RemarkFormatter, "#{__dir__}/formatters/remark_formatter"
+      autoload :LiteralsFormatter, "#{__dir__}/formatters/literals_formatter"
+      autoload :ReferencesFormatter,
+               "#{__dir__}/formatters/references_formatter"
+      autoload :SupertypeExpressionsFormatter,
+               "#{__dir__}/formatters/supertype_expressions_formatter"
+      autoload :StatementsFormatter,
+               "#{__dir__}/formatters/statements_formatter"
+      autoload :ExpressionsFormatter,
+               "#{__dir__}/formatters/expressions_formatter"
+      autoload :DataTypesFormatter, "#{__dir__}/formatters/data_types_formatter"
+      autoload :DeclarationsFormatter,
+               "#{__dir__}/formatters/declarations_formatter"
+    end
+  end
+end