expressir 2.4.29-arm-linux-musl

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds rule declaration nodes.
+      class RuleDeclBuilder
+        def call(ast_data)
+          head = ast_data[:rule_head]
+          algorithm_head = ast_data[:algorithm_head]
+          stmts = ast_data[:stmt]
+          where_clause = ast_data[:where_clause]
+
+          id = Builder.build_optional(head[:rule_id]) if head
+          applies_to = build_applies_to(head)
+
+          declarations = []
+          if algorithm_head.is_a?(Hash)
+            declarations = Builder.build_children(algorithm_head[:declaration])
+          end
+
+          types = declarations.grep(Expressir::Model::Declarations::Type)
+          entities = declarations.grep(Expressir::Model::Declarations::Entity)
+          subtype_constraints = declarations.grep(Expressir::Model::Declarations::SubtypeConstraint)
+          functions = declarations.grep(Expressir::Model::Declarations::Function)
+          procedures = declarations.grep(Expressir::Model::Declarations::Procedure)
+          constants = if algorithm_head.is_a?(Hash) && algorithm_head[:constant_decl]
+                        build_constant_decl(algorithm_head[:constant_decl])
+                      else
+                        []
+                      end
+          variables = if algorithm_head.is_a?(Hash) && algorithm_head[:local_decl]
+                        build_local_decl(algorithm_head[:local_decl])
+                      else
+                        []
+                      end
+          statements = Builder.build_children(stmts)
+          where_rules = where_clause ? Builder.build({ where_clause: where_clause }) : []
+
+          Expressir::Model::Declarations::Rule.new(
+            id: id,
+            applies_to: Builder.ensure_array(applies_to),
+            types: types,
+            entities: entities,
+            subtype_constraints: subtype_constraints,
+            functions: functions,
+            procedures: procedures,
+            constants: constants,
+            variables: variables,
+            statements: statements.compact,
+            where_rules: [where_rules].flatten,
+          )
+        end
+
+        private
+
+        def build_applies_to(head)
+          return [] unless head && head[:list_of_entity_ref]
+
+          entity_refs = head[:list_of_entity_ref]
+          refs = []
+
+          # entity_refs can be:
+          # - A Hash with entity_ref key (single entity)
+          # - An Array of Hashes (multiple entities)
+          if entity_refs.is_a?(Array)
+            entity_refs.each do |item|
+              if item[:entity_ref]
+                refs << Builder.build({ entity_ref: item[:entity_ref] })
+              end
+            end
+          elsif entity_refs.is_a?(Hash)
+            if entity_refs[:entity_ref]
+              refs << Builder.build({ entity_ref: entity_refs[:entity_ref] })
+            end
+            if entity_refs[:item]
+              Builder.ensure_array(entity_refs[:item]).each do |item|
+                if item[:entity_ref]
+                  refs << Builder.build({ entity_ref: item[:entity_ref] })
+                end
+              end
+            end
+          end
+          refs.compact
+        end
+
+        def build_constant_decl(data)
+          Builder.build_children(data[:constant_body])
+        end
+
+        def build_local_decl(data)
+          Builder.build_children(data[:local_variable])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds schema_body_declaration nodes - dispatches to declaration or rule.
+      class SchemaBodyDeclBuilder
+        def call(ast_data)
+          if ast_data[:declaration]
+            Builder.build({ declaration: ast_data[:declaration] })
+          elsif ast_data[:rule_decl]
+            Builder.build({ rule_decl: ast_data[:rule_decl] })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds schema_decl nodes into Schema objects.
+      class SchemaDeclBuilder
+        def call(ast_data)
+          id = Builder.build_optional(ast_data[:schema_id])
+          version = if ast_data[:schema_version_id]
+                      Builder.build({ schema_version_id: ast_data[:schema_version_id] })
+                    end
+
+          interfaces = []
+          constants = []
+          declarations = []
+
+          if ast_data[:schema_body]
+            interfaces = Builder.build_children(ast_data[:schema_body][:interface_specification])
+            constants = build_constants(ast_data[:schema_body][:constant_decl])
+            body_decls = ast_data[:schema_body][:schema_body_declaration]
+            declarations = Builder.build_children(body_decls) if body_decls
+          end
+
+          types = declarations.grep(Expressir::Model::Declarations::Type)
+          entities = declarations.grep(Expressir::Model::Declarations::Entity)
+          subtype_constraints = declarations.grep(Expressir::Model::Declarations::SubtypeConstraint)
+          functions = declarations.grep(Expressir::Model::Declarations::Function)
+          rules = declarations.grep(Expressir::Model::Declarations::Rule)
+          procedures = declarations.grep(Expressir::Model::Declarations::Procedure)
+
+          Expressir::Model::Declarations::Schema.new(
+            id: id,
+            version: version,
+            interfaces: interfaces.compact,
+            constants: [constants].flatten,
+            types: types,
+            entities: entities,
+            subtype_constraints: subtype_constraints,
+            functions: functions,
+            rules: rules,
+            procedures: procedures,
+          )
+        end
+
+        private
+
+        def build_constants(data)
+          return [] unless data
+
+          Builder.build_children(data[:constant_body])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds schema_version_id nodes into SchemaVersion objects.
+      class SchemaVersionBuilder
+        def call(ast_data)
+          string_val = Builder.build_optional(ast_data[:string_literal])
+          value = string_val.is_a?(Expressir::Model::Literals::String) ? string_val.value : string_val.to_s
+
+          items = nil
+          if value.start_with?("{") && value.end_with?("}")
+            parts = value[1..-2].split
+            items = parts.map do |part|
+              if (match = part.match(/^(.+)\((\d+)\)$/))
+                Expressir::Model::Declarations::SchemaVersionItem.new(
+                  name: match[1], value: match[2],
+                )
+              elsif /^\d+$/.match?(part)
+                Expressir::Model::Declarations::SchemaVersionItem.new(value: part)
+              else
+                Expressir::Model::Declarations::SchemaVersionItem.new(name: part)
+              end
+            end
+          end
+
+          Expressir::Model::Declarations::SchemaVersion.new(value: value,
+                                                            items: items)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds simple ID nodes (simple_id, schema_id, entity_id, etc.)
+      # These return a string, not a Model object.
+      class SimpleIdBuilder
+        include ::Expressir::Express::Builders::Helpers
+
+        def call(ast_data)
+          extract_text(ast_data[:str]) || extract_text(ast_data[:simple_id]&.dig(:str))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds statement nodes (assignment, if, case, repeat, etc.).
+      class StatementBuilder
+        include ::Expressir::Express::Builders::Helpers
+
+        # stmt - choice dispatcher
+        def build_stmt(ast_data)
+          if ast_data[:assignment_stmt]
+            Builder.build({ assignment_stmt: ast_data[:assignment_stmt] })
+          elsif ast_data[:alias_stmt]
+            Builder.build({ alias_stmt: ast_data[:alias_stmt] })
+          elsif ast_data[:if_stmt]
+            Builder.build({ if_stmt: ast_data[:if_stmt] })
+          elsif ast_data[:case_stmt]
+            Builder.build({ case_stmt: ast_data[:case_stmt] })
+          elsif ast_data[:compound_stmt]
+            Builder.build({ compound_stmt: ast_data[:compound_stmt] })
+          elsif ast_data[:repeat_stmt]
+            Builder.build({ repeat_stmt: ast_data[:repeat_stmt] })
+          elsif ast_data[:return_stmt]
+            Builder.build({ return_stmt: ast_data[:return_stmt] })
+          elsif ast_data[:escape_stmt]
+            Builder.build({ escape_stmt: ast_data[:escape_stmt] })
+          elsif ast_data[:skip_stmt]
+            Builder.build({ skip_stmt: ast_data[:skip_stmt] })
+          elsif ast_data[:null_stmt]
+            Builder.build({ null_stmt: ast_data[:null_stmt] })
+          elsif ast_data[:procedure_call_stmt]
+            Builder.build({ procedure_call_stmt: ast_data[:procedure_call_stmt] })
+          end
+        end
+
+        def build_assignment_stmt(ast_data)
+          ref = Builder.build_optional(ast_data[:general_ref])
+          expression = if ast_data[:expression]
+                         Builder.build({ expression: ast_data[:expression] })
+                       end
+
+          if ast_data[:qualifier]
+            Builder.ensure_array(ast_data[:qualifier]).each do |qual|
+              qual_result = Builder.build({ qualifier: qual })
+              ref = apply_qualifier(ref, qual_result)
+            end
+          end
+
+          Expressir::Model::Statements::Assignment.new(ref: ref,
+                                                       expression: expression)
+        end
+
+        def build_alias_stmt(ast_data)
+          var_id = Builder.build_optional(ast_data[:variable_id])
+          expression = Builder.build_optional(ast_data[:general_ref])
+          statements = Builder.build_children(ast_data[:stmt])
+
+          if ast_data[:qualifier] && expression
+            Builder.ensure_array(ast_data[:qualifier]).each do |qual|
+              qual_result = Builder.build({ qualifier: qual })
+              expression = apply_qualifier(expression, qual_result)
+            end
+          end
+
+          Expressir::Model::Statements::Alias.new(
+            id: var_id,
+            expression: expression,
+            statements: statements.compact,
+          )
+        end
+
+        def build_if_stmt(ast_data)
+          expression = Builder.build_optional(ast_data[:logical_expression])
+          then_stmts = Builder.build_children(ast_data[:if_stmt_statements]&.dig(:stmt))
+          else_stmts = Builder.build_children(ast_data[:if_stmt_else_statements]&.dig(:stmt))
+
+          Expressir::Model::Statements::If.new(
+            expression: expression,
+            statements: then_stmts.compact,
+            else_statements: else_stmts.compact,
+          )
+        end
+
+        def build_case_stmt(ast_data)
+          selector = Builder.build_optional(ast_data[:selector])
+          actions = Builder.build_children(ast_data[:case_action])
+          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_statement: otherwise_stmt,
+          )
+        end
+
+        def build_selector(ast_data)
+          if ast_data[:expression]
+            Builder.build({ expression: ast_data[:expression] })
+          end
+        end
+
+        def build_case_action(ast_data)
+          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,
+            statement: stmt,
+          )
+        end
+
+        def build_case_label(ast_data)
+          if ast_data[:expression]
+            Builder.build({ expression: ast_data[:expression] })
+          end
+        end
+
+        def build_compound_stmt(ast_data)
+          statements = Builder.build_children(ast_data[:stmt])
+          Expressir::Model::Statements::Compound.new(statements: statements.compact)
+        end
+
+        def build_repeat_stmt(ast_data)
+          control = ast_data[:repeat_control]
+          statements = Builder.build_children(ast_data[:stmt])
+
+          var_id = nil
+          bound1 = nil
+          bound2 = nil
+          increment = nil
+
+          increment_control = control[:increment_control] if control.is_a?(Hash)
+          if increment_control.is_a?(Hash)
+            var_id = Builder.build_optional(increment_control[:variable_id])
+            bound1 = Builder.build_optional(increment_control[:bound1])
+            bound2 = Builder.build_optional(increment_control[:bound2])
+            increment = Builder.build_optional(increment_control[:increment])
+          end
+
+          while_ctrl = control.is_a?(Hash) ? control[:while_control] : nil
+          until_ctrl = control.is_a?(Hash) ? control[:until_control] : nil
+
+          while_expression = if while_ctrl.is_a?(Hash)
+                               Builder.build_optional(while_ctrl[:logical_expression])
+                             end
+          until_expression = if until_ctrl.is_a?(Hash)
+                               Builder.build_optional(until_ctrl[:logical_expression])
+                             end
+
+          Expressir::Model::Statements::Repeat.new(
+            id: var_id,
+            bound1: bound1,
+            bound2: bound2,
+            increment: increment,
+            while_expression: while_expression,
+            until_expression: until_expression,
+            statements: statements.compact,
+          )
+        end
+
+        def build_increment_control(_ast_data)
+          nil
+        end
+
+        def build_increment(ast_data)
+          Builder.build_optional(ast_data[:numeric_expression])
+        end
+
+        def build_while_control(ast_data)
+          Builder.build_optional(ast_data[:logical_expression])
+        end
+
+        def build_until_control(ast_data)
+          Builder.build_optional(ast_data[:logical_expression])
+        end
+
+        def build_return_stmt(ast_data)
+          expression = if ast_data[:expression]
+                         Builder.build({ expression: ast_data[:expression] })
+                       end
+          Expressir::Model::Statements::Return.new(expression: expression)
+        end
+
+        def build_escape_stmt(_ast_data)
+          Expressir::Model::Statements::Escape.new
+        end
+
+        def build_skip_stmt(_ast_data)
+          Expressir::Model::Statements::Skip.new
+        end
+
+        def build_null_stmt(_ast_data)
+          Expressir::Model::Statements::Null.new
+        end
+
+        def build_procedure_call_stmt(ast_data)
+          proc_ref = if ast_data[:procedure_ref]
+                       Builder.build({ procedure_ref: ast_data[:procedure_ref] })
+                     elsif ast_data[:built_in_procedure]
+                       Builder.build({ built_in_procedure: ast_data[:built_in_procedure] })
+                     end
+          params = if ast_data[:actual_parameter_list]
+                     Builder.build({ actual_parameter_list: ast_data[:actual_parameter_list] })
+                   else
+                     []
+                   end
+
+          Expressir::Model::Statements::ProcedureCall.new(
+            procedure: proc_ref,
+            parameters: Builder.ensure_array(params),
+          )
+        end
+
+        def build_type_label(ast_data)
+          if ast_data[:type_label_id]
+            Builder.build({ type_label_id: ast_data[:type_label_id] })
+          elsif ast_data[:type_label_ref]
+            Builder.build({ type_label_ref: ast_data[:type_label_ref] })
+          end
+        end
+
+        def build_type_label_ref(ast_data)
+          id = extract_text(ast_data[:str] || ast_data[:type_label_id]&.dig(:str))
+          Expressir::Model::References::SimpleReference.new(id: id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds subtype constraint and supertype expression nodes.
+      class SubtypeConstraintBuilder
+        def build_subtype_constraint_decl(ast_data)
+          head = ast_data[:subtype_constraint_head]
+          body = ast_data[:subtype_constraint_body]
+
+          id = Builder.build_optional(head[:subtype_constraint_id]) if head
+          applies_to = if head && head[:entity_ref]
+                         Builder.build({ entity_ref: head[:entity_ref] })
+                       end
+
+          abstract = false
+          total_over = []
+          supertype_expression = nil
+
+          if body.is_a?(Hash)
+            abstract = !body[:abstract_supertype].nil?
+            if body[:total_over].is_a?(Hash)
+              refs = body[:total_over][:list_of_entity_ref] ||
+                body[:total_over][:entity_ref]
+              total_over = Builder.build_children(Builder.ensure_array(refs))
+            end
+            # Wrap supertype_expression in its node type so Builder.build dispatches correctly
+            supertype_expression = if body[:supertype_expression]
+                                     Builder.build({ supertype_expression: body[:supertype_expression] })
+                                   end
+          end
+
+          Expressir::Model::Declarations::SubtypeConstraint.new(
+            id: id,
+            applies_to: applies_to,
+            abstract: abstract,
+            total_over: total_over,
+            supertype_expression: supertype_expression,
+          )
+        end
+
+        def build_total_over(ast_data)
+          Builder.build_children(ast_data[:entity_ref])
+        end
+
+        def build_supertype_expression(ast_data)
+          return nil unless ast_data
+
+          base_factor = ast_data[:supertype_factor]
+          return nil unless base_factor
+
+          # Handle both formats:
+          # - With item wrapper: {item: {operator: {...}, supertype_factor: {...}}}
+          # - Without item wrapper: {operator: {...}, supertype_factor: {...}}
+          factors = [base_factor] + Builder.ensure_array(ast_data[:rhs]).filter_map do |r|
+            r[:item]&.dig(:supertype_factor) || r[:supertype_factor]
+          end
+          operators = Builder.ensure_array(ast_data[:rhs]).map do |r|
+            (r[:item]&.dig(:operator) || r[:operator])&.values&.first
+          end
+
+          if factors.length == 1
+            Builder.build({ supertype_factor: factors.first })
+          elsif factors.length >= 2
+            operands = factors.map do |f|
+              Builder.build({ supertype_factor: f })
+            end
+            build_binary_supertype_expression(operands, operators.map do
+              :ANDOR
+            end)
+          end
+        end
+
+        def build_supertype_factor(ast_data)
+          return nil unless ast_data
+
+          base_term = ast_data[:supertype_term]
+          return nil unless base_term
+
+          # Handle both formats:
+          # - With item wrapper: {item: {operator: {...}, supertype_term: {...}}}
+          # - Without item wrapper: {operator: {...}, supertype_term: {...}}
+          terms = [base_term] + Builder.ensure_array(ast_data[:rhs]).filter_map do |r|
+            r[:item]&.dig(:supertype_term) || r[:supertype_term]
+          end
+          operators = Builder.ensure_array(ast_data[:rhs]).map do |r|
+            (r[:item]&.dig(:operator) || r[:operator])&.values&.first
+          end
+
+          if terms.length == 1
+            Builder.build({ supertype_term: terms.first })
+          elsif terms.length >= 2
+            operands = terms.map { |t| Builder.build({ supertype_term: t }) }
+            build_binary_supertype_expression(operands, operators.map { :AND })
+          end
+        end
+
+        def build_binary_supertype_expression(operands, operators)
+          result = Expressir::Model::SupertypeExpressions::BinarySupertypeExpression.new(
+            operator: operators.first,
+            operand1: operands.first,
+            operand2: operands[1],
+          )
+          (2...operands.length).each do |i|
+            result = Expressir::Model::SupertypeExpressions::BinarySupertypeExpression.new(
+              operator: operators[i - 1],
+              operand1: result,
+              operand2: operands[i],
+            )
+          end
+          result
+        end
+
+        def build_supertype_term(ast_data)
+          return nil unless ast_data.is_a?(Hash)
+
+          if ast_data[:entity_ref]
+            Builder.build({ entity_ref: ast_data[:entity_ref] })
+          elsif ast_data[:one_of]
+            Builder.build({ one_of: ast_data[:one_of] })
+          elsif ast_data[:supertype_expression]
+            Builder.build({ supertype_expression: ast_data[:supertype_expression] })
+          end
+        end
+
+        def build_one_of(ast_data)
+          list_data = ast_data[:list_of_supertype_expression]
+          operands = if list_data.is_a?(Array)
+                       list_data.filter_map do |item|
+                         next unless item.is_a?(Hash)
+
+                         expr_data = item[:supertype_expression]
+                         Builder.build({ supertype_expression: expr_data }) if expr_data
+                       end
+                     elsif list_data.is_a?(Hash)
+                       expr_data = list_data[:supertype_expression]
+                       [Builder.build({ supertype_expression: expr_data })] if expr_data
+                     else
+                       []
+                     end
+          Expressir::Model::SupertypeExpressions::OneofSupertypeExpression.new(operands: operands.compact)
+        end
+
+        def build_supertype_rule(ast_data)
+          subtype_constraint = ast_data[:subtype_constraint]
+          if subtype_constraint.is_a?(Hash)
+            Builder.build({ subtype_constraint: subtype_constraint })
+          end
+        end
+
+        def build_subtype_constraint(ast_data)
+          expr_data = ast_data[:supertype_expression]
+          if expr_data.is_a?(Hash)
+            Builder.build({ supertype_expression: expr_data })
+          end
+        end
+
+        def build_subtype_declaration(ast_data)
+          refs = ast_data[:entity_ref] || ast_data[:list_of_entity_ref]&.dig(:entity_ref)
+          Builder.build_children(Builder.ensure_array(refs))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds syntax (top-level) nodes into ExpFile objects.
+      # Each parsed EXPRESS file is represented as an ExpFile containing schemas.
+      class SyntaxBuilder
+        # Build ExpFile from AST data
+        # @param ast_data [Hash] The parsed AST with syntax node
+        # @return [Model::ExpFile] ExpFile containing the parsed schemas
+        def call(ast_data)
+          schema_decl_data = extract_schema_decls(ast_data)
+
+          schemas = Builder.build_children(schema_decl_data)
+          Expressir::Model::ExpFile.new(schemas: schemas.compact)
+        end
+
+        private
+
+        # Extract schema declarations from AST data.
+        def extract_schema_decls(ast_data)
+          if ast_data.is_a?(Hash)
+            ast_data[:schema_decl]
+          end
+        end
+      end
+    end
+  end
+end