expressir 2.3.6 → 2.3.7

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

data/lib/expressir/express/pretty_formatter.rb

@@ -74,8 +74,6 @@ module Expressir
         super(no_remarks: options.fetch(:no_remarks, false))
       end
 
-      private
-
       # Override indent to use configured width
       # @param str [String] String to indent
       # @return [String] Indented string
@@ -379,7 +377,6 @@ module Expressir
       def format_declarations_schema(node)
         indent_str = " " * @config.indent
         preamble = format_preamble_remarks(node, indent_str)
-
         schema_declarations = [
           *if node.constants&.length&.positive?
              [
@@ -435,8 +432,6 @@ module Expressir
       end
 
       # Override format_declarations_function to use aligned constants
-      # @param node [Model::Declarations::Function] Function node
-      # @return [String] Formatted function
       def format_declarations_function(node)
         [
           [
@@ -459,55 +454,12 @@ module Expressir
             format(node.return_type),
             ";",
           ].join,
-          *if node.types&.length&.positive?
-             indent(node.types.map { |x| format(x) }.join("\n"))
-           end,
-          *if node.entities&.length&.positive?
-             indent(node.entities.map { |x| format(x) }.join("\n"))
-           end,
-          *if node.subtype_constraints&.length&.positive?
-             indent(node.subtype_constraints.map { |x| format(x) }.join("\n"))
-           end,
-          *if node.functions&.length&.positive?
-             indent(node.functions.map { |x| format(x) }.join("\n"))
-           end,
-          *if node.procedures&.length&.positive?
-             indent(node.procedures.map { |x| format(x) }.join("\n"))
-           end,
-          *if node.constants&.length&.positive?
-             indent([
-               "CONSTANT",
-               indent(format_constant_block(node.constants)),
-               [
-                 "END_CONSTANT",
-                 ";",
-               ].join,
-             ].join("\n"))
-           end,
-          *if node.variables&.length&.positive?
-             indent([
-               "LOCAL",
-               indent(node.variables.map { |x| format(x) }.join("\n")),
-               [
-                 "END_LOCAL",
-                 ";",
-               ].join,
-             ].join("\n"))
-           end,
-          *if node.statements&.length&.positive?
-             indent(node.statements.map { |x| format(x) }.join("\n"))
-           end,
-          [
-            "END_FUNCTION",
-            ";",
-            format_end_scope_remark(node),
-          ].join,
+          *format_scope_body(node),
+          format_scope_footer("END_FUNCTION", node),
         ].join("\n")
       end
 
       # Override format_declarations_procedure to use aligned constants
-      # @param node [Model::Declarations::Procedure] Procedure node
-      # @return [String] Formatted procedure
       def format_declarations_procedure(node)
         [
           [
@@ -526,57 +478,13 @@ module Expressir
              end,
             ";",
           ].join,
-          *if node.types&.length&.positive?
-             indent(node.types.map { |x| format(x) }.join("\n"))
-           end,
-          *if node.entities&.length&.positive?
-             indent(node.entities.map { |x| format(x) }.join("\n"))
-           end,
-          *if node.subtype_constraints&.length&.positive?
-             indent(node.subtype_constraints.map { |x| format(x) }.join("\n"))
-           end,
-          *if node.functions&.length&.positive?
-             indent(node.functions.map { |x| format(x) }.join("\n"))
-           end,
-          *if node.procedures&.length&.positive?
-             indent(node.procedures.map { |x| format(x) }.join("\n"))
-           end,
-          *if node.constants&.length&.positive?
-             indent([
-               "CONSTANT",
-               indent(format_constant_block(node.constants)),
-               [
-                 "END_CONSTANT",
-                 ";",
-               ].join,
-             ].join("\n"))
-           end,
-          *if node.variables&.length&.positive?
-             indent([
-               "LOCAL",
-               indent(node.variables.map { |x| format(x) }.join("\n")),
-               [
-                 "END_LOCAL",
-                 ";",
-               ].join,
-             ].join("\n"))
-           end,
-          *if node.statements&.length&.positive?
-             indent(node.statements.map { |x| format(x) }.join("\n"))
-           end,
-          [
-            "END_PROCEDURE",
-            ";",
-            format_end_scope_remark(node),
-          ].join,
+          *format_scope_body(node),
+          format_scope_footer("END_PROCEDURE", node),
         ].join("\n")
       end
 
       # Override format_declarations_rule to use aligned constants
-      # @param node [Model::Declarations::Rule] Rule node
-      # @return [String] Formatted rule
       def format_declarations_rule(node)
-        node.applies_to ||= []
         [
           [
             "RULE",
@@ -586,10 +494,27 @@ module Expressir
             "FOR",
             " ",
             "(",
-            node.applies_to.map { |x| format(x) }.join(", "),
+            Array(node.applies_to).map { |x| format(x) }.join(", "),
             ")",
             ";",
           ].join,
+          *format_scope_body(node),
+          *if node.where_rules&.length&.positive?
+             [
+               "WHERE",
+               indent(node.where_rules.map { |x| format(x) }.join("\n")),
+             ]
+           end,
+          format_scope_footer("END_RULE", node),
+        ].join("\n")
+      end
+
+      # Shared scope body for function, procedure, and rule declarations.
+      # These declaration types share the same internal structure:
+      # types, entities, subtype_constraints, functions, procedures,
+      # constants, variables, statements.
+      def format_scope_body(node)
+        [
           *if node.types&.length&.positive?
              indent(node.types.map { |x| format(x) }.join("\n"))
            end,
@@ -628,17 +553,15 @@ module Expressir
           *if node.statements&.length&.positive?
              indent(node.statements.map { |x| format(x) }.join("\n"))
            end,
-          *if node.where_rules&.length&.positive?
-             [
-               "WHERE",
-               indent(node.where_rules.map { |x| format(x) }.join("\n")),
-             ]
-           end,
-          [
-            "END_RULE",
-            ";",
-          ].join,
-        ].join("\n")
+        ]
+      end
+
+      def format_scope_footer(keyword, node)
+        [
+          keyword,
+          ";",
+          format_end_scope_remark(node),
+        ].join
       end
     end
   end