expressir 2.4.0 → 2.4.1

data/lib/expressir/coverage.rb

@@ -3,53 +3,39 @@ require "pathname"
 module Expressir
   # Coverage module for calculating documentation coverage of EXPRESS entities
   module Coverage
-    # Mapping of EXPRESS entity type names to their corresponding class names
-    ENTITY_TYPE_MAP = {
-      "TYPE" => "Expressir::Model::Declarations::Type",
-      "ENTITY" => "Expressir::Model::Declarations::Entity",
-      "CONSTANT" => "Expressir::Model::Declarations::Constant",
-      "FUNCTION" => "Expressir::Model::Declarations::Function",
-      "RULE" => "Expressir::Model::Declarations::Rule",
-      "PROCEDURE" => "Expressir::Model::Declarations::Procedure",
-      "SUBTYPE_CONSTRAINT" => "Expressir::Model::Declarations::SubtypeConstraint",
-      "PARAMETER" => "Expressir::Model::Declarations::Parameter",
-      "VARIABLE" => "Expressir::Model::Declarations::Variable",
-      "ATTRIBUTE" => "Expressir::Model::Declarations::Attribute",
-      "DERIVED_ATTRIBUTE" => "Expressir::Model::Declarations::DerivedAttribute",
-      "INVERSE_ATTRIBUTE" => "Expressir::Model::Declarations::InverseAttribute",
-      "UNIQUE_RULE" => "Expressir::Model::Declarations::UniqueRule",
-      "WHERE_RULE" => "Expressir::Model::Declarations::WhereRule",
-      "ENUMERATION_ITEM" => "Expressir::Model::DataTypes::EnumerationItem",
-      "INTERFACE" => "Expressir::Model::Declarations::Interface",
-      "INTERFACE_ITEM" => "Expressir::Model::Declarations::InterfaceItem",
-      "INTERFACED_ITEM" => "Expressir::Model::Declarations::InterfacedItem",
-      "SCHEMA_VERSION" => "Expressir::Model::Declarations::SchemaVersion",
-      "SCHEMA_VERSION_ITEM" => "Expressir::Model::Declarations::SchemaVersionItem",
-    }.freeze
-
-    # Mapping of class names to EXPRESS entity type names (for proper formatting)
-    CLASS_TO_EXPRESS_TYPE_MAP = {
-      "Type" => "TYPE",
-      "Entity" => "ENTITY",
-      "Constant" => "CONSTANT",
-      "Function" => "FUNCTION",
-      "Rule" => "RULE",
-      "Procedure" => "PROCEDURE",
-      "SubtypeConstraint" => "SUBTYPE_CONSTRAINT",
-      "Parameter" => "PARAMETER",
-      "Variable" => "VARIABLE",
-      "Attribute" => "ATTRIBUTE",
-      "DerivedAttribute" => "DERIVED_ATTRIBUTE",
-      "InverseAttribute" => "INVERSE_ATTRIBUTE",
-      "UniqueRule" => "UNIQUE_RULE",
-      "WhereRule" => "WHERE_RULE",
-      "EnumerationItem" => "ENUMERATION_ITEM",
-      "Interface" => "INTERFACE",
-      "InterfaceItem" => "INTERFACE_ITEM",
-      "InterfacedItem" => "INTERFACED_ITEM",
-      "SchemaVersion" => "SCHEMA_VERSION",
-      "SchemaVersionItem" => "SCHEMA_VERSION_ITEM",
-    }.freeze
+    # Single source of truth: EXPRESS type name → Ruby class name pairs.
+    # ENTITY_TYPE_MAP and CLASS_TO_EXPRESS_TYPE_MAP are derived from this
+    # so the two never drift out of sync.
+    TYPE_PAIRS = [
+      ["TYPE", "Expressir::Model::Declarations::Type"],
+      ["ENTITY", "Expressir::Model::Declarations::Entity"],
+      ["CONSTANT", "Expressir::Model::Declarations::Constant"],
+      ["FUNCTION", "Expressir::Model::Declarations::Function"],
+      ["RULE", "Expressir::Model::Declarations::Rule"],
+      ["PROCEDURE", "Expressir::Model::Declarations::Procedure"],
+      ["SUBTYPE_CONSTRAINT", "Expressir::Model::Declarations::SubtypeConstraint"],
+      ["PARAMETER", "Expressir::Model::Declarations::Parameter"],
+      ["VARIABLE", "Expressir::Model::Declarations::Variable"],
+      ["ATTRIBUTE", "Expressir::Model::Declarations::Attribute"],
+      ["DERIVED_ATTRIBUTE", "Expressir::Model::Declarations::DerivedAttribute"],
+      ["INVERSE_ATTRIBUTE", "Expressir::Model::Declarations::InverseAttribute"],
+      ["UNIQUE_RULE", "Expressir::Model::Declarations::UniqueRule"],
+      ["WHERE_RULE", "Expressir::Model::Declarations::WhereRule"],
+      ["ENUMERATION_ITEM", "Expressir::Model::DataTypes::EnumerationItem"],
+      ["INTERFACE", "Expressir::Model::Declarations::Interface"],
+      ["INTERFACE_ITEM", "Expressir::Model::Declarations::InterfaceItem"],
+      ["INTERFACED_ITEM", "Expressir::Model::Declarations::InterfacedItem"],
+      ["SCHEMA_VERSION", "Expressir::Model::Declarations::SchemaVersion"],
+      ["SCHEMA_VERSION_ITEM", "Expressir::Model::Declarations::SchemaVersionItem"],
+    ].freeze
+
+    # EXPRESS entity type name → Ruby class name.
+    ENTITY_TYPE_MAP = TYPE_PAIRS.to_h.freeze
+
+    # Short Ruby class name → EXPRESS entity type name.
+    CLASS_TO_EXPRESS_TYPE_MAP = TYPE_PAIRS.to_h do |express_name, ruby_class|
+      [ruby_class.split("::").last, express_name]
+    end.freeze
 
     # Available TYPE subtypes based on data types
     TYPE_SUBTYPES = %w[
@@ -401,78 +387,24 @@ module Expressir
         entities.concat(container.unique_rules) if container.unique_rules
         entities.concat(container.where_rules) if container.where_rules
 
-      when Expressir::Model::Declarations::Function
-        # Function nested entities
-        entities.concat(container.parameters) if container.parameters
-        entities.concat(container.variables) if container.variables
-        entities.concat(container.constants) if container.constants
-        entities.concat(container.types) if container.types
-        entities.concat(container.entities) if container.entities
-        entities.concat(container.functions) if container.functions
-        entities.concat(container.procedures) if container.procedures
-        entities.concat(container.subtype_constraints) if container.subtype_constraints
-
-        # Recursively find nested entities in nested containers
-        container.types&.each do |type|
-          entities.concat(find_nested_entities(type))
-        end
-        container.entities&.each do |entity|
-          entities.concat(find_nested_entities(entity))
-        end
-        container.functions&.each do |function|
-          entities.concat(find_nested_entities(function))
-        end
-        container.procedures&.each do |procedure|
-          entities.concat(find_nested_entities(procedure))
-        end
-
-      when Expressir::Model::Declarations::Rule
-        # Rule nested entities
-        entities.concat(container.variables) if container.variables
-        entities.concat(container.constants) if container.constants
-        entities.concat(container.types) if container.types
-        entities.concat(container.entities) if container.entities
-        entities.concat(container.functions) if container.functions
-        entities.concat(container.procedures) if container.procedures
-        entities.concat(container.subtype_constraints) if container.subtype_constraints
-
-        # Recursively find nested entities in nested containers
-        container.types&.each do |type|
-          entities.concat(find_nested_entities(type))
-        end
-        container.entities&.each do |entity|
-          entities.concat(find_nested_entities(entity))
-        end
-        container.functions&.each do |function|
-          entities.concat(find_nested_entities(function))
-        end
-        container.procedures&.each do |procedure|
-          entities.concat(find_nested_entities(procedure))
+      when Expressir::Model::Declarations::Function,
+           Expressir::Model::Declarations::Procedure,
+           Expressir::Model::Declarations::Rule
+        # All three scope containers follow the same nested-entity pattern.
+        # Derive the collection list from the model's own declaration rather
+        # than maintaining three separate hand-coded branches.
+        nested_attrs = container.class.collection_attributes_list - %i[
+          statements remark_items where_rules informal_propositions applies_to
+        ]
+        nested_attrs.each do |attr|
+          collection = container.public_send(attr)
+          entities.concat(collection) if collection.is_a?(Array)
         end
 
-      when Expressir::Model::Declarations::Procedure
-        # Procedure nested entities
-        entities.concat(container.parameters) if container.parameters
-        entities.concat(container.variables) if container.variables
-        entities.concat(container.constants) if container.constants
-        entities.concat(container.types) if container.types
-        entities.concat(container.entities) if container.entities
-        entities.concat(container.functions) if container.functions
-        entities.concat(container.procedures) if container.procedures
-        entities.concat(container.subtype_constraints) if container.subtype_constraints
-
-        # Recursively find nested entities in nested containers
-        container.types&.each do |type|
-          entities.concat(find_nested_entities(type))
-        end
-        container.entities&.each do |entity|
-          entities.concat(find_nested_entities(entity))
-        end
-        container.functions&.each do |function|
-          entities.concat(find_nested_entities(function))
-        end
-        container.procedures&.each do |procedure|
-          entities.concat(find_nested_entities(procedure))
+        # Recursively find nested entities in nested scope containers
+        %i[types entities functions procedures].each do |attr|
+          collection = container.public_send(attr)
+          collection&.each { |item| entities.concat(find_nested_entities(item)) }
         end
 
       when Expressir::Model::Declarations::Interface

data/lib/expressir/express/builder.rb

@@ -7,10 +7,34 @@ module Expressir
     # This is the ONLY way to build models from AST - no Transformer fallback.
     module Builder
       class << self
-        attr_reader :source, :include_source
+        # Thread-local key under which the current BuilderContext is stored
+        # for the duration of a build_with_remarks call. Recursive build
+        # calls read source/include_source from here instead of from
+        # class-level mutable state.
+        CONTEXT_KEY = :expressir_builder_context
+
+        # Returns the BuilderContext for the current thread, or nil if no
+        # build is in progress.
+        def current_context
+          Thread.current[CONTEXT_KEY]
+        end
+
+        # Convenience accessors — read from the current context.
+        def source
+          current_context&.source
+        end
 
-        # Cache for snake_case conversions
-        SNAKE_CASE_CACHE = {} # rubocop:disable Style/MutableConstant
+        def include_source
+          current_context&.include_source
+        end
+
+        # Thread-local snake_case conversion cache. Thread-local avoids the
+        # mutable-constant anti-pattern while remaining thread-safe.
+        # Each thread gets its own cache; the cache grows with the number of
+        # unique AST node-type names encountered (bounded by grammar size).
+        def snake_case_cache
+          Thread.current[:expressir_snake_case_cache] ||= {}
+        end
 
         # Register a builder for a node type.
         # @param node_type [Symbol] The AST node type
@@ -23,32 +47,10 @@ module Expressir
 
         # Build a Model object from AST data.
         # @param ast [Hash] The AST with node type as key
-        # @param source [String, nil] The original source code
-        # @param include_source [Boolean, nil] Whether to include source
         # @return [Model::ModelElement] The built model object
-        # Operator tokens that return nil (separators, punctuation)
-        # When these appear as the first key in a multi-key hash, they should be
-        # skipped in favor of the content key. This handles grammar patterns like
-        # `element >> (op_comma >> element).repeat` which produce
-        # {:op_comma => ..., :element => {...}}.
-        OPERATOR_TOKENS = Set.new(%i[
-                                    op_comma op_colon op_decl op_delim op_leftparen op_rightparen
-                                    op_leftbracket op_rightbracket op_left_curly_brace op_right_curly_brace
-                                    op_period op_pipe op_double_backslash op_double_pipe op_double_asterisk
-                                    op_asterisk op_slash op_plus op_minus op_less_equal op_greater_equal
-                                    op_less_greater op_less_than op_greater_than op_equals
-                                    op_colon_less_greater_colon op_colon_equals_colon
-                                    op_query_begin op_query_end op_question_mark
-                                  ]).freeze
-
-        def build(ast, source: nil, include_source: nil)
+        def build(ast)
           return nil unless ast
 
-          # Only set instance variables on first call (when they're provided)
-          # Recursive calls pass nil which shouldn't override the saved values
-          @source = source unless source.nil?
-          @include_source = include_source unless include_source.nil?
-
           # Optimized: Hash is 90%+ of cases, check it first
           case ast
           when Hash
@@ -68,26 +70,27 @@ module Expressir
                 return result
               end
 
-              # Slow path: operator token returned nil in multi-key hash.
-              # Try other keys for actual content. This handles
-              # {:op_comma => ..., :element => {...}} where the first key
-              # is an operator separator rather than a content key.
-              if OPERATOR_TOKENS.include?(handler_key)
-                ast.each_key do |key|
-                  next if key == node_type
-
-                  h_key = cached_snake_case(key)
-                  h_builder = @register[h_key]
-                  next unless h_builder
-
-                  n_data = ast[key]
-                  s_data = fast_convert_keys(n_data)
-                  result = h_builder.call(s_data)
-
-                  unless result.nil?
-                    attach_source_info(result, n_data)
-                    return result
-                  end
+              # Slow path: first-key builder returned nil in a multi-key
+              # hash. Try remaining keys for actual content. This handles
+              # grammar patterns like `element >> (op_comma >> element).repeat`
+              # which produce {:op_comma => ..., :element => {...}} where
+              # the first key is an operator separator.
+              # Previously gated by a hand-maintained OPERATOR_TOKENS set;
+              # now tries all remaining keys unconditionally (TODO.bugs/21).
+              ast.each_key do |key|
+                next if key == node_type
+
+                h_key = cached_snake_case(key)
+                h_builder = @register[h_key]
+                next unless h_builder
+
+                n_data = ast[key]
+                s_data = fast_convert_keys(n_data)
+                result = h_builder.call(s_data)
+
+                unless result.nil?
+                  attach_source_info(result, n_data)
+                  return result
                 end
               end
             else
@@ -105,12 +108,23 @@ module Expressir
           end
         end
 
-        # Build with remark attachment
+        # Build with remark attachment.
+        #
+        # Sets up a BuilderContext as a thread-local for the duration of the
+        # build so recursive build calls can read source/include_source via
+        # `Builder.source` / `Builder.include_source`. The previous context
+        # (if any) is restored on exit so nested builds are reentrant.
         def build_with_remarks(ast, source: nil, include_source: nil)
-          # Reset instance variables at the start of a top-level build
-          # This ensures state from previous parses is cleared
-          @source = source
-          @include_source = include_source
+          # Trigger BuilderRegistry autoload so all AST node type handlers
+          # are registered before build() runs. The reference to
+          # BuilderRegistry resolves the autoload defined in express.rb.
+          BuilderRegistry
+
+          previous = Thread.current[CONTEXT_KEY]
+          Thread.current[CONTEXT_KEY] = BuilderContext.new(
+            source: source,
+            include_source: include_source,
+          )
 
           result = build(ast)
 
@@ -122,6 +136,8 @@ module Expressir
           end
 
           result
+        ensure
+          Thread.current[CONTEXT_KEY] = previous
         end
 
         # Check if a builder is registered for a node type.
@@ -203,41 +219,11 @@ module Expressir
           builder.call(data)
         end
 
-        # Fast path for term nodes
-        def build_term(data)
-          build_node(:term, data)
-        end
-
-        # Fast path for factor nodes
-        def build_factor(data)
-          build_node(:factor, data)
-        end
-
-        # Fast path for simple_factor nodes
-        def build_simple_factor(data)
-          build_node(:simple_factor, data)
-        end
-
-        # Fast path for primary nodes
-        def build_primary(data)
-          build_node(:primary, data)
-        end
-
-        # Fast path for expression nodes
-        def build_expression(data)
-          build_node(:expression, data)
-        end
-
-        # Fast path for simple_expression nodes
-        def build_simple_expression(data)
-          build_node(:simple_expression, data)
-        end
-
         private
 
         # Cached snake_case conversion
         def cached_snake_case(name)
-          SNAKE_CASE_CACHE[name] ||= begin
+          snake_case_cache[name] ||= begin
             str = name.to_s
             # Check if already snake_case
             if /^[a-z_]+$/.match?(str)
@@ -342,25 +328,27 @@ module Expressir
 
         def extract_source_info(data)
           return nil unless data
-          return nil unless @source
+
+          src = source
+          return nil unless src
 
           slice = find_slice(data)
           return nil unless slice
 
           {
-            text: @source[slice.offset...(slice.offset + slice.length)]&.strip,
+            text: src[slice.offset...(slice.offset + slice.length)]&.strip,
             offset: slice.offset,
           }
         end
 
         def attach_source_info(result, data)
-          return unless @source && result.is_a?(Expressir::Model::ModelElement)
+          return unless source && result.is_a?(Expressir::Model::ModelElement)
 
           source_info = extract_source_info(data)
           return unless source_info
 
           result.source_offset = source_info[:offset]
-          result.source = source_info[:text] if @include_source
+          result.source = source_info[:text] if include_source
         end
 
         def find_slice(data, depth = 0)

data/lib/expressir/express/builder_context.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Value object carrying the per-build context that Builder needs to
+    # attach source info to model elements.
+    #
+    # Stored as a thread-local by Builder.build_with_remarks so that recursive
+    # build calls can read `Builder.source` / `Builder.include_source` without
+    # the module mutating class-level state. Thread-local means concurrent
+    # builds in different threads don't corrupt each other; the save/restore
+    # pattern in build_with_remarks means nested builds are reentrant.
+    class BuilderContext
+      attr_reader :source, :include_source
+
+      def initialize(source:, include_source:)
+        @source = source
+        @include_source = include_source
+      end
+    end
+  end
+end

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

@@ -10,9 +10,9 @@ module Expressir
         # Expression
         def build_expression(ast_data)
           left = if ast_data[:simple_expression]
-                   Builder.build_simple_expression(ast_data[:simple_expression])
+                   Builder.build_node(:simple_expression, ast_data[:simple_expression])
                  elsif ast_data[:logical_expression]
-                   Builder.build_simple_expression(ast_data[:logical_expression][:simple_expression])
+                   Builder.build_node(:simple_expression, ast_data[:logical_expression][:simple_expression])
                  end
 
           if ast_data[:rel_op_extended] && ast_data[:rhs]
@@ -29,18 +29,18 @@ module Expressir
         end
 
         def build_logical_expression(ast_data)
-          Builder.build_simple_expression(ast_data[:simple_expression])
+          Builder.build_node(:simple_expression, ast_data[:simple_expression])
         end
 
         def build_numeric_expression(ast_data)
-          Builder.build_simple_expression(ast_data[:simple_expression])
+          Builder.build_node(:simple_expression, ast_data[:simple_expression])
         end
 
         # Simple expression (addition/subtraction chain)
         def build_simple_expression(ast_data)
           return nil unless ast_data[:term]
 
-          term = Builder.build_term(ast_data[:term])
+          term = Builder.build_node(:term, ast_data[:term])
           rhs = ast_data[:rhs]
 
           return term if rhs.nil? || (rhs.is_a?(Array) && rhs.empty?)
@@ -60,7 +60,7 @@ module Expressir
             op_data = item[:operator]
             operators << extract_operator(op_data[:add_like_op]) if op_data
             if item[:term]
-              operands << Builder.build_term(item[:term])
+              operands << Builder.build_node(:term, item[:term])
             end
           end
 
@@ -71,7 +71,7 @@ module Expressir
         def build_term(ast_data)
           return nil unless ast_data[:factor]
 
-          factor = Builder.build_factor(ast_data[:factor])
+          factor = Builder.build_node(:factor, ast_data[:factor])
           rhs = ast_data[:rhs]
 
           return factor if rhs.nil? || (rhs.is_a?(Array) && rhs.empty?)
@@ -90,7 +90,7 @@ module Expressir
             item = r[:item] || r
             op_data = item[:multiplication_like_op] || item[:mul_like_op]
             operators << extract_operator(op_data) if op_data
-            operands << Builder.build_factor(item[:factor]) if item[:factor]
+            operands << Builder.build_node(:factor, item[:factor]) if item[:factor]
           end
 
           build_binary_expression(operands, operators)
@@ -99,14 +99,14 @@ module Expressir
         def build_factor(ast_data)
           return nil unless ast_data[:simple_factor]
 
-          Builder.build_simple_factor(ast_data[:simple_factor])
+          Builder.build_node(:simple_factor, ast_data[:simple_factor])
         end
 
         def build_simple_factor(ast_data)
           return nil unless ast_data
 
           if ast_data[:primary]
-            Builder.build_primary(ast_data[:primary])
+            Builder.build_node(:primary, ast_data[:primary])
           elsif ast_data[:simple_factor_expression]
             Builder.build_node(:simple_factor_expression,
                                ast_data[:simple_factor_expression])
@@ -116,7 +116,7 @@ module Expressir
           elsif ast_data[:constant_factor]
             Builder.build_node(:constant_factor, ast_data[:constant_factor])
           elsif ast_data[:expression]
-            Builder.build_expression(ast_data[:expression])
+            Builder.build_node(:expression, ast_data[:expression])
           elsif ast_data[:aggregate_initializer]
             Builder.build_node(:aggregate_initializer,
                                ast_data[:aggregate_initializer])
@@ -137,21 +137,21 @@ module Expressir
 
         def build_simple_factor_expression(ast_data)
           if ast_data[:primary]
-            Builder.build_primary(ast_data[:primary])
+            Builder.build_node(:primary, ast_data[:primary])
           elsif ast_data[:expression]
-            Builder.build_expression(ast_data[:expression])
+            Builder.build_node(:expression, ast_data[:expression])
           end
         end
 
         def build_simple_factor_unary_expression(ast_data)
           op = extract_unary_op(ast_data[:unary_op])
           operand = if ast_data[:simple_factor]
-                      Builder.build_simple_factor(ast_data[:simple_factor])
+                      Builder.build_node(:simple_factor, ast_data[:simple_factor])
                     elsif ast_data[:simple_factor_expression]
                       Builder.build_node(:simple_factor_expression,
                                          ast_data[:simple_factor_expression])
                     elsif ast_data[:primary]
-                      Builder.build_primary(ast_data[:primary])
+                      Builder.build_node(:primary, ast_data[:primary])
                     end
 
           if op
@@ -181,7 +181,7 @@ module Expressir
           elsif ast_data[:population]
             build_population(ast_data[:population], ast_data[:qualifier])
           elsif ast_data[:expression]
-            Builder.build_expression(ast_data[:expression])
+            Builder.build_node(:expression, ast_data[:expression])
           end
         end
 

data/lib/expressir/express/cache.rb

@@ -1,8 +1,17 @@
+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
@@ -11,7 +20,7 @@ module Expressir
       # @return [nil]
       def self.to_file(file, content, root_path: nil,
 test_overwrite_version: nil)
-        version = test_overwrite_version || VERSION
+        version = test_overwrite_version || Expressir::Version::VERSION
 
         cache = Model::Cache.new(
           version: version,
@@ -19,10 +28,9 @@ test_overwrite_version: nil)
           root_path: root_path,
         )
 
-        yaml = cache.to_yaml
-        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
 
@@ -31,18 +39,37 @@ test_overwrite_version: nil)
       # @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)
-        cache = Model::Cache.from_yaml(yaml)
+        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::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
+
+        data
       end
     end
   end

data/lib/expressir/express/error.rb

@@ -38,6 +38,13 @@ module Expressir
         end
       end
 
+      # Error raised when a cache file is not a valid cache file or fails integrity validation
+      class CacheCorruptedError < ExpressError
+        def initialize(message = "Cache file is corrupted or not a valid Expressir cache file")
+          super
+        end
+      end
+
       # Base class for visitor-related errors
       class VisitorError < ExpressError; end