expressir 2.3.5 → 2.3.7

data/lib/expressir/coverage.rb

@@ -282,18 +282,18 @@ module Expressir
     # @return [Boolean] True if the entity has documentation
     def self.entity_documented?(entity)
       # Check for direct remarks (types with Identifier module have remarks)
-      if entity.is_a?(Model::ModelElement) && entity.class.method_defined?(:remarks) && entity.remarks && !entity.remarks.empty?
+      if entity.is_a?(Model::HasRemarks) && entity.remarks && !entity.remarks.empty?
         return true
       end
 
       # Check for remark_items (types with Identifier module have remark_items)
-      if entity.is_a?(Model::ModelElement) && entity.class.method_defined?(:remark_items) && entity.remark_items && !entity.remark_items.empty?
+      if entity.is_a?(Model::HasRemarkItems) && entity.remark_items && !entity.remark_items.empty?
         return true
       end
 
       # For schema entities, check if there's a remark_item with their ID
       parent = entity.parent
-      if parent.is_a?(Model::ModelElement) && parent.class.method_defined?(:remark_items) && parent.remark_items
+      if parent.is_a?(Model::HasRemarkItems) && parent.remark_items
         entity_id = entity.id.to_s.downcase
         parent.remark_items.any? do |item|
           item.id.to_s.downcase == entity_id || item.id.to_s.downcase.include?("#{entity_id}.")
@@ -331,7 +331,7 @@ module Expressir
       # Filter out nil elements and ensure all have IDs
       # Note: Some ModelElement types (like Interface) don't have id
       entities = entities.compact.select do |e|
-        e.is_a?(Model::ModelElement) && e.class.method_defined?(:id) && e.id
+        e.is_a?(Model::HasId) && e.id
       end
 
       # Filter out skipped entity types

data/lib/expressir/express/builder.rb

@@ -354,7 +354,7 @@ module Expressir
         end
 
         def attach_source_info(result, data)
-          return unless @source && result.is_a?(Model::ModelElement)
+          return unless @source && result.is_a?(Expressir::Model::ModelElement)
 
           source_info = extract_source_info(data)
           return unless source_info

data/lib/expressir/express/builder_registry.rb

@@ -181,18 +181,18 @@ module Expressir
       Builder.register(:interval_high) { |d| expression.build_interval_high(d) }
       Builder.register(:interval_item) { |d| expression.build_interval_item(d) }
       Builder.register(:interval_op) do |d|
-        expression.send(:extract_interval_op, d)
+        expression.extract_interval_op(d)
       end
 
       # Operators
       Builder.register(:add_like_op) do |d|
-        expression.send(:extract_operator, d)
+        expression.extract_operator(d)
       end
       Builder.register(:mul_like_op) do |d|
-        expression.send(:extract_operator, d)
+        expression.extract_operator(d)
       end
-      Builder.register(:unary_op) { |d| expression.send(:extract_unary_op, d) }
-      Builder.register(:rel_op) { |d| expression.send(:extract_rel_op, d) }
+      Builder.register(:unary_op) { |d| expression.extract_unary_op(d) }
+      Builder.register(:rel_op) { |d| expression.extract_rel_op(d) }
 
       # ========================================================================
       # Interface Builder (closures)
@@ -319,45 +319,22 @@ module Expressir
         subtype_constraint.build_total_over(d)
       end
 
-      Builder.register(:subtype_constraint_decl) do |d|
-        subtype_constraint.build_subtype_constraint_decl(d)
-      end
-      Builder.register(:total_over) do |d|
-        subtype_constraint.build_total_over(d)
-      end
-      Builder.register(:supertype_expression) do |d|
-        subtype_constraint.build_supertype_expression(d)
-      end
-      Builder.register(:supertype_factor) do |d|
-        subtype_constraint.build_supertype_factor(d)
-      end
-      Builder.register(:supertype_term) do |d|
-        subtype_constraint.build_supertype_term(d)
-      end
-      Builder.register(:one_of) { |d| subtype_constraint.build_one_of(d) }
-      Builder.register(:supertype_rule) do |d|
-        subtype_constraint.build_supertype_rule(d)
-      end
-      Builder.register(:subtype_constraint) do |d|
-        subtype_constraint.build_subtype_constraint(d)
-      end
-      Builder.register(:subtype_declaration) do |d|
-        subtype_constraint.build_subtype_declaration(d)
-      end
-
       # ========================================================================
       # Type Builder (closures)
       # ========================================================================
 
       # Simple types
