expressir 2.1.31 → 2.2.1

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "helpers"
+
+module Expressir
+  module Express
+    module Builders
+      # Builds qualifier nodes (attribute, group, index qualifiers).
+      class QualifierBuilder
+        include Helpers
+
+        def build_redeclared_attribute(ast_data)
+          qualified_attr = ast_data[:qualified_attribute]
+          if qualified_attr.is_a?(Hash)
+            Builder.build({ qualified_attribute: qualified_attr })
+          end
+        end
+
+        def build_referenced_attribute(ast_data)
+          if ast_data[:attribute_ref]
+            Builder.build({ attribute_ref: ast_data[:attribute_ref] })
+          elsif ast_data[:qualified_attribute]
+            Builder.build({ qualified_attribute: ast_data[:qualified_attribute] })
+          end
+        end
+
+        def build_qualified_attribute(ast_data)
+          # t_self is part of qualified_attribute grammar
+          self_ref = if ast_data[:t_self]
+                       Expressir::Model::References::SimpleReference.new(id: "SELF")
+                     end
+
+          # group_qualifier contains the entity reference
+          entity_ref = if ast_data[:group_qualifier]
+                         Builder.build({ entity_ref: ast_data[:group_qualifier][:entity_ref] })
+                       end
+
+          # Create GroupReference with ref (SELF) and entity
+          group_qual = if self_ref || entity_ref
+                         Expressir::Model::References::GroupReference.new(
+                           ref: self_ref, entity: entity_ref,
+                         )
+                       end
+
+          attr_qual = if ast_data[:attribute_qualifier]
+                        Builder.build({ attribute_qualifier: ast_data[:attribute_qualifier] })
+                      end
+
+          if group_qual && attr_qual
+            Expressir::Model::References::AttributeReference.new(
+              ref: group_qual, attribute: attr_qual,
+            )
+          else
+            attr_qual || group_qual
+          end
+        end
+
+        def build_group_qualifier(ast_data)
+          entity = if ast_data[:entity_ref]
+                     Builder.build({ entity_ref: ast_data[:entity_ref] })
+                   end
+          Expressir::Model::References::GroupReference.new(entity: entity)
+        end
+
+        def build_attribute_qualifier(ast_data)
+          Builder.build({ attribute_ref: ast_data[:attribute_ref] })
+        end
+
+        def build_index_qualifier(ast_data)
+          index1 = Builder.build_optional(ast_data[:index1])
+          index2 = Builder.build_optional(ast_data[:index2])
+          { index1: index1, index2: index2 }
+        end
+
+        def build_index1(ast_data)
+          Builder.build_optional(ast_data[:numeric_expression])
+        end
+
+        def build_index2(ast_data)
+          Builder.build_optional(ast_data[:numeric_expression])
+        end
+
+        def build_index(ast_data)
+          Builder.build_optional(ast_data[:numeric_expression])
+        end
+
+        def build_enumeration_reference(ast_data)
+          type_ref = Builder.build_optional(ast_data[:type_ref])
+          enum_ref = if ast_data[:enumeration_ref]
+                       Builder.build({ enumeration_ref: ast_data[:enumeration_ref] })
+                     end
+
+          if type_ref && enum_ref
+            Expressir::Model::References::AttributeReference.new(
+              ref: type_ref,
+              attribute: enum_ref,
+            )
+          elsif enum_ref
+            enum_ref
+          end
+        end
+      end
+    end
+  end
+end
+
+builder = Expressir::Express::Builders::QualifierBuilder.new
+
+Builder.register(:redeclared_attribute) do |d|
+  builder.build_redeclared_attribute(d)
+end
+Builder.register(:referenced_attribute) do |d|
+  builder.build_referenced_attribute(d)
+end
+Builder.register(:qualified_attribute) do |d|
+  builder.build_qualified_attribute(d)
+end
+Builder.register(:group_qualifier) { |d| builder.build_group_qualifier(d) }
+Builder.register(:attribute_qualifier) do |d|
+  builder.build_attribute_qualifier(d)
+end
+Builder.register(:index_qualifier) { |d| builder.build_index_qualifier(d) }
+Builder.register(:index1) { |d| builder.build_index1(d) }
+Builder.register(:index2) { |d| builder.build_index2(d) }
+Builder.register(:index) { |d| builder.build_index(d) }
+Builder.register(:enumeration_reference) do |d|
+  builder.build_enumeration_reference(d)
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "helpers"
+
+module Expressir
+  module Express
+    module Builders
+      # Builds reference nodes (attribute_ref, entity_ref, etc.).
+      # Returns SimpleReference for all reference types.
+      class ReferenceBuilder
+        include Helpers
+
+        def call(ast_data)
+          id = extract_id_ref(ast_data)
+          Expressir::Model::References::SimpleReference.new(id: id)
+        end
+      end
+    end
+  end
+end
+
+# Register for all reference types
+%i[attribute_ref constant_ref entity_ref enumeration_ref function_ref
+   parameter_ref procedure_ref rule_ref rule_label_ref schema_ref
+   subtype_constraint_ref type_label_ref type_ref variable_ref].each do |ref_type|
+  Builder.register(ref_type, Expressir::Express::Builders::ReferenceBuilder.new)
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "helpers"
+
+module Expressir
+  module Express
+    module Builders
+      # Builds rule declaration nodes.
+      class RuleDeclBuilder
+        include Helpers
+
+        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.select { |x| x.is_a?(Expressir::Model::Declarations::Type) }
+          entities = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Entity) }
+          subtype_constraints = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::SubtypeConstraint) }
+          functions = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Function) }
+          procedures = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Procedure) }
+          constants = build_constant_decl(algorithm_head[:constant_decl]) if algorithm_head.is_a?(Hash) && algorithm_head[:constant_decl]
+          variables = build_local_decl(algorithm_head[:local_decl]) if algorithm_head.is_a?(Hash) && algorithm_head[:local_decl]
+          statements = Builder.build_children(stmts)
+          where_rules = where_clause ? Builder.build({ where_clause: where_clause }) : []
+
+          Expressir::Model::Declarations::Rule.new(
+            id: id,
+            applies_to: [applies_to].flatten.compact,
+            types: types,
+            entities: entities,
+            subtype_constraints: subtype_constraints,
+            functions: functions,
+            procedures: procedures,
+            constants: [constants].flatten.compact,
+            variables: [variables].flatten.compact,
+            statements: statements.compact,
+            where_rules: [where_rules].flatten.compact,
+          )
+        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]
+              [entity_refs[:item]].flatten.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]).flatten.compact
+        end
+      end
+    end
+  end
+end
+
+Builder.register(:rule_decl, Expressir::Express::Builders::RuleDeclBuilder.new)

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "helpers"
+
+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
+
+Builder.register(:schema_body_declaration, Expressir::Express::Builders::SchemaBodyDeclBuilder.new)

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "helpers"
+
+module Expressir
+  module Express
+    module Builders
+      # Builds schema_decl nodes into Schema objects.
+      class SchemaDeclBuilder
+        include Helpers
+
+        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.select { |x| x.is_a?(Expressir::Model::Declarations::Type) }
+          entities = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Entity) }
+          subtype_constraints = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::SubtypeConstraint) }
+          functions = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Function) }
+          rules = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Rule) }
+          procedures = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Procedure) }
+
+          Expressir::Model::Declarations::Schema.new(
+            id: id,
+            version: version,
+            interfaces: interfaces.compact,
+            constants: [constants].flatten.compact,
+            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
+
+Builder.register(:schema_decl, Expressir::Express::Builders::SchemaDeclBuilder.new)

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "helpers"
+
+module Expressir
+  module Express
+    module Builders
+      # Builds schema_version_id nodes into SchemaVersion objects.
+      class SchemaVersionBuilder
+        include Helpers
+
+        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
+
+Builder.register(:schema_version_id, Expressir::Express::Builders::SchemaVersionBuilder.new)

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "helpers"
+
+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 Helpers
+
+        def call(ast_data)
+          extract_text(ast_data[:str]) || extract_text(ast_data[:simple_id]&.dig(:str))
+        end
+      end
+    end
+  end
+end
+
+# Register for all ID types
+%i[simple_id schema_id entity_id type_id function_id procedure_id
+   rule_id rule_label_id constant_id parameter_id variable_id
+   enumeration_id subtype_constraint_id type_label_id attribute_id].each do |id_type|
+  Builder.register(id_type, Expressir::Express::Builders::SimpleIdBuilder.new)
+end

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

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require_relative "helpers"
+
+module Expressir
+  module Express
+    module Builders
+      # Builds statement nodes (assignment, if, case, repeat, etc.).
+      class StatementBuilder
+        include 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 = Builder.build_optional(ast_data[:expression])
+
+          if ast_data[:qualifier]
+            [ast_data[:qualifier]].flatten.compact.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
+            [ast_data[:qualifier]].flatten.compact.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 = Builder.build_children(ast_data[:otherwise]&.dig(:stmt))
+
+          Expressir::Model::Statements::Case.new(
+            expression: selector,
+            actions: actions.compact,
+            otherwise: otherwise.compact,
+          )
+        end
+
+        def build_selector(ast_data)
+          Builder.build_optional(ast_data[:expression])
+        end
+
+        def build_case_action(ast_data)
+          labels = Builder.build_children(ast_data[:case_label])
+          statements = Builder.build_children(ast_data[:stmt])
+
+          Expressir::Model::Statements::CaseAction.new(
+            labels: labels.compact,
+            statements: statements.compact,
+          )
+        end
+
+        def build_case_label(ast_data)
+          Builder.build_optional(ast_data[:expression])
+        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 = Builder.build_optional(ast_data[:expression])
+          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: [params].flatten.compact,
+          )
+        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
+
+builder = Expressir::Express::Builders::StatementBuilder.new
+
+Builder.register(:stmt) { |d| builder.build_stmt(d) }
+Builder.register(:assignment_stmt) { |d| builder.build_assignment_stmt(d) }
+Builder.register(:alias_stmt) { |d| builder.build_alias_stmt(d) }
+Builder.register(:if_stmt) { |d| builder.build_if_stmt(d) }
+Builder.register(:case_stmt) { |d| builder.build_case_stmt(d) }
+Builder.register(:selector) { |d| builder.build_selector(d) }
+Builder.register(:case_action) { |d| builder.build_case_action(d) }
+Builder.register(:case_label) { |d| builder.build_case_label(d) }
+Builder.register(:compound_stmt) { |d| builder.build_compound_stmt(d) }
+Builder.register(:repeat_stmt) { |d| builder.build_repeat_stmt(d) }
+Builder.register(:increment_control) { |d| builder.build_increment_control(d) }
+Builder.register(:increment) { |d| builder.build_increment(d) }
+Builder.register(:while_control) { |d| builder.build_while_control(d) }
+Builder.register(:until_control) { |d| builder.build_until_control(d) }
+Builder.register(:return_stmt) { |d| builder.build_return_stmt(d) }
+Builder.register(:escape_stmt) { |d| builder.build_escape_stmt(d) }
+Builder.register(:skip_stmt) { |d| builder.build_skip_stmt(d) }
+Builder.register(:null_stmt) { |d| builder.build_null_stmt(d) }
+Builder.register(:procedure_call_stmt) do |d|
+  builder.build_procedure_call_stmt(d)
+end
+Builder.register(:type_label) { |d| builder.build_type_label(d) }
+Builder.register(:type_label_ref) { |d| builder.build_type_label_ref(d) }