expressir 2.4.29-aarch64-mingw-ucrt

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Shared helper methods for all builders.
+      # Included as a module to avoid duplication.
+      module Helpers
+        # Extract text from Parsanol::Slice or return as-is
+        def extract_text(val)
+          return nil unless val
+          return val.to_s if val.is_a?(String)
+          return val.to_s if val.is_a?(Symbol)
+          return val.to_s if val.is_a?(Parsanol::Slice)
+
+          if val.is_a?(Hash)
+            str = val[:str]
+            return str.to_s if str
+          end
+          val
+        end
+
+        # Get first value from a hash (for union types)
+        def first_value(hash)
+          return nil unless hash.is_a?(Hash)
+
+          hash.values.first
+        end
+
+        # Recursively extract text from nested structures
+        def extract_nested_text(data)
+          return nil unless data
+          return data.to_s if data.is_a?(String)
+          return data.to_s if data.is_a?(Symbol)
+          return data.to_s if data.is_a?(Parsanol::Slice)
+
+          if data.is_a?(Hash)
+            str = data[:str]
+            return str.to_s if str
+
+            data.each_value do |value|
+              result = extract_nested_text(value)
+              return result if result
+            end
+          elsif data.is_a?(Array)
+            data.each do |item|
+              result = extract_nested_text(item)
+              return result if result
+            end
+          end
+          nil
+        end
+
+        # Extract ID from reference types like functionId, constantId, etc.
+        def extract_id_ref(data)
+          id_data = data[:function_id] || data[:constant_id] || data[:parameter_id] ||
+            data[:variable_id] || data[:attribute_id] || data[:entity_id] ||
+            data[:type_id] || data[:procedure_id] || data[:schema_id] ||
+            data[:type_label_id] || data[:enumeration_id] || data[:rename_id] ||
+            data[:simple_id]
+
+          extract_nested_text(id_data || first_value(data))
+        end
+
+        # Extract interval operator
+        def extract_interval_op(data)
+          return nil unless data
+
+          if data.is_a?(Array)
+            data.each do |item|
+              next unless item.is_a?(Hash)
+              return "LESS_THAN" if item[:op_less_than]
+              return "LESS_THAN_OR_EQUAL" if item[:op_less_equal]
+            end
+            nil
+          elsif data.is_a?(Hash)
+            return "LESS_THAN" if data[:op_less_than]
+            return "LESS_THAN_OR_EQUAL" if data[:op_less_equal]
+
+            nil
+          end
+        end
+
+        # Extract binary operator
+        def extract_operator(data)
+          return nil unless data
+          return :ADDITION if data[:op_plus]
+          return :SUBTRACTION if data[:op_minus]
+          return :OR if data[:t_or]
+          return :XOR if data[:t_xor]
+          return :MULTIPLICATION if data[:op_asterisk]
+          return :REAL_DIVISION if data[:op_slash]
+          return :INTEGER_DIVISION if data[:t_div]
+          return :MODULO if data[:t_mod]
+          return :AND if data[:t_and]
+          return :COMBINE if data[:op_double_pipe]
+
+          extract_text(first_value(data))&.upcase&.to_sym
+        end
+
+        # Extract unary operator
+        def extract_unary_op(data)
+          return nil unless data
+          return :PLUS if data[:op_plus]
+          return :MINUS if data[:op_minus]
+          return :NOT if data[:t_not]
+
+          extract_text(first_value(data))&.upcase&.to_sym
+        end
+
+        # Extract relational operator
+        def extract_rel_op(data)
+          return nil unless data
+          return :EQUAL if data[:t_equal] || data[:op_equals]
+          return :NOT_EQUAL if data[:t_not_equal] || data[:op_less_greater]
+          return :LESS_THAN if data[:t_less_than] || data[:op_less_than]
+          return :GREATER_THAN if data[:t_greater_than] || data[:op_greater_than]
+          return :LESS_THAN_OR_EQUAL if data[:t_less_than_or_equal] || data[:op_less_equal]
+          return :GREATER_THAN_OR_EQUAL if data[:t_greater_than_or_equal] || data[:op_greater_equal]
+          return :INSTANCE_EQUAL if data[:t_instance_equal] || data[:op_colon_equals_colon]
+          return :INSTANCE_NOT_EQUAL if data[:t_instance_not_equal] || data[:op_colon_less_greater_colon]
+
+          extract_text(first_value(data))&.upcase&.to_sym
+        end
+
+        # Apply qualifier to reference
+        def apply_qualifier(ref, qualifier)
+          case qualifier
+          when Expressir::Model::References::AttributeReference
+            Expressir::Model::References::AttributeReference.new(ref: ref,
+                                                                 attribute: qualifier.attribute)
+          when Expressir::Model::References::GroupReference
+            Expressir::Model::References::GroupReference.new(ref: ref,
+                                                             entity: qualifier.entity)
+          when Expressir::Model::References::IndexReference
+            Expressir::Model::References::IndexReference.new(ref: ref,
+                                                             index1: qualifier.index1, index2: qualifier.index2)
+          when Expressir::Model::References::SimpleReference
+            Expressir::Model::References::AttributeReference.new(ref: ref,
+                                                                 attribute: qualifier)
+          else
+            ref
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds interface specification nodes (use/reference clauses).
+      class InterfaceBuilder
+        def build_interface_specification(ast_data)
+          ast_data = ast_data[:interface_specification] if ast_data[:interface_specification]
+          if ast_data[:reference_clause]
+            Builder.build({ reference_clause: ast_data[:reference_clause] })
+          elsif ast_data[:use_clause]
+            Builder.build({ use_clause: ast_data[:use_clause] })
+          end
+        end
+
+        def build_use_clause(ast_data)
+          schema_ref_data = ast_data[:schema_ref]
+          schema = if schema_ref_data
+                     Builder.build({ schema_ref: schema_ref_data })
+                   end
+
+          list_data = ast_data[:list_of_named_type_or_rename]
+          items = build_items(list_data, :named_type_or_rename)
+
+          Expressir::Model::Declarations::Interface.new(
+            kind: Expressir::Model::Declarations::Interface::USE,
+            schema: schema,
+            items: items.compact,
+          )
+        end
+
+        def build_reference_clause(ast_data)
+          schema_ref_data = ast_data[:schema_ref]
+          schema = if schema_ref_data
+                     Builder.build({ schema_ref: schema_ref_data })
+                   end
+
+          list_data = ast_data[:list_of_resource_or_rename]
+          items = build_items(list_data, :resource_or_rename)
+
+          Expressir::Model::Declarations::Interface.new(
+            kind: Expressir::Model::Declarations::Interface::REFERENCE,
+            schema: schema,
+            items: items.compact,
+          )
+        end
+
+        def build_named_type_or_rename(ast_data)
+          named_types_data = ast_data[:named_types]
+          ref = if named_types_data.is_a?(Hash)
+                  if named_types_data[:entity_ref]
+                    Builder.build({ entity_ref: named_types_data[:entity_ref] })
+                  elsif named_types_data[:type_ref]
+                    Builder.build({ type_ref: named_types_data[:type_ref] })
+                  end
+                end
+
+          id = nil
+          if ast_data[:entity_id].is_a?(Hash)
+            id = Builder.build({ entity_id: ast_data[:entity_id] })
+          elsif ast_data[:type_id].is_a?(Hash)
+            id = Builder.build({ type_id: ast_data[:type_id] })
+          end
+
+          Expressir::Model::Declarations::InterfaceItem.new(ref: ref, id: id)
+        end
+
+        def build_resource_or_rename(ast_data)
+          ref_data = ast_data[:resource_ref]
+          ref = if ref_data.is_a?(Hash)
+                  if ref_data[:constant_ref]
+                    Builder.build({ constant_ref: ref_data[:constant_ref] })
+                  elsif ref_data[:entity_ref]
+                    Builder.build({ entity_ref: ref_data[:entity_ref] })
+                  elsif ref_data[:function_ref]
+                    Builder.build({ function_ref: ref_data[:function_ref] })
+                  elsif ref_data[:procedure_ref]
+                    Builder.build({ procedure_ref: ref_data[:procedure_ref] })
+                  elsif ref_data[:type_ref]
+                    Builder.build({ type_ref: ref_data[:type_ref] })
+                  end
+                end
+
+          id_data = ast_data[:rename_id]
+          id = if id_data.is_a?(Hash)
+                 if id_data[:constant_id]
+                   Builder.build({ constant_id: id_data[:constant_id] })
+                 elsif id_data[:entity_id]
+                   Builder.build({ entity_id: id_data[:entity_id] })
+                 elsif id_data[:function_id]
+                   Builder.build({ function_id: id_data[:function_id] })
+                 elsif id_data[:procedure_id]
+                   Builder.build({ procedure_id: id_data[:procedure_id] })
+                 elsif id_data[:type_id]
+                   Builder.build({ type_id: id_data[:type_id] })
+                 end
+               end
+
+          Expressir::Model::Declarations::InterfaceItem.new(ref: ref, id: id)
+        end
+
+        def build_resource_ref(ast_data)
+          if ast_data[:constant_ref]
+            Builder.build({ constant_ref: ast_data[:constant_ref] })
+          elsif ast_data[:entity_ref]
+            Builder.build({ entity_ref: ast_data[:entity_ref] })
+          elsif ast_data[:function_ref]
+            Builder.build({ function_ref: ast_data[:function_ref] })
+          elsif ast_data[:procedure_ref]
+            Builder.build({ procedure_ref: ast_data[:procedure_ref] })
+          elsif ast_data[:type_ref]
+            Builder.build({ type_ref: ast_data[:type_ref] })
+          end
+        end
+
+        def build_rename_id(ast_data)
+          if ast_data[:constant_id]
+            Builder.build({ constant_id: ast_data[:constant_id] })
+          elsif ast_data[:entity_id]
+            Builder.build({ entity_id: ast_data[:entity_id] })
+          elsif ast_data[:function_id]
+            Builder.build({ function_id: ast_data[:function_id] })
+          elsif ast_data[:procedure_id]
+            Builder.build({ procedure_id: ast_data[:procedure_id] })
+          elsif ast_data[:type_id]
+            Builder.build({ type_id: ast_data[:type_id] })
+          end
+        end
+
+        private
+
+        def build_items(list_data, item_key)
+          if list_data.is_a?(Hash)
+            items_data = list_data[item_key]
+            items_data ? [Builder.build({ item_key => items_data })] : []
+          elsif list_data.is_a?(Array)
+            list_data.filter_map do |item|
+              next unless item.is_a?(Hash)
+
+              items_data = item[item_key]
+              Builder.build({ item_key => items_data }) if items_data
+            end
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds inverse_attr nodes.
+      class InverseAttrBuilder
+        def call(ast_data)
+          attr_decl_data = ast_data[:attribute_decl]
+          attr = if attr_decl_data.is_a?(Hash)
+                   Builder.build({ attribute_decl: attr_decl_data })
+                 end
+
+          type_data = ast_data[:inverse_attr_type]
+          type = if type_data.is_a?(Hash)
+                   Builder.build({ inverse_attr_type: type_data })
+                 end
+
+          expression = if ast_data[:entity_ref]
+                         ref = Builder.build({ entity_ref: ast_data[:entity_ref] })
+                         attr_ref = if ast_data[:attribute_ref]
+                                      Builder.build({ attribute_ref: ast_data[:attribute_ref] })
+                                    end
+                         Expressir::Model::References::AttributeReference.new(ref: ref,
+                                                                              attribute: attr_ref)
+                       else
+                         attr_ref_data = ast_data[:attribute_ref]
+                         if attr_ref_data
+                           Builder.build({ attribute_ref: attr_ref_data })
+                         end
+                       end
+
+          Expressir::Model::Declarations::InverseAttribute.new(
+            id: attr&.id,
+            supertype_attribute: attr&.supertype_attribute,
+            type: type,
+            expression: expression,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds inverse_attr_type nodes.
+      class InverseAttrTypeBuilder
+        def call(ast_data)
+          bound_spec = ast_data[:bound_spec] || {}
+          bound1 = Builder.build_optional(bound_spec[:bound1])
+          bound2 = Builder.build_optional(bound_spec[:bound2])
+          base_type_data = ast_data[:entity_ref]
+          base_type = if base_type_data.is_a?(Hash)
+                        Builder.build({ entity_ref: base_type_data })
+                      end
+
+          if ast_data[:t_set]
+            Expressir::Model::DataTypes::Set.new(bound1: bound1,
+                                                 bound2: bound2, base_type: base_type)
+          elsif ast_data[:t_bag]
+            Expressir::Model::DataTypes::Bag.new(bound1: bound1,
+                                                 bound2: bound2, base_type: base_type)
+          else
+            base_type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds inverse_clause nodes.
+      class InverseClauseBuilder
+        def call(ast_data)
+          Builder.build_children(ast_data[:inverse_attr])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds literal nodes (integer, real, binary, logical, string).
+      class LiteralBuilder
+        include ::Expressir::Express::Builders::Helpers
+
+        # Integer literal
+        def build_integer(ast_data)
+          val = extract_text(ast_data[:integer] || ast_data[:str])
+          Expressir::Model::Literals::Integer.new(value: val)
+        end
+
+        # Real literal
+        def build_real(ast_data)
+          val = extract_text(ast_data[:real] || ast_data[:str])
+          Expressir::Model::Literals::Real.new(value: val)
+        end
+
+        # Binary literal
+        def build_binary(ast_data)
+          val = extract_text(ast_data[:binary] || ast_data[:str])
+          Expressir::Model::Literals::Binary.new(value: val)
+        end
+
+        # Logical literal
+        def build_logical(ast_data)
+          value = if ast_data[:t_true]
+                    Expressir::Model::Literals::Logical::TRUE
+                  elsif ast_data[:t_false]
+                    Expressir::Model::Literals::Logical::FALSE
+                  elsif ast_data[:t_unknown]
+                    Expressir::Model::Literals::Logical::UNKNOWN
+                  else
+                    val = extract_text(ast_data[:logical] || ast_data[:str]).to_s.strip.upcase
+                    case val
+                    when "TRUE" then Expressir::Model::Literals::Logical::TRUE
+                    when "FALSE" then Expressir::Model::Literals::Logical::FALSE
+                    else Expressir::Model::Literals::Logical::UNKNOWN
+                    end
+                  end
+          Expressir::Model::Literals::Logical.new(value: value)
+        end
+
+        # String literal
+        def build_string(ast_data)
+          if ast_data[:string_literal] && ast_data.keys.length == 1
+            ast_data = ast_data[:string_literal]
+          end
+
+          if ast_data[:simple_string_literal].is_a?(Hash)
+            build_simple_string(ast_data[:simple_string_literal])
+          elsif ast_data[:encoded_string_literal].is_a?(Hash)
+            build_encoded_string(ast_data[:encoded_string_literal])
+          else
+            val = extract_text(ast_data[:str])
+            val = val[1..-2] if val && val.length >= 2
+            Expressir::Model::Literals::String.new(value: val)
+          end
+        end
+
+        def build_simple_string(ast_data)
+          val = extract_text(ast_data[:str])
+          val = val[1..-2] if val && val.length >= 2
+          Expressir::Model::Literals::String.new(value: val)
+        end
+
+        def build_encoded_string(ast_data)
+          val = extract_text(ast_data[:str])
+          val = val[1..-2] if val && val.length >= 2
+          Expressir::Model::Literals::String.new(value: val, encoded: true)
+        end
+
+        # Generic literal dispatcher
+        def call(ast_data)
+          if ast_data[:binary_literal]
+            Builder.build({ binary_literal: ast_data[:binary_literal] })
+          elsif ast_data[:integer_literal]
+            Builder.build({ integer_literal: ast_data[:integer_literal] })
+          elsif ast_data[:logical_literal]
+            Builder.build({ logical_literal: ast_data[:logical_literal] })
+          elsif ast_data[:real_literal]
+            Builder.build({ real_literal: ast_data[:real_literal] })
+          elsif ast_data[:string_literal]
+            Builder.build({ string_literal: ast_data[:string_literal] })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds procedure declaration nodes.
+      class ProcedureDeclBuilder
+        def call(ast_data)
+          head = ast_data[:procedure_head]
+          algorithm_head = ast_data[:algorithm_head]
+          stmts = ast_data[:stmt]
+
+          id = Builder.build_optional(head[:procedure_id]) if head
+          parameters = build_parameters(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)
+
+          Expressir::Model::Declarations::Procedure.new(
+            id: id,
+            parameters: parameters,
+            types: types,
+            entities: entities,
+            subtype_constraints: subtype_constraints,
+            functions: functions,
+            procedures: procedures,
+            constants: constants,
+            variables: variables,
+            statements: statements.compact,
+          )
+        end
+
+        private
+
+        def build_parameters(head)
+          return [] unless head && head[:list_of_procedure_head_parameter]
+
+          params_data = head[:list_of_procedure_head_parameter]
+          if params_data.is_a?(Hash)
+            param_values = params_data[:procedure_head_parameter]
+            params_data = param_values.is_a?(Array) ? param_values : [param_values]
+          end
+
+          parameters = []
+          Builder.ensure_array(params_data).each do |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
+        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/qualifier_builder.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds qualifier nodes (attribute, group, index qualifiers).
+      class QualifierBuilder
+        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])
+          Expressir::Model::References::IndexReference.new(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

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds reference nodes (attribute_ref, entity_ref, etc.).
+      # Returns SimpleReference for all reference types.
+      class ReferenceBuilder
+        include ::Expressir::Express::Builders::Helpers
+
+        def call(ast_data)
+          id = extract_id_ref(ast_data)
+          Expressir::Model::References::SimpleReference.new(id: id)
+        end
+      end
+    end
+  end
+end