-      %i[boolean_type integer_type logical_type number_type].each do |type|
-        Builder.register(type) { |d| type_builder.send(:"build_#{type}", d) }
-      end
+      Builder.register(:boolean_type) { |d| type_builder.build_boolean_type(d) }
+      Builder.register(:integer_type) { |d| type_builder.build_integer_type(d) }
+      Builder.register(:logical_type) { |d| type_builder.build_logical_type(d) }
+      Builder.register(:number_type) { |d| type_builder.build_number_type(d) }
 
       # Type constructors
       Builder.register(:generic_type) { |_d| Expressir::Model::DataTypes::Generic.new }
       Builder.register(:generic_entity_type) { |_d| Expressir::Model::DataTypes::GenericEntity.new }
-      Builder.register(:aggregate_type) { |_d| Expressir::Model::DataTypes::Aggregate.new }
+      Builder.register(:aggregate_type) do |d|
+        type_builder.build_aggregate_type(d)
+      end
       Builder.register(:general_set_type) do |d|
         type_builder.build_general_set_type(d)
       end

data/lib/expressir/express/builders/constant_builder.rb

@@ -36,7 +36,10 @@ module Expressir
           ids = if ids_data.is_a?(Hash)
                   [Builder.build({ variable_id: ids_data })]
                 elsif ids_data.is_a?(Array)
-                  ids_data.map { |id| Builder.build({ variable_id: id }) }
+                  ids_data.filter_map do |elem|
+                    actual_id = elem[:variable_id] || elem
+                    Builder.build({ variable_id: actual_id })
+                  end
                 else
                   []
                 end
@@ -64,7 +67,10 @@ module Expressir
           ids = if ids_data.is_a?(Hash)
                   [Builder.build({ parameter_id: ids_data })]
                 elsif ids_data.is_a?(Array)
-                  ids_data.map { |id| Builder.build({ parameter_id: id }) }
+                  ids_data.filter_map do |elem|
+                    actual_id = elem[:parameter_id] || elem
+                    Builder.build({ parameter_id: actual_id })
+                  end
                 else
                   []
                 end

data/lib/expressir/express/builders/expression_builder.rb

@@ -43,7 +43,7 @@ module Expressir
           term = Builder.build_term(ast_data[:term])
           rhs = ast_data[:rhs]
 
-          return term if rhs.nil? || (rhs.respond_to?(:empty?) && rhs.empty?)
+          return term if rhs.nil? || (rhs.is_a?(Array) && rhs.empty?)
 
           rhs_array = rhs.is_a?(Array) ? rhs : [rhs]
 
@@ -74,7 +74,7 @@ module Expressir
           factor = Builder.build_factor(ast_data[:factor])
           rhs = ast_data[:rhs]
 
-          return factor if rhs.nil? || (rhs.respond_to?(:empty?) && rhs.empty?)
+          return factor if rhs.nil? || (rhs.is_a?(Array) && rhs.empty?)
 
           rhs_array = rhs.is_a?(Array) ? rhs : [rhs]
 

data/lib/expressir/express/builders/helpers.rb

@@ -9,11 +9,9 @@ module Expressir
         # Extract text from Parsanol::Slice or return as-is
         def extract_text(val)
           return nil unless val
-          # Handle String, Symbol, and objects with to_str (duck typing via class check)
           return val.to_s if val.is_a?(String)
           return val.to_s if val.is_a?(Symbol)
-          # Handle Parsanol Slice objects - they respond to to_s but not to_str
-          return val.to_s if val.class.name&.include?("Slice")
+          return val.to_s if val.is_a?(Parsanol::Slice)
 
           if val.is_a?(Hash)
             str = val[:str]
