expressir 2.4.29-arm-linux

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

@@ -0,0 +1,180 @@
+module Expressir
+  module Express
+    module Formatters
+      module ExpressionsFormatter
+        def self.included(base)
+          base.register_formatter Model::Expressions::AggregateInitializer,
+                                  :format_expressions_aggregate_initializer
+          base.register_formatter Model::Expressions::AggregateInitializerItem,
+                                  :format_expressions_aggregate_initializer_item
+          base.register_formatter Model::Expressions::BinaryExpression,
+                                  :format_expressions_binary_expression
+          base.register_formatter Model::Expressions::EntityConstructor,
+                                  :format_expressions_entity_constructor
+          base.register_formatter Model::Expressions::FunctionCall,
+                                  :format_expressions_function_call
+          base.register_formatter Model::Expressions::Interval,
+                                  :format_expressions_interval
+          base.register_formatter Model::Expressions::QueryExpression,
+                                  :format_expressions_query_expression
+          base.register_formatter Model::Expressions::UnaryExpression,
+                                  :format_expressions_unary_expression
+        end
+
+        def format_expressions_aggregate_initializer(node)
+          [
+            "[",
+            Array(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_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
+
+        def format_expressions_entity_constructor(node)
+          [
+            format(node.entity),
+            "(",
+            Array(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
+
+          [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_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)
+          needs_parens = node.operand.is_a?(Model::Expressions::BinaryExpression) ||
+            node.operand.is_a?(Model::Expressions::Interval)
+
+          [
+            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 needs_parens
+               "("
+             end,
+            format(node.operand),
+            *if needs_parens
+               ")"
+             end,
+          ].join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Expressir
+  module Express
+    module Formatters
+      module LiteralsFormatter
+        def self.included(base)
+          base.register_formatter Model::Literals::Binary,
+                                  :format_literals_binary
+          base.register_formatter Model::Literals::Integer,
+                                  :format_literals_integer
+          base.register_formatter Model::Literals::Logical,
+                                  :format_literals_logical
+          base.register_formatter Model::Literals::Real, :format_literals_real
+          base.register_formatter Model::Literals::String,
+                                  :format_literals_string
+        end
+
+        def format_literals_binary(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"
+          end
+        end
+
+        def format_literals_real(node)
+          node.value
+        end
+
+        def format_literals_string(node)
+          if node.encoded
+            [
+              "\"",
+              node.value,
+              "\"",
+            ].join
+          else
+            [
+              "'",
+              node.value,
+              "'",
+            ].join
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Expressir
+  module Express
+    module Formatters
+      module ReferencesFormatter
+        def self.included(base)
+          base.register_formatter Model::References::AttributeReference,
+                                  :format_references_attribute_reference
+          base.register_formatter Model::References::GroupReference,
+                                  :format_references_group_reference
+          base.register_formatter Model::References::IndexReference,
+                                  :format_references_index_reference
+          base.register_formatter Model::References::SimpleReference,
+                                  :format_references_simple_reference
+        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_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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,270 @@
+module Expressir
+  module Express
+    module Formatters
+      module RemarkFormatter
+        def format_remark(node, remark)
+          # Handle embedded remarks
+          if remark.include?("\n")
+            [
+              [
+                "(*\"",
+                node.path || node.id,
+                "\"",
+              ].join,
+              remark,
+              "*)",
+            ].join("\n")
+          elsif node.path.nil? && node.id.include?("IP")
+            # Handle immediate informal propositions
+            [
+              "--",
+              node.id,
+              " ",
+              remark,
+            ].join
+          else
+            # Handle tail remarks
+            [
+              "--\"",
+              node.path || node.id,
+              "\" ",
+              remark,
+            ].join
+          end
+        end
+
+        def format_untagged_remark(remark)
+          return "" unless remark.is_a?(Model::RemarkInfo)
+
+          text = remark.text
+          return "" if text.nil? || text.empty?
+
+          formatted_text = remark.tagged? ? "\"#{remark.tag}\" #{text}" : text
+
+          if remark.tail?
+            "-- #{formatted_text}"
+          elsif text.include?("\n")
+            ["(*", formatted_text, "*)"].join("\n")
+          else
+            "(* #{formatted_text} *)"
+          end
+        end
+
+        def format_inline_tail_remark(node)
+          return "" if @no_remarks
+          return "" unless node.is_a?(Model::ModelElement)
+          return "" if node.untagged_remarks.nil? || node.untagged_remarks.empty?
+
+          remark = node.untagged_remarks.first
+          return "" unless remark.is_a?(Model::RemarkInfo)
+
+          text = remark.text
+          return "" if text.nil? || text.empty?
+
+          formatted_text = remark.tagged? ? "\"#{remark.tag}\" #{text}" : text
+          remark.tail? ? " -- #{formatted_text}" : " (* #{formatted_text} *)"
+        end
+
+        def format_end_scope_remark(node)
+          return "" if @no_remarks
+          return "" unless node.is_a?(Model::ModelElement)
+
+          # Only legacy (unplaced) remarks belong after the END_* keyword.
+          # Remarks carrying an explicit placement are rendered by the
+          # placement-aware emitters, and must not be emitted twice.
+          remark = Array(node.untagged_remarks).reject(&:placement).last
+          return "" unless remark.is_a?(Model::RemarkInfo)
+
+          text = remark.text
+          return "" if text.nil? || text.empty?
+
+          # Only output if it's a tail remark (END_* scope remarks are always tail)
+          return "" unless remark.tail?
+
+          formatted_text = remark.tagged? ? "\"#{remark.tag}\" #{text}" : text
+          " -- #{formatted_text}"
+        end
+
+        def format_preamble_remark(remark, indent_str = "")
+          return "" unless remark.is_a?(Model::RemarkInfo)
+
+          text = remark.text
+          text = "\"#{remark.tag}\" #{text}" if remark.tagged?
+
+          if remark.tail?
+            "#{indent_str}-- #{text}"
+          elsif text.include?("\n")
+            lines = text.split("\n")
+            [
+              "#{indent_str}(*",
+              *lines.map { |line| "#{indent_str}  #{line.strip}" },
+              "#{indent_str}*)",
+            ].join("\n")
+          else
+            "#{indent_str}(* #{text} *)"
+          end
+        end
+
+        def format_preamble_remarks(node, indent_str = "")
+          return nil if @no_remarks
+          return nil unless node.is_a?(Model::ModelElement)
+          return nil if node.untagged_remarks.nil? || node.untagged_remarks.empty?
+
+          # For scope containers, exclude the last tail remark as it's the END_* remark
+          # but keep all embedded remarks
+          is_scope_container = node.is_a?(Model::Declarations::Schema) ||
+            node.is_a?(Model::Declarations::Entity) ||
+            node.is_a?(Model::Declarations::Type) ||
+            node.is_a?(Model::Declarations::Function) ||
+            node.is_a?(Model::Declarations::Procedure) ||
+            node.is_a?(Model::Declarations::Rule)
+
+          preamble_remarks = node.untagged_remarks.select do |remark|
+            remark.is_a?(Model::RemarkInfo) && !remark.text.nil? && !remark.text.empty?
+          end
+
+          # For scope containers: exclude last remark ONLY if it's a tail remark (END_* remark)
+          # Keep all embedded remarks
+          if is_scope_container && preamble_remarks.length >= 1
+            last_remark = preamble_remarks.last
+            # Only exclude if it's a tail remark
+            preamble_remarks = preamble_remarks[0..-2] if last_remark.tail?
+          end
+
+          return nil if preamble_remarks.empty?
+
+          preamble_remarks.map do |remark|
+            format_preamble_remark(remark, indent_str)
+          end.join("\n")
+        end
+
+        # Remarks that close one body of `node`, emitted just before that
+        # body's closing keyword. Only explicit TRAILING remarks for the named
+        # region qualify: legacy (nil) remarks keep their historical emission
+        # path so old caches render exactly as they did before.
+        def format_trailing_region_remarks(node, region)
+          return [] if @no_remarks
+          return [] unless node.is_a?(Model::ModelElement)
+
+          Array(node.untagged_remarks).filter_map do |remark|
+            next unless remark.trailing_region?(region)
+
+            formatted = format_untagged_remark(remark)
+            formatted unless formatted.empty?
+          end
+        end
+
+        # Remarks written after their statement on the same line, which for a
+        # single-line statement is where appending puts them back. Opener
+        # remarks are excluded: those belong on the first line rather than
+        # after the closing keyword, and {#format_opener_remarks} emits them.
+        # Mid-keyword remarks (ELSE / OTHERWISE regions) are excluded too:
+        # {#format_mid_keyword_remarks} emits them after their keyword.
+        def format_inline_statement_remarks(node)
+          formatted_inline_remarks(node) { |remark| remark.region.nil? }
+        end
+
+        # Remarks that trailed the opening line of a statement spanning
+        # several lines, as in `IF x THEN -- why`. Where they are written back
+        # is Formatter#format's business, not this method's.
+        def format_opener_remarks(node)
+          formatted_inline_remarks(node, &:opener?)
+        end
+
+        # Remarks that trailed a mid-construct keyword of `node` — the ELSE
+        # line of an IF, the OTHERWISE line of a CASE — emitted after that
+        # keyword, where they were written.
+        def format_mid_keyword_remarks(node, region)
+          formatted_inline_remarks(node) { |remark| remark.inline_region?(region) }
+        end
+
+        # The inline remarks of a node that the given block accepts, formatted
+        # and joined. The callers partition the same collection, so every
+        # inline remark is emitted by exactly one of them.
+        def formatted_inline_remarks(node, &)
+          return "" if @no_remarks
+          return "" unless node.is_a?(Model::TakesInlineRemark)
+
+          Array(node.untagged_remarks).filter_map do |remark|
+            next unless remark.inline? && yield(remark)
+
+            formatted = format_untagged_remark(remark)
+            formatted unless formatted.empty?
+          end.map { |text| " #{text}" }.join
+        end
+
+        def format_leading_statement_remarks(node)
+          return [] if @no_remarks
+          return [] unless node.is_a?(Model::Statement)
+
+          Array(node.untagged_remarks).filter_map do |remark|
+            next unless remark.leading?
+
+            formatted = format_untagged_remark(remark)
+            formatted unless formatted.empty?
+          end
+        end
+
+        # Block-end emission for ALIAS/REPEAT bodies. Tagged remarks are
+        # stored as bare text in node.remarks alongside a mirror of every
+        # untagged text (add_remark dual-store), so "genuinely tagged" is
+        # derivable only by multiset-subtracting the untagged texts.
+        def format_block_end_remarks(node)
+          return [] if @no_remarks
+
+          untagged = Array(node.untagged_remarks)
+          remaining = untagged.map(&:text).tally
+          tagged = Array(node.remarks).compact.reject do |text|
+            next false unless remaining[text]&.positive?
+
+            remaining[text] -= 1
+            true
+          end
+
+          [
+            *tagged.map { |text| format_remark(node, text) },
+            # Leading and inline remarks are emitted by their own paths;
+            # including them here would render them a second time.
+            *untagged.reject { |r| r.leading? || r.inline? }
+              .filter_map do |remark|
+                formatted = format_untagged_remark(remark)
+                formatted unless formatted.empty?
+              end,
+          ]
+        end
+
+        def format_remarks(node)
+          remarks = []
+
+          # Add tagged remarks
+          if node.is_a?(Model::HasRemarks) && !@no_remarks &&
+              !node.remarks.nil?
+            remarks.concat(node.remarks.compact.map do |remark|
+              format_remark(node, remark)
+            end)
+          end
+
+          # Skip untagged remarks for nodes that handle them separately
+          skip_untagged = node.is_a?(Model::Declarations::Attribute) ||
+            node.is_a?(Model::DataTypes::EnumerationItem) ||
+            node.is_a?(Model::Declarations::Schema) ||
+            node.is_a?(Model::Declarations::Entity) ||
+            node.is_a?(Model::Declarations::Type) ||
+            node.is_a?(Model::Declarations::Function) ||
+            node.is_a?(Model::Declarations::Procedure) ||
+            node.is_a?(Model::Declarations::Rule)
+
+          # Add untagged remarks only for nodes that don't handle them specially
+          if !skip_untagged && node.is_a?(Model::ModelElement) && !@no_remarks &&
+              !node.untagged_remarks.nil?
+            remarks.concat(node.untagged_remarks.map do |remark|
+              format_untagged_remark(remark)
+            end)
+          end
+
+          remarks
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Expressir
+  module Express
+    module Formatters
+      module RemarkItemFormatter
+        def self.included(base)
+          base.register_formatter Model::Declarations::RemarkItem,
+                                  :format_remark_item
+        end
+
+        def format_remark_item(node)
+          return "" unless node.remarks&.any?
+
+          # Check if any remark contains newlines
+          has_newlines = node.remarks.any? { |r| r.to_s.include?("\n") }
+
+          if has_newlines
+            # Multi-line format: (*"path" remarks *)
+            remarks_text = node.remarks.join("\n")
+            "(*\"#{node.path}\"\n#{remarks_text}\n*)"
+          else
+            # Single-line format: --"path"
+            "--\"#{node.path}\""
+          end
+        end
+      end
+    end
+  end
+end