expressir 2.2.1 → 2.3.0

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

@@ -1,159 +1,161 @@
 module Expressir
   module Express
-    module ExpressionsFormatter
-      private
+    module Formatters
+      module ExpressionsFormatter
+        private
 
-      def format_expressions_aggregate_initializer(node)
-        node.items ||= []
-        [
-          "[",
-          node.items.map { |x| format(x) }.join(", "),
-          "]",
-        ].join
-      end
+        def format_expressions_aggregate_initializer(node)
+          node.items ||= []
+          [
+            "[",
+            node.items.map { |x| format(x) }.join(", "),
+            "]",
+          ].join
+        end
 
-      def format_expressions_aggregate_initializer_item(node)
-        [
-          format(node.expression),
-          ":",
-          format(node.repetition),
-        ].join
-      end
+        def format_expressions_aggregate_initializer_item(node)
+          [
+            format(node.expression),
+            ":",
+            format(node.repetition),
+          ].join
+        end
 
-      def format_expressions_binary_expression(node)
-        operator_precedence = self.class.const_get(:OPERATOR_PRECEDENCE)
-        op1_bin_exp = node.operand1.is_a?(Model::Expressions::BinaryExpression) &&
-          (operator_precedence[node.operand1.operator] > operator_precedence[node.operator])
-        op2_bin_exp = node.operand2.is_a?(Model::Expressions::BinaryExpression) &&
-          (operator_precedence[node.operand2.operator] > operator_precedence[node.operator])
+        def format_expressions_binary_expression(node)
+          operator_precedence = self.class.const_get(:OPERATOR_PRECEDENCE)
+          op1_bin_exp = node.operand1.is_a?(Model::Expressions::BinaryExpression) &&
+            (operator_precedence[node.operand1.operator] > operator_precedence[node.operator])
+          op2_bin_exp = node.operand2.is_a?(Model::Expressions::BinaryExpression) &&
+            (operator_precedence[node.operand2.operator] > operator_precedence[node.operator])
 
-        [
-          *if op1_bin_exp
-             "("
-           end,
-          format(node.operand1),
-          *if op1_bin_exp
-             ")"
-           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,
-          " ",
-          *if op2_bin_exp
-             "("
-           end,
-          format(node.operand2),
-          *if op2_bin_exp
-             ")"
-           end,
-        ].join
-      end
+          [
+            *if op1_bin_exp
+               "("
+             end,
+            format(node.operand1),
+            *if op1_bin_exp
+               ")"
+             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,
+            " ",
+            *if op2_bin_exp
+               "("
+             end,
+            format(node.operand2),
+            *if op2_bin_exp
+               ")"
+             end,
+          ].join
+        end
 
-      def format_expressions_entity_constructor(node)
-        node.parameters ||= []
-        [
-          format(node.entity),
-          "(",
-          node.parameters.map { |x| format(x) }.join(", "),
-          ")",
-        ].join
-      end
+        def format_expressions_entity_constructor(node)
+          node.parameters ||= []
+          [
+            format(node.entity),
+            "(",
+            node.parameters.map { |x| format(x) }.join(", "),
+            ")",
+          ].join
+        end
 
-      def format_expressions_function_call(node)
-        params = if node.parameters.nil?
-                   []
-                 else
-                   [
-                     "(",
-                     node.parameters.map { |x| format(x) }.join(", "),
-                     ")",
-                   ]
-                 end
+        def format_expressions_function_call(node)
+          params = if node.parameters.nil?
+                     []
+                   else
+                     [
+                       "(",
+                       node.parameters.map { |x| format(x) }.join(", "),
+                       ")",
+                     ]
+                   end
 
