expressir 2.3.5 → 2.3.7

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

@@ -2,7 +2,46 @@ module Expressir
   module Express
     module Formatters
       module DeclarationsFormatter
-        private
+        def self.included(base)
+          base.register_formatter Model::Declarations::Attribute,
+                                  :format_declarations_attribute
+          base.register_formatter Model::Declarations::Constant,
+                                  :format_declarations_constant
+          base.register_formatter Model::Declarations::Entity,
+                                  :format_declarations_entity
+          base.register_formatter Model::Declarations::Function,
+                                  :format_declarations_function
+          base.register_formatter Model::Declarations::Interface,
+                                  :format_declarations_interface
+          base.register_formatter Model::Declarations::InterfaceItem,
+                                  :format_declarations_interface_item
+          base.register_formatter Model::Declarations::Parameter,
+                                  :format_declarations_parameter
+          base.register_formatter Model::Declarations::Procedure,
+                                  :format_declarations_procedure
+          base.register_formatter Model::Declarations::Rule,
+                                  :format_declarations_rule
+          base.register_formatter Model::Declarations::Schema,
+                                  :format_declarations_schema
+          base.register_formatter Model::Declarations::SchemaVersion,
+                                  :format_declarations_schema_version
+          base.register_formatter Model::Declarations::SubtypeConstraint,
+                                  :format_declarations_subtype_constraint
+          base.register_formatter Model::Declarations::Type,
+                                  :format_declarations_type
+          base.register_formatter Model::Declarations::UniqueRule,
+                                  :format_declarations_unique_rule
+          base.register_formatter Model::Declarations::Variable,
+                                  :format_declarations_variable
+          base.register_formatter Model::Declarations::WhereRule,
+                                  :format_declarations_where_rule
+          base.register_formatter Model::Declarations::InformalPropositionRule,
+                                  :format_declarations_informal_proposition_rule
+          base.register_formatter Model::Declarations::DerivedAttribute,
+                                  :format_declarations_attribute
+          base.register_formatter Model::Declarations::InverseAttribute,
+                                  :format_declarations_attribute
+        end
 
         def format_declarations_attribute(node)
           [
@@ -187,8 +226,7 @@ module Expressir
             [
               "END_ENTITY",
               ";",
-              # Only show end_scope_remark if entity has explicit attributes
-              explicit_attributes&.length&.positive? ? format_end_scope_remark(node) : "",
+              format_end_scope_remark(node),
             ].join,
           ].join("\n")
         end
@@ -257,6 +295,7 @@ module Expressir
             [
               "END_FUNCTION",
               ";",
+              format_end_scope_remark(node),
             ].join,
           ].join("\n")
         end
@@ -377,13 +416,12 @@ module Expressir
             [
               "END_PROCEDURE",
               ";",
+              format_end_scope_remark(node),
             ].join,
           ].join("\n")
         end
 
         def format_declarations_rule(node)
-          node.applies_to ||= []
-
           # Filter out statements that only exist to hold remarks in rules
           # (ALIAS/REPEAT with only Null sub-statements, query assignments, or Null statements)
           formatted_statements = []
@@ -414,7 +452,7 @@ module Expressir
               "FOR",
               " ",
               "(",
-              node.applies_to.map { |x| format(x) }.join(", "),
+              Array(node.applies_to).map { |x| format(x) }.join(", "),
               ")",
               ";",
             ].join,
@@ -465,6 +503,7 @@ module Expressir
             [
               "END_RULE",
               ";",
+              format_end_scope_remark(node),
             ].join,
           ].join("\n")
         end
@@ -596,6 +635,7 @@ module Expressir
             [
               "END_SUBTYPE_CONSTRAINT",
               ";",
+              format_end_scope_remark(node),
             ].join,
           ].join("\n")
         end
@@ -627,7 +667,6 @@ module Expressir
         end
 
         def format_declarations_unique_rule(node)
-          node.attributes ||= []
           [
             *if node.id
                [
@@ -636,7 +675,7 @@ module Expressir
                  " ",
                ].join
              end,
-            node.attributes.map { |x| format(x) }.join(", "),
+            Array(node.attributes).map { |x| format(x) }.join(", "),
             ";",
           ].join
         end

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

@@ -2,13 +2,29 @@ module Expressir
   module Express
     module Formatters
       module ExpressionsFormatter
-        private
+        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)
-          node.items ||= []
           [
             "[",
-            node.items.map { |x| format(x) }.join(", "),
+            Array(node.items).map { |x| format(x) }.join(", "),
             "]",
           ].join
         end
@@ -24,9 +40,9 @@ module Expressir
         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])