@@ -34,8 +32,7 @@ module Expressir
           return nil unless data
           return data.to_s if data.is_a?(String)
           return data.to_s if data.is_a?(Symbol)
-          # Handle Parsanol Slice objects
-          return data.to_s if data.class.name&.include?("Slice")
+          return data.to_s if data.is_a?(Parsanol::Slice)
 
           if data.is_a?(Hash)
             str = data[:str]
@@ -141,9 +138,6 @@ module Expressir
           when Expressir::Model::References::SimpleReference
             Expressir::Model::References::AttributeReference.new(ref: ref,
                                                                  attribute: qualifier)
-          when Hash
-            Expressir::Model::References::IndexReference.new(ref: ref,
-                                                             index1: qualifier[:index1], index2: qualifier[:index2])
           else
             ref
           end

data/lib/expressir/express/builders/procedure_decl_builder.rb

@@ -62,7 +62,8 @@ module Expressir
 
           parameters = []
           Builder.ensure_array(params_data).each do |param|
-            result = Builder.build({ procedure_head_parameter: param })
+            actual_param = param[:procedure_head_parameter] || param
+            result = Builder.build({ procedure_head_parameter: actual_param })
             parameters.concat(Builder.ensure_array(result)) if result
           end
           parameters

data/lib/expressir/express/builders/qualifier_builder.rb

@@ -65,7 +65,8 @@ module Expressir
         def build_index_qualifier(ast_data)
           index1 = Builder.build_optional(ast_data[:index1])
           index2 = Builder.build_optional(ast_data[:index2])
-          { index1: index1, index2: index2 }
+          Expressir::Model::References::IndexReference.new(index1: index1,
+                                                           index2: index2)
         end
 
         def build_index1(ast_data)

data/lib/expressir/express/builders/statement_builder.rb

@@ -85,12 +85,14 @@ module Expressir
         def build_case_stmt(ast_data)
           selector = Builder.build_optional(ast_data[:selector])
           actions = Builder.build_children(ast_data[:case_action])
-          otherwise = Builder.build_children(ast_data[:otherwise]&.dig(:stmt))
+          otherwise_stmt = if ast_data[:t_otherwise] && ast_data[:stmt].is_a?(Hash)
+                             Builder.build({ stmt: ast_data[:stmt] })
+                           end
 
           Expressir::Model::Statements::Case.new(
             expression: selector,
             actions: actions.compact,
-            otherwise: otherwise.compact,
+            otherwise_statement: otherwise_stmt,
           )
         end
 
@@ -101,12 +103,23 @@ module Expressir
         end
 
         def build_case_action(ast_data)
-          labels = Builder.build_children(ast_data[:case_label])
-          statements = Builder.build_children(ast_data[:stmt])
+          label_data = ast_data[:list_of_case_label]
+          labels = if label_data.is_a?(Hash)
+                     Builder.build_children(label_data[:case_label])
+                   elsif label_data.is_a?(Array)
+                     label_data.flat_map do |item|
+                       Builder.build_children(item.is_a?(Hash) ? item[:case_label] : item)
+                     end
+                   else
+                     []
+                   end
+          stmt = if ast_data[:stmt].is_a?(Hash)
+                   Builder.build({ stmt: ast_data[:stmt] })
+                 end
 
           Expressir::Model::Statements::CaseAction.new(
             labels: labels.compact,
-            statements: statements.compact,
+            statement: stmt,
           )
         end
 

data/lib/expressir/express/builders/type_builder.rb

@@ -7,18 +7,20 @@ module Expressir
       class TypeBuilder
         include ::Expressir::Express::Builders::Helpers
 
-        # Simple types
-        {
-          boolean_type: Expressir::Model::DataTypes::Boolean,
-          integer_type: Expressir::Model::DataTypes::Integer,
-          logical_type: Expressir::Model::DataTypes::Logical,
-          number_type: Expressir::Model::DataTypes::Number,
-          generic_type: Expressir::Model::DataTypes::Generic,
-          generic_entity_type: Expressir::Model::DataTypes::GenericEntity,
-        }.each do |type_name, klass|
-          define_method(:"build_#{type_name}") do |_ast_data|
-            klass.new
-          end
+        def build_boolean_type(_ast_data)
+          Expressir::Model::DataTypes::Boolean.new
+        end
+
+        def build_integer_type(_ast_data)
+          Expressir::Model::DataTypes::Integer.new
+        end
+
+        def build_logical_type(_ast_data)
+          Expressir::Model::DataTypes::Logical.new
+        end
+
+        def build_number_type(_ast_data)
+          Expressir::Model::DataTypes::Number.new
         end
 
         # String type