-        [format(node.function), params].join
-      end
+          [format(node.function), params].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 "<="
-          end,
-          " ",
-          format(node.item),
-          " ",
-          case node.operator2
-          when Model::Expressions::Interval::LESS_THAN then "<"
-          when Model::Expressions::Interval::LESS_THAN_OR_EQUAL then "<="
-          end,
-          " ",
-          format(node.high),
-          "}",
-        ].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 "<="
+            end,
+            " ",
+            format(node.item),
+            " ",
+            case node.operator2
+            when Model::Expressions::Interval::LESS_THAN then "<"
+            when Model::Expressions::Interval::LESS_THAN_OR_EQUAL then "<="
+            end,
+            " ",
+            format(node.high),
+            "}",
+          ].join
+        end
 
-      def format_expressions_query_expression(node)
-        [
-          "QUERY",
-          "(",
-          node.id,
-          " ",
-          "<*",
-          " ",
-          format(node.aggregate_source),
-          " ",
-          "|",
-          " ",
-          format(node.expression),
-          *format_remarks(node).instance_eval do |x|
-            x&.length&.positive? ? ["\n", *x, "\n"] : x
-          end,
-          ")",
-        ].join
-      end
+        def format_expressions_query_expression(node)
+          [
+            "QUERY",
+            "(",
+            node.id,
+            " ",
+            "<*",
+            " ",
+            format(node.aggregate_source),
+            " ",
+            "|",
+            " ",
+            format(node.expression),
+            *format_remarks(node).instance_eval do |x|
+              x&.length&.positive? ? ["\n", *x, "\n"] : x
+            end,
+            ")",
+          ].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 "+"
-          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
+        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 "+"
+            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
       end
     end
   end

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

@@ -1,44 +1,46 @@
 module Expressir
   module Express
-    module LiteralsFormatter
-      private
+    module Formatters
+      module LiteralsFormatter
+        private
 
-      def format_literals_binary(node)
-        [
-          "%",
-          node.value,
-        ].join
-      end
+        def format_literals_binary(node)
+          [
+            "%",
+            node.value,
+          ].join
+        end
 
-      def format_literals_integer(node)
-        node.value
-      end
+        def format_literals_integer(node)
+          node.value
+        end
 
-      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"
+        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"
+          end
         end
-      end
 
-      def format_literals_real(node)
-        node.value
-      end
+        def format_literals_real(node)
+          node.value
+        end
 
-      def format_literals_string(node)
-        if node.encoded
-          [
-            "\"",
-            node.value,
-            "\"",
-          ].join
-        else
-          [
-            "'",
-            node.value,
-            "'",
-          ].join
+        def format_literals_string(node)
+          if node.encoded
+            [
+              "\"",
+              node.value,
+              "\"",
+            ].join
+          else
+            [
+              "'",
+              node.value,
+              "'",
+            ].join
+          end
         end
       end
     end

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

@@ -1,41 +1,43 @@
 module Expressir
   module Express
-    module ReferencesFormatter
-      private
+    module Formatters
+      module ReferencesFormatter
+        private
 
-      def format_references_attribute_reference(node)
-        [
-          format(node.ref),
-          ".",
-          format(node.attribute),
-        ].join
-      end
+        def format_references_attribute_reference(node)
+          [
+            format(node.ref),
+            ".",
+            format(node.attribute),
+          ].join
+        end
 
-      def format_references_group_reference(node)
-        [
-          format(node.ref),
-          "\\",
-          format(node.entity),
-        ].join
-      end
+        def format_references_group_reference(node)
+          [
+            format(node.ref),
+            "\\",
+            format(node.entity),
+          ].join
+        end
 
-      def format_references_index_reference(node)
-        [
-          format(node.ref),
-          "[",
-          format(node.index1),
-          *if node.index2
-             [
-               ":",
-               format(node.index2),
-             ].join
-           end,
-          "]",
-        ].join
-      end
+        def format_references_index_reference(node)
+          [
+            format(node.ref),
+            "[",
+            format(node.index1),
+            *if node.index2
+               [
+                 ":",
+                 format(node.index2),
+               ].join
+             end,
+            "]",
+          ].join
+        end
 
-      def format_references_simple_reference(node)
-        node.id
+        def format_references_simple_reference(node)
+          node.id
+        end
       end
     end
   end