expressir 1.2.11-aarch64-linux → 2.4.29-aarch64-linux

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

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds data type nodes (enumeration, select, array, bag, list, set, etc.).
+      class TypeBuilder
+        include ::Expressir::Express::Builders::Helpers
+
+        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
+        def build_string_type(ast_data)
+          width = Builder.build_optional(ast_data[:width_spec]&.dig(:width))
+          fixed = !ast_data[:width_spec]&.dig(:t_fixed).nil?
+          kwargs = { width: width }
+          kwargs[:fixed] = fixed if fixed
+          Expressir::Model::DataTypes::String.new(**kwargs)
+        end
+
+        # Binary type
+        def build_binary_type(ast_data)
+          width = Builder.build_optional(ast_data[:width_spec]&.dig(:width))
+          fixed = !ast_data[:width_spec]&.dig(:t_fixed).nil?
+          kwargs = { width: width }
+          kwargs[:fixed] = fixed if fixed
+          Expressir::Model::DataTypes::Binary.new(**kwargs)
+        end
+
+        # Real type
+        def build_real_type(ast_data)
+          precision = Builder.build_optional(ast_data[:precision_spec])
+          if precision
+            Expressir::Model::DataTypes::Real.new(precision: precision)
+          else
+            Expressir::Model::DataTypes::Real.new
+          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)
+        end
+
+        def build_bag_type(ast_data)
+          build_aggregation_type(ast_data, Expressir::Model::DataTypes::Bag)
+        end
+
+        def build_list_type(ast_data)
+          build_aggregation_type(ast_data, Expressir::Model::DataTypes::List)
+        end
+
+        def build_set_type(ast_data)
+          build_aggregation_type(ast_data, Expressir::Model::DataTypes::Set)
+        end
+
+        def build_general_set_type(ast_data)
+          build_general_aggregation_type(ast_data, Expressir::Model::DataTypes::Set)
+        end
+
+        def build_general_list_type(ast_data)
+          build_general_aggregation_type(ast_data, Expressir::Model::DataTypes::List)
+        end
+
+        def build_general_bag_type(ast_data)
+          build_general_aggregation_type(ast_data, Expressir::Model::DataTypes::Bag)
+        end
+
+        def build_general_array_type(ast_data)
+          build_general_aggregation_type(ast_data, Expressir::Model::DataTypes::Array)
+        end
+
+        def build_aggregation_type(ast_data, type_class)
+          bound_spec = ast_data[:bound_spec] || {}
+          bound1 = Builder.build_optional(bound_spec[:bound1])
+          bound2 = Builder.build_optional(bound_spec[:bound2])
+          optional = !ast_data[:t_optional].nil?
+          unique = !ast_data[:t_unique].nil?
+          base_type = Builder.build_optional(ast_data[:instantiable_type])
+
+          type_class.new(
+            bound1: bound1,
+            bound2: bound2,
+            optional: optional,
+            unique: unique,
+            base_type: base_type,
+          )
+        end
+
+        # General aggregation types (used in parameter types)
+        # These use parameter_type instead of instantiable_type
+        def build_general_aggregation_type(ast_data, type_class)
+          bound_spec = ast_data[:bound_spec] || {}
+          bound1 = Builder.build_optional(bound_spec[:bound1])
+          bound2 = Builder.build_optional(bound_spec[:bound2])
+          base_type = Builder.build_optional(ast_data[:parameter_type])
+          # Element modifiers are legal on general aggregations too
+          # (attributes and parameters); dropping them silently changed
+          # element constraints (GH-338). ARRAY carries both flags,
+          # LIST only UNIQUE, per the model.
+          optional = !ast_data[:t_optional].nil? if type_class.method_defined?(:optional)
+          unique = !ast_data[:t_unique].nil? if type_class.method_defined?(:unique)
+
+          type_class.new(
+            bound1: bound1,
+            bound2: bound2,
+            optional: optional,
+            unique: unique,
+            base_type: base_type,
+          )
+        end
+
+        # Enumeration type
+        def build_enumeration_type(ast_data)
+          extensible = !ast_data[:t_extensible].nil?
+          items = []
+          based_on = nil
+
+          if ast_data[:enumeration_items].is_a?(Hash)
+            items_data = ast_data[:enumeration_items][:list_of_enumeration_item] ||
+              ast_data[:enumeration_items][:enumeration_item]
+            if items_data
+              items_data = items_data[:enumeration_item] if items_data.is_a?(Hash) && items_data[:enumeration_item]
+              items_data = [items_data] unless items_data.is_a?(Array)
+              items = items_data.filter_map do |item|
+                actual_item = item.is_a?(Hash) ? (item[:enumeration_item] || item) : item
+                Builder.build({ enumeration_item: actual_item })
+              end
+            end
+          elsif ast_data[:enumeration_extension].is_a?(Hash)
+            # Wrap type_ref data so the correct handler is called
+            type_ref_data = ast_data[:enumeration_extension][:type_ref]
+            based_on = Builder.build({ type_ref: type_ref_data }) if type_ref_data
+
+            if ast_data[:enumeration_extension][:enumeration_items].is_a?(Hash)
+              items_data = ast_data[:enumeration_extension][:enumeration_items][:list_of_enumeration_item] ||
+                ast_data[:enumeration_extension][:enumeration_items][:enumeration_item]
+              if items_data
+                items_data = items_data[:enumeration_item] if items_data.is_a?(Hash) && items_data[:enumeration_item]
+                items_data = [items_data] unless items_data.is_a?(Array)
+                items = items_data.filter_map do |item|
+                  actual_item = item.is_a?(Hash) ? (item[:enumeration_item] || item) : item
+                  Builder.build({ enumeration_item: actual_item })
+                end
+              end
+            end
+          end
+
+          kwargs = { based_on: based_on, items: items }
+          kwargs[:extensible] = extensible if extensible
+          Expressir::Model::DataTypes::Enumeration.new(**kwargs)
+        end
+
+        # Enumeration item
+        def build_enumeration_item(ast_data)
+          id = nil
+          if ast_data.is_a?(Hash)
+            if ast_data[:enumeration_id]
+              enum_id_data = ast_data[:enumeration_id]
+              id = if enum_id_data.is_a?(Hash)
+                     extract_text(enum_id_data[:str]) || extract_text(enum_id_data[:simple_id]&.dig(:str))
+                   else
+                     enum_id_data.to_s
+                   end
+            elsif ast_data[:simple_id]
+              id = extract_text(ast_data[:simple_id]&.dig(:str)) || extract_text(ast_data[:str])
+            elsif ast_data[:str]
+              id = extract_text(ast_data[:str])
+            end
+          elsif ast_data.is_a?(String)
+            id = ast_data
+          end
+          Expressir::Model::DataTypes::EnumerationItem.new(id: id)
+        end
+
+        # Select type
+        def build_select_type(ast_data)
+          extensible = !ast_data[:t_extensible].nil?
+          generic_entity = !ast_data[:t_generic_entity].nil?
+          items = []
+          based_on = nil
+
+          if ast_data[:select_list].is_a?(Hash)
+            named_types = ast_data[:select_list][:list_of_named_types]
+            items = Builder.build_children(named_types) if named_types
+          elsif ast_data[:select_extension].is_a?(Hash)
+            # Wrap type_ref data so the correct handler is called
+            if ast_data[:select_extension][:type_ref]
+              based_on = Builder.build({ type_ref: ast_data[:select_extension][:type_ref] })
+            end
+            if ast_data[:select_extension][:select_list].is_a?(Hash)
+              named_types = ast_data[:select_extension][:select_list][:list_of_named_types]
+              items = Builder.build_children(named_types) if named_types
+            end
+          end
+
+          kwargs = { based_on: based_on, items: items.compact }
+          kwargs[:extensible] = extensible if extensible
+          kwargs[:generic_entity] = generic_entity if generic_entity
+          Expressir::Model::DataTypes::Select.new(**kwargs)
+        end
+
+        # Type wrappers - choice types that dispatch to inner type
+        def build_type_wrapper(ast_data)
+          return nil unless ast_data.is_a?(Hash)
+
+          ast_data.each do |k, v|
+            next unless v
+
+            result = Builder.build({ k => v })
+            return result if result
+          end
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds type_decl nodes.
+      class TypeDeclBuilder
+        def call(ast_data)
+          id = Builder.build_optional(ast_data[:type_id])
+          underlying_type = Builder.build_optional(ast_data[:underlying_type])
+          where_rules = if ast_data[:where_clause]
+                          Builder.build({ where_clause: ast_data[:where_clause] })
+                        else
+                          []
+                        end
+
+          Expressir::Model::Declarations::Type.new(
+            id: id,
+            underlying_type: underlying_type,
+            where_rules: [where_rules].flatten,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds unique_clause nodes.
+      class UniqueClauseBuilder
+        def call(ast_data)
+          rules_data = ast_data[:list_of_unique_rule] || ast_data[:unique_rule]
+          return [] unless rules_data
+
+          rules_data = [rules_data] if rules_data.is_a?(Hash)
+          Builder.ensure_array(rules_data).filter_map do |rule|
+            Builder.build({ unique_rule: rule })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds unique_rule nodes.
+      class UniqueRuleBuilder
+        def call(ast_data)
+          inner_data = ast_data[:unique_rule] || ast_data
+
+          id = Builder.build_optional(inner_data[:rule_label_id])
+
+          if inner_data[:list_of_referenced_attribute]
+            attrs_data = inner_data[:list_of_referenced_attribute]
+            if attrs_data.is_a?(Hash)
+              ref_attrs = attrs_data[:referenced_attribute]
+              ref_attrs = [ref_attrs] unless ref_attrs.is_a?(Array)
+              attributes = ref_attrs.filter_map do |attr|
+                Builder.build({ referenced_attribute: attr })
+              end
+            else
+              attributes = Builder.build_children(attrs_data)
+            end
+          else
+            attributes = Builder.build_children(inner_data[:referenced_attribute])
+          end
+
+          attributes = attributes.compact
+
+          # The grammar's separator repetition can yield a phantom rule
+          # fragment (no label, no referenced attributes) between real
+          # rules; drop it so clean never emits a bare ";" (GH-340).
+          return nil if id.nil? && attributes.empty?
+
+          Expressir::Model::Declarations::UniqueRule.new(id: id,
+                                                         attributes: attributes)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds where_clause nodes.
+      class WhereClauseBuilder
+        def call(ast_data)
+          rules_data = ast_data[:list_of_domain_rule] || ast_data[:domain_rule]
+          return [] unless rules_data
+
+          rules_data = [rules_data] if rules_data.is_a?(Hash)
+          Builder.ensure_array(rules_data).filter_map do |rule|
+            Builder.build({ domain_rule: rule })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/expressir/express/builders.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# Builder loader - requires all builder classes.
+# This file has NO CODE, only requires.
+# Each builder class registers itself with Builder.register.
+
+# Ensure Expressir module and autoloads are set up first
+module Expressir
+  module Express
+    module Builders
+      autoload :Helpers, "#{__dir__}/builders/helpers"
+
+      autoload :TokenBuilder, "#{__dir__}/builders/token_builder"
+      autoload :SimpleIdBuilder, "#{__dir__}/builders/simple_id_builder"
+      autoload :SyntaxBuilder, "#{__dir__}/builders/syntax_builder"
+      autoload :SchemaVersionBuilder,
+               "#{__dir__}/builders/schema_version_builder"
+      autoload :DeclarationBuilder, "#{__dir__}/builders/declaration_builder"
+      autoload :SchemaBodyDeclBuilder,
+               "#{__dir__}/builders/schema_body_decl_builder"
+      autoload :SchemaDeclBuilder, "#{__dir__}/builders/schema_decl_builder"
+      autoload :EntityDeclBuilder, "#{__dir__}/builders/entity_decl_builder"
+      autoload :ExplicitAttrBuilder, "#{__dir__}/builders/explicit_attr_builder"
+      autoload :AttributeDeclBuilder,
+               "#{__dir__}/builders/attribute_decl_builder"
+      autoload :DeriveClauseBuilder, "#{__dir__}/builders/derive_clause_builder"
+      autoload :DerivedAttrBuilder, "#{__dir__}/builders/derived_attr_builder"
+      autoload :InverseClauseBuilder,
+               "#{__dir__}/builders/inverse_clause_builder"
+      autoload :InverseAttrBuilder, "#{__dir__}/builders/inverse_attr_builder"
+      autoload :InverseAttrTypeBuilder,
+               "#{__dir__}/builders/inverse_attr_type_builder"
+      autoload :UniqueClauseBuilder, "#{__dir__}/builders/unique_clause_builder"
+      autoload :UniqueRuleBuilder, "#{__dir__}/builders/unique_rule_builder"
+      autoload :WhereClauseBuilder, "#{__dir__}/builders/where_clause_builder"
+      autoload :DomainRuleBuilder, "#{__dir__}/builders/domain_rule_builder"
+      autoload :ReferenceBuilder, "#{__dir__}/builders/reference_builder"
+      autoload :LiteralBuilder, "#{__dir__}/builders/literal_builder"
+      autoload :TypeDeclBuilder, "#{__dir__}/builders/type_decl_builder"
+      autoload :TypeBuilder, "#{__dir__}/builders/type_builder"
+      autoload :ExpressionBuilder, "#{__dir__}/builders/expression_builder"
+      autoload :StatementBuilder, "#{__dir__}/builders/statement_builder"
+      autoload :FunctionDeclBuilder, "#{__dir__}/builders/function_decl_builder"
+      autoload :ProcedureDeclBuilder,
+               "#{__dir__}/builders/procedure_decl_builder"
+      autoload :RuleDeclBuilder, "#{__dir__}/builders/rule_decl_builder"
+      autoload :SubtypeConstraintBuilder,
+               "#{__dir__}/builders/subtype_constraint_builder"
+      autoload :InterfaceBuilder, "#{__dir__}/builders/interface_builder"
+      autoload :ConstantBuilder, "#{__dir__}/builders/constant_builder"
+      autoload :QualifierBuilder, "#{__dir__}/builders/qualifier_builder"
+      autoload :BuiltInBuilder, "#{__dir__}/builders/built_in_builder"
+    end
+  end
+end

data/lib/expressir/express/cache.rb

@@ -1,29 +1,36 @@
-require 'yaml'
-require 'zlib'
-require 'expressir/model'
+require "digest"
+require "zlib"
 
 module Expressir
   module Express
     class Cache
+      # Format: magic + SHA-256 (raw, 32 bytes) + Zlib-deflated Marshal.dump
+      # of Model::Cache. The digest detects corruption; a corrupted cache is
+      # disposable — callers drop the file and regenerate. Marshal is only
+      # safe for trusted, locally generated cache files.
+      MAGIC = "EXPRC1".freeze
+
+      DIGEST_BYTES = Digest::SHA256.digest("").bytesize
+
       # Save Express model into a cache file
       # @param file [String] cache file path
       # @param content [Model::ModelElement] Express model
       # @param root_path [String] Express repository root path, to be stripped from Express file paths to create a portable cache file
       # @param test_overwrite_version [String] don't use, only for tests
       # @return [nil]
-      def self.to_file(file, content, root_path: nil, test_overwrite_version: nil)
-        version = test_overwrite_version || VERSION
+      def self.to_file(file, content, root_path: nil,
+test_overwrite_version: nil)
+        version = test_overwrite_version || Expressir::Version::VERSION
 
         cache = Model::Cache.new(
           version: version,
-          content: content
+          content: content,
+          root_path: root_path,
         )
 
-        hash = cache.to_hash(root_path: root_path)
-        yaml = YAML.dump(hash)
-        yaml_compressed = Zlib::Deflate.deflate(yaml)
+        data = Zlib::Deflate.deflate(Marshal.dump(cache), 1)
+        File.binwrite(file, "#{MAGIC}#{Digest::SHA256.digest(data)}#{data}")
 
-        File.binwrite(file, yaml_compressed)
         nil
       end
 
@@ -32,20 +39,38 @@ module Expressir
       # @param root_path [String] Express repository root path, to be prepended to Express file paths if loading a portable cache file
       # @param test_overwrite_version [String] don't use, only for tests
       # @return [Model::ModelElement] Express model
+      # @raise [Error::CacheCorruptedError] if the file is not a valid cache file or its digest does not match
+      # @raise [Error::CacheVersionMismatchError] if the cache was written by another Expressir version
       def self.from_file(file, root_path: nil, test_overwrite_version: nil)
-        version = test_overwrite_version || VERSION
+        version = test_overwrite_version || Expressir::Version::VERSION
 
-        yaml_compressed = File.binread(file)
-        yaml = Zlib::Inflate.inflate(yaml_compressed)
-        hash = YAML.load(yaml)
-        cache = Model::ModelElement.from_hash(hash, root_path: root_path)
+        raw = File.binread(file)
+        data = Zlib::Inflate.inflate(validated_data(raw))
+        cache = Marshal.load(data) # rubocop:disable Security/MarshalLoad
 
         if cache.version != version
-          raise Error.new("Cache version mismatch, cache version is #{cache.version}, Expressir version is #{version}")
+          raise Error::CacheVersionMismatchError.new(cache.version, version)
+        end
+
+        cache
+      rescue TypeError, ArgumentError, RangeError
+        raise Error::CacheCorruptedError
+      end
+
+      def self.validated_data(raw)
+        header = MAGIC.bytesize + DIGEST_BYTES
+        unless raw.bytesize > header && raw.start_with?(MAGIC)
+          raise Error::CacheCorruptedError
+        end
+
+        digest = raw.byteslice(MAGIC.bytesize, DIGEST_BYTES)
+        data = raw.byteslice(header, raw.bytesize - header)
+        unless Digest::SHA256.digest(data) == digest
+          raise Error::CacheCorruptedError
         end
 
-        cache.content
+        data
       end
     end
   end
-end
+end