@@ -49,6 +51,12 @@ module Expressir
           end
         end
 
+        # Aggregate type (AGGREGATE OF type)
+        def build_aggregate_type(ast_data)
+          base_type = Builder.build_optional(ast_data[:parameter_type])
+          Expressir::Model::DataTypes::Aggregate.new(base_type: base_type)
+        end
+
         # Aggregation types
         def build_array_type(ast_data)
           build_aggregation_type(ast_data, Expressir::Model::DataTypes::Array)

data/lib/expressir/express/formatter.rb

@@ -1,6 +1,18 @@
 module Expressir
   module Express
     class Formatter
+      # Registry infrastructure — must precede includes so modules can register handlers
+      @format_registry = {}
+
+      def self.format_registry
+        @format_registry || superclass&.format_registry
+      end
+
+      def self.register_formatter(model_class, method_name)
+        @format_registry[model_class] = method_name
+      end
+
+      # Include formatter modules — each registers its handlers via self.included
       include Formatters::RemarkItemFormatter
       include Formatters::RemarkFormatter
       include Formatters::LiteralsFormatter
@@ -11,6 +23,14 @@ module Expressir
       include Formatters::DataTypesFormatter
       include Formatters::DeclarationsFormatter
 
+      # Handlers for types implemented directly in this class
+      register_formatter Model::Repository, :format_repository
+      register_formatter Model::ExpFile, :format_exp_file
+      register_formatter Model::Declarations::SchemaVersionItem, :format_noop
+      register_formatter Model::Declarations::InterfacedItem, :format_noop
+      register_formatter Model::Cache, :format_noop
+      register_formatter Model::ModelElement, :format_noop
+
       INDENT_CHAR = " ".freeze
       INDENT_WIDTH = 2
       INDENT = INDENT_CHAR * INDENT_WIDTH
@@ -54,177 +74,25 @@ module Expressir
         @no_remarks = no_remarks
       end
 
-      # Formats Express model into an Express code
-      # @param [Model::ModelElement] node
-      # @return [String]
       def self.format(node)
-        formatter = new
-        formatter.format(node)
+        new.format(node)
       end
 