+            (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])
+            (operator_precedence[node.operand2.operator] >= operator_precedence[node.operator])
 
           [
             *if op1_bin_exp
@@ -72,11 +88,10 @@ module Expressir
         end
 
         def format_expressions_entity_constructor(node)
-          node.parameters ||= []
           [
             format(node.entity),
             "(",
-            node.parameters.map { |x| format(x) }.join(", "),
+            Array(node.parameters).map { |x| format(x) }.join(", "),
             ")",
           ].join
         end
@@ -138,6 +153,9 @@ module Expressir
         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 "-"
@@ -147,11 +165,11 @@ module Expressir
             if node.operator == Model::Expressions::UnaryExpression::NOT
               " "
             end,
-            *if node.operand.is_a? Model::Expressions::BinaryExpression
+            *if needs_parens
                "("
              end,
             format(node.operand),
-            *if node.operand.is_a? Model::Expressions::BinaryExpression
+            *if needs_parens
                ")"
              end,
           ].join

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

@@ -2,13 +2,20 @@ module Expressir
   module Express
     module Formatters
       module LiteralsFormatter
-        private
+        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,
-          ].join
+          node.value
         end
 
         def format_literals_integer(node)

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

@@ -2,7 +2,16 @@ module Expressir
   module Express
     module Formatters
       module ReferencesFormatter