-      # Formats Express model into an Express code
-      # @param [Model::ModelElement] node
-      # @return [String]
-      def format(node) # rubocop:disable Metrics/MethodLength
-        case node
-        when Model::Repository
-          format_repository(node)
-        when Model::ExpFile
-          format_exp_file(node)
-        when Model::Declarations::Attribute
-          format_declarations_attribute(node)
-        when Model::Declarations::Constant
-          format_declarations_constant(node)
-        when Model::Declarations::Entity
-          format_declarations_entity(node)
-        when Model::Declarations::Function
-          format_declarations_function(node)
-        when Model::Declarations::Interface
-          format_declarations_interface(node)
-        when Model::Declarations::InterfaceItem
-          format_declarations_interface_item(node)
-        when Model::Declarations::Parameter
-          format_declarations_parameter(node)
-        when Model::Declarations::Procedure
-          format_declarations_procedure(node)
-        when Model::Declarations::Rule
-          format_declarations_rule(node)
-        when Model::Declarations::Schema
-          format_declarations_schema(node)
-        when Model::Declarations::SchemaVersion
-          format_declarations_schema_version(node)
-        when Model::Declarations::SubtypeConstraint
-          format_declarations_subtype_constraint(node)
-        when Model::Declarations::Type
-          format_declarations_type(node)
-        when Model::Declarations::UniqueRule
-          format_declarations_unique_rule(node)
-        when Model::Declarations::Variable
-          format_declarations_variable(node)
-        when Model::Declarations::WhereRule
-          format_declarations_where_rule(node)
-        when Model::Declarations::InformalPropositionRule
-          format_declarations_informal_proposition_rule(node)
-        when Model::DataTypes::Aggregate
-          format_data_types_aggregate(node)
-        when Model::DataTypes::Array
-          format_data_types_array(node)
-        when Model::DataTypes::Bag
-          format_data_types_bag(node)
-        when Model::DataTypes::Binary
-          format_data_types_binary(node)
-        when Model::DataTypes::Boolean
-          format_data_types_boolean(node)
-        when Model::DataTypes::Enumeration
-          format_data_types_enumeration(node)
-        when Model::DataTypes::EnumerationItem
-          format_data_types_enumeration_item(node)
-        when Model::DataTypes::GenericEntity
-          format_data_types_generic_entity(node)
-        when Model::DataTypes::Generic
-          format_data_types_generic(node)
-        when Model::DataTypes::Integer
-          format_data_types_integer(node)
-        when Model::DataTypes::List
-          format_data_types_list(node)
-        when Model::DataTypes::Logical
-          format_data_types_logical(node)
-        when Model::DataTypes::Number
-          format_data_types_number(node)
-        when Model::DataTypes::Real
-          format_data_types_real(node)
-        when Model::DataTypes::Select
-          format_data_types_select(node)
-        when Model::DataTypes::Set
-          format_data_types_set(node)
-        when Model::DataTypes::String
-          format_data_types_string(node)
-        when Model::Expressions::AggregateInitializer
-          format_expressions_aggregate_initializer(node)
-        when Model::Expressions::AggregateInitializerItem
-          format_expressions_aggregate_initializer_item(node)
-        when Model::Expressions::BinaryExpression
-          format_expressions_binary_expression(node)
-        when Model::Expressions::EntityConstructor
-          format_expressions_entity_constructor(node)
-        when Model::Expressions::FunctionCall
-          format_expressions_function_call(node)
-        when Model::Expressions::Interval
-          format_expressions_interval(node)
-        when Model::Expressions::QueryExpression
-          format_expressions_query_expression(node)
-        when Model::Expressions::UnaryExpression
-          format_expressions_unary_expression(node)
-        when Model::Literals::Binary
-          format_literals_binary(node)
-        when Model::Literals::Integer
-          format_literals_integer(node)
-        when Model::Literals::Logical
-          format_literals_logical(node)
-        when Model::Literals::Real
-          format_literals_real(node)
-        when Model::Literals::String
-          format_literals_string(node)
-        when Model::References::AttributeReference
-          format_references_attribute_reference(node)
-        when Model::References::GroupReference
-          format_references_group_reference(node)
-        when Model::References::IndexReference
-          format_references_index_reference(node)
-        when Model::References::SimpleReference
-          format_references_simple_reference(node)
-        when Model::Statements::Alias
-          format_statements_alias(node)
-        when Model::Statements::Assignment
-          format_statements_assignment(node)
-        when Model::Statements::Case
-          format_statements_case(node)
-        when Model::Statements::CaseAction
-          format_statements_case_action(node)
-        when Model::Statements::Compound
-          format_statements_compound(node)
-        when Model::Statements::Escape
-          format_statements_escape(node)
-        when Model::Statements::If
-          format_statements_if(node)
-        when Model::Statements::Null
-          format_statements_null(node)
-        when Model::Statements::ProcedureCall
-          format_statements_procedure_call(node)
-        when Model::Statements::Repeat
-          format_statements_repeat(node)
-        when Model::Statements::Return
-          format_statements_return(node)
-        when Model::Statements::Skip
-          format_statements_skip(node)
-        when Model::SupertypeExpressions::BinarySupertypeExpression
-          format_supertype_expressions_binary_supertype_expression(node)
-        when Model::SupertypeExpressions::OneofSupertypeExpression
-          format_supertype_expressions_oneof_supertype_expression(node)
-        when Model::Declarations::SchemaVersionItem
-          # not implemented yet
-        when Model::Declarations::InterfacedItem
-          # not implemented yet
-        when Model::Declarations::RemarkItem
-          format_remark_item(node)
-        when Model::Cache
-          # not implemented yet
-        when Model::ModelElement
-          # not implemented yet
-        when Model::Literals::Logical
-          node.value
-        when NilClass
-          # not implemented yet
-        else
-          warn "#{node.class.name} format not implemented"
-          ""
-        end
+      def format(node)
+        return "" if node.nil?
+
+        handler = self.class.format_registry[node.class]
+        return public_send(handler, node) if handler
+
+        warn "#{node.class.name} format not implemented"
+        ""
       end
 
-      private
+      def format_noop(_node)
+        ""
+      end
 
       def format_repository(node)
-        # Format each file in the repository
         result = node.files&.map { |f| format(f) }&.join("\n\n")
         result ? "#{result}\n" : ""
       end

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

@@ -2,10 +2,53 @@ module Expressir
   module Express
     module Formatters
       module DataTypesFormatter
-        private
+        def self.included(base)
+          base.register_formatter Model::DataTypes::Aggregate,
+                                  :format_data_types_aggregate
+          base.register_formatter Model::DataTypes::Array,
+                                  :format_data_types_array
+          base.register_formatter Model::DataTypes::Bag, :format_data_types_bag
+          base.register_formatter Model::DataTypes::Binary,
+                                  :format_data_types_binary
+          base.register_formatter Model::DataTypes::Boolean,
+                                  :format_data_types_boolean
+          base.register_formatter Model::DataTypes::Enumeration,
+                                  :format_data_types_enumeration
+          base.register_formatter Model::DataTypes::EnumerationItem,
+                                  :format_data_types_enumeration_item
+          base.register_formatter Model::DataTypes::GenericEntity,
+                                  :format_data_types_generic_entity
+          base.register_formatter Model::DataTypes::Generic,
+                                  :format_data_types_generic
+          base.register_formatter Model::DataTypes::Integer,
+                                  :format_data_types_integer
+          base.register_formatter Model::DataTypes::List,
+                                  :format_data_types_list
+          base.register_formatter Model::DataTypes::Logical,
+                                  :format_data_types_logical
+          base.register_formatter Model::DataTypes::Number,
+                                  :format_data_types_number
+          base.register_formatter Model::DataTypes::Real,
+                                  :format_data_types_real
+          base.register_formatter Model::DataTypes::Select,
+                                  :format_data_types_select
+          base.register_formatter Model::DataTypes::Set, :format_data_types_set
+          base.register_formatter Model::DataTypes::String,
+                                  :format_data_types_string
+        end
 
-        def format_data_types_aggregate(_node)
-          "AGGREGATE"
+        def format_data_types_aggregate(node)
+          [
+            "AGGREGATE",
+            *if node.base_type
+               [
+                 " ",
+                 "OF",
+                 " ",
+                 format(node.base_type),
+               ]
+             end,
+          ].join
         end
 
         def format_data_types_array(node)
@@ -220,7 +263,7 @@ module Expressir
 
         def format_data_types_select(node)
           indent_char = self.class.const_get(:INDENT_CHAR)
-          node.items ||= []
+          items = Array(node.items)
           [
             *if node.extensible
                [
@@ -241,7 +284,7 @@ module Expressir
                  "BASED_ON",
                  " ",
                  format(node.based_on),
-                 *if node.items&.length&.positive?
+                 *if items.length.positive?
                     item_indent = indent_char * "(".length
                     [
                       " ",
@@ -249,7 +292,7 @@ module Expressir
                       "\n",
                       indent([
                         "(",
-                        node.items.map do |x|
+                        items.map do |x|
                           format(x)
                         end.join(",\n#{item_indent}"),
                         ")",
@@ -257,14 +300,14 @@ module Expressir
                     ].join
                   end,
                ].join
-             else
+             elsif items.length.positive?
                indent_char = self.class.const_get(:INDENT_CHAR)
                item_indent = indent_char * "(".length
                [
                  "\n",
                  indent([
                    "(",
-                   node.items.map do |x|
+                   items.map do |x|
                      format(x)
                    end.join(",\n#{item_indent}"),
                    ")",