-        private
+        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)
           [

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

@@ -2,8 +2,6 @@ module Expressir
   module Express
     module Formatters
       module RemarkFormatter
-        private
-
         def format_remark(node, remark)
           # Handle embedded remarks
           if remark.include?("\n")
@@ -142,7 +140,7 @@ module Expressir
           remarks = []
 
           # Add tagged remarks
-          if node.class.method_defined?(:remarks) && !@no_remarks &&
+          if node.is_a?(Model::HasRemarks) && !@no_remarks &&
               !node.remarks.nil?
             remarks.concat(node.remarks.compact.map do |remark|
               format_remark(node, remark)
@@ -169,92 +167,6 @@ module Expressir
 
           remarks
         end
-
-        def format_scope_remarks(node)
-          remarks = []
-
-          # Collect tagged remarks using the standard format_remarks
-          remarks.concat(format_remarks(node))
-
-          # Special handling for Schema to get proper remark ordering
-          if node.is_a?(Model::Declarations::Schema)
-            # Schema's own remarks that need to be in specific positions
-            schema_remarks = {}
-            if !@no_remarks && node.is_a?(Model::ModelElement) && !node.untagged_remarks.nil?
-              node.untagged_remarks.compact.each do |remark|
-                next unless remark.is_a?(Model::RemarkInfo)
-
-                text = remark.text
-                schema_remarks[text] = remark unless text == "interfaces" # Skip "interfaces"
-              end
-            end
-
-            # Add Schema remarks in the proper order relative to children
-            # Declaration order: constants, types, entities, subtype_constraints, functions, rules, procedures
-            remarks.concat(schema_remarks["constants"] ? [format_untagged_remark(schema_remarks["constants"])] : [])
-
-            # Collect from children grouped by type
-            if node.is_a?(Model::ModelElement) && node.children
-              types_done = false
-              entities_done = false
-
-              node.children.select do |child|
-                !child.is_a?(Model::DataTypes::EnumerationItem) || node.is_a?(Model::Declarations::Type)
-              end.each do |child|
-                # Add types section remarks
-                if !types_done && child.is_a?(Model::Declarations::Type)
-                  types_done = true
-                end
-
-                # Add entities section remarks
-                if !entities_done && child.is_a?(Model::Declarations::Entity)
-                  entities_done = true
-                end
-
-                # Add subtype constraints Schema remark after last entity, before first subtype constraint
-                if entities_done && child.is_a?(Model::Declarations::SubtypeConstraint) && schema_remarks["subtype constraints"]
-                  remarks.push(format_untagged_remark(schema_remarks["subtype constraints"]))
-                  schema_remarks.delete("subtype constraints") # Only add once
-                end
-
-                # Recursively collect from child
-                remarks.concat(format_scope_remarks(child))
-              end
-            end
-          else
-            # For non-Schema nodes, use standard logic
-            skip_untagged_types = [
-              Model::Declarations::Entity,
-              Model::Declarations::Type,
-              Model::Declarations::Function,
-              Model::Declarations::Procedure,
-              Model::Declarations::Rule,
-              Model::Declarations::SubtypeConstraint,
-            ]
-
-            if !@no_remarks &&
-                node.is_a?(Model::ModelElement) &&
-                !node.untagged_remarks.nil? &&
-                skip_untagged_types.any? { |type| node.is_a?(type) }
-
-              remarks.concat(node.untagged_remarks.compact.grep(Model::RemarkInfo).map do |remark|
-                format_untagged_remark(remark)
-              end)
-            end
-
-            # Then recursively collect from children
-            if node.is_a?(Model::ModelElement) && node.children
-              node.children.select do |child|
-                !child.is_a?(Model::DataTypes::EnumerationItem) || node.is_a?(Model::Declarations::Type)
-              end.each do |child|
-                # Recursively collect remarks from child and its descendants
-                remarks.concat(format_scope_remarks(child))
-              end
-            end
-          end
-
-          remarks
-        end
       end
     end
   end

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

@@ -1,11 +1,12 @@
 module Expressir
   module Express
     module Formatters
-      # Formatter for RemarkItem declarations
       module RemarkItemFormatter
-        # Format a RemarkItem as an EXPRESS remark
-        # @param node [Model::Declarations::RemarkItem] The remark item to format
-        # @return [String] Formatted remark
+        def self.included(base)
+          base.register_formatter Model::Declarations::RemarkItem,
+                                  :format_remark_item
+        end
+
         def format_remark_item(node)
           return "" unless node.remarks&.any?
 

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

@@ -2,7 +2,31 @@ module Expressir
   module Express
     module Formatters
       module StatementsFormatter
-        private
+        def self.included(base)
+          base.register_formatter Model::Statements::Alias,
+                                  :format_statements_alias
+          base.register_formatter Model::Statements::Assignment,
+                                  :format_statements_assignment
+          base.register_formatter Model::Statements::Case,
+                                  :format_statements_case
+          base.register_formatter Model::Statements::CaseAction,
+                                  :format_statements_case_action
+          base.register_formatter Model::Statements::Compound,
+                                  :format_statements_compound
+          base.register_formatter Model::Statements::Escape,
+                                  :format_statements_escape
+          base.register_formatter Model::Statements::If, :format_statements_if
+          base.register_formatter Model::Statements::Null,
+                                  :format_statements_null
+          base.register_formatter Model::Statements::ProcedureCall,
+                                  :format_statements_procedure_call
+          base.register_formatter Model::Statements::Repeat,
+                                  :format_statements_repeat
+          base.register_formatter Model::Statements::Return,
+                                  :format_statements_return
+          base.register_formatter Model::Statements::Skip,
+                                  :format_statements_skip
+        end
 
         def format_statements_alias(node)
           [
@@ -82,10 +106,9 @@ module Expressir
         end
 
         def format_statements_case_action(node)
-          node.labels ||= []
           [
             [
-              node.labels.map { |x| format(x) }.join(", "),
+              Array(node.labels).map { |x| format(x) }.join(", "),
               " ",
               ":",
             ].join,
@@ -94,11 +117,11 @@ module Expressir
         end
 
         def format_statements_compound(node)
-          node.statements ||= []
+          statements = Array(node.statements)
           [
             "BEGIN",
-            *if node.statements&.length&.positive?
-               indent(node.statements.map { |x| format(x) }.join("\n"))
+            *if statements.length.positive?
+               indent(statements.map { |x| format(x) }.join("\n"))
              end,
             [
               "END",
@@ -144,7 +167,7 @@ module Expressir
         end
 
         def format_statements_repeat(node)
-          node.statements ||= []
+          statements = Array(node.statements)
           [
             [
               "REPEAT",
@@ -188,8 +211,8 @@ module Expressir
                end,
               ";",
             ].join,
-            *if node.statements&.length&.positive?
-               indent(node.statements.map { |x| format(x) }.join("\n"))
+            *if statements.length.positive?
+               indent(statements.map { |x| format(x) }.join("\n"))
              end,
             *format_remarks(node),
             [

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

@@ -2,7 +2,12 @@ module Expressir
   module Express
     module Formatters
       module SupertypeExpressionsFormatter
-        private
+        def self.included(base)
+          base.register_formatter Model::SupertypeExpressions::BinarySupertypeExpression,
+                                  :format_supertype_expressions_binary_supertype_expression
+          base.register_formatter Model::SupertypeExpressions::OneofSupertypeExpression,
+                                  :format_supertype_expressions_oneof_supertype_expression
+        end
 
         def format_supertype_expressions_binary_supertype_expression(node)
           supertype_precedence = self.class.const_get(:SUPERTYPE_OPERATOR_PRECEDENCE)
@@ -36,11 +41,10 @@ module Expressir
         end
 
         def format_supertype_expressions_oneof_supertype_expression(node)
-          node.operands ||= []
           [
             "ONEOF",
             "(",
-            node.operands.map { |x| format(x) }.join(", "),
+            Array(node.operands).map { |x| format(x) }.join(", "),
             ")",
           ].join
         end

data/lib/expressir/express/hyperlink_formatter.rb

@@ -8,14 +8,12 @@ module Expressir
     module HyperlinkFormatter
       # @!visibility private
       def self.included(mod)
-        if !mod.superclass.private_method_defined? :format_references_simple_reference
+        unless mod.superclass <= Expressir::Express::Formatter
           raise Error::FormatterMethodMissingError.new("HyperlinkFormatter",
                                                        "format_references_simple_reference")
         end
       end
 
-      private
-
       def format_references_simple_reference(node)
         return node.id unless node.base_path
 

data/lib/expressir/express/model_visitor.rb

@@ -6,7 +6,7 @@ module Expressir
         node.class.attributes.each_key do |symbol|
           next if ::Expressir::Model::ModelElement::SKIP_ATTRIBUTES.include?(symbol)
 
-          value = node.send(symbol)
+          value = node.public_send(symbol)
 
           case value
           when Array