expressir 1.2.10-aarch64-linux → 2.4.29-aarch64-linux

data/lib/expressir/express/concatenator.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Builds the concatenated EXPRESS artifact (expressir#247): the
+    # root schema plus every schema reachable through USE FROM /
+    # REFERENCE FROM, one section per source schema, ordered
+    # alphabetically by schema name — the Express Engine
+    # `--concat_schema` semantics.
+    module Concatenator
+      module_function
+
+      # Schemas of the interface closure of `root_schema`, deduplicated
+      # by name and sorted alphabetically — the exact set and order the
+      # concatenated artifact contains. `repository` must hold every
+      # schema the closure can reach.
+      def closure(root_schema, repository)
+        by_name = repository.schemas.to_h { |s| [s.id.safe_downcase, s] }
+        visited = {}
+        queue = [root_schema]
+        until queue.empty?
+          schema = queue.shift
+          key = schema.id.safe_downcase
+          next if visited.key?(key)
+
+          visited[key] = schema
+          Array(schema.interfaces).each do |iface|
+            target = interface_target(iface, by_name)
+            queue << target if target && !visited.key?(target.id.safe_downcase)
+          end
+        end
+        visited.values.sort_by { |s| s.id.safe_downcase }
+      end
+
+      def interface_target(iface, by_name)
+        name = iface.schema.is_a?(String) ? iface.schema : iface.schema&.id
+        return nil unless name
+
+        by_name[name.safe_downcase]
+      end
+
+      # Writes the artifact: a provenance banner, the schema index
+      # (name, file, version), then each source file verbatim behind a
+      # `-- NAME (file)` separator.
+      def write(io, schemas)
+        io.puts "(* Concatenated File produced by Expressir #{Expressir::Version::VERSION}"
+        io.puts
+        io.puts "#{schemas.size} Schemata for Concatenated File"
+        io.puts
+        schemas.each do |schema|
+          io.puts schema.id.safe_downcase
+          io.puts "   Filename: #{schema.file}"
+          io.puts "   Version:   #{schema.version&.value}" if schema.version
+          io.puts
+        end
+        io.puts " *)"
+        io.puts
+        schemas.each do |schema|
+          io.puts "--"
+          io.puts "-- #{schema.id.upcase} (#{schema.file})"
+          io.puts "--"
+          io.write(File.read(schema.file))
+          io.puts
+          io.puts
+        end
+      end
+
+      # One-call convenience: closure of the root schema found in
+      # `repository`, written to `path`.
+      def call(root_schema, repository, path)
+        schemas = closure(root_schema, repository)
+        File.open(path, "w") do |file|
+          write(file, schemas)
+        end
+        schemas
+      end
+    end
+  end
+end

data/lib/expressir/express/core.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Expressir
+  module Express
+    # Ruby bridge to the expressir-core Rust crate (parse + model
+    # extraction). Available when the native extension is built;
+    # callers fall back to the pure-Ruby parser otherwise.
+    module Core
+      NATIVE_AVAILABLE = begin
+        require "expressir/expressir_core"
+        true
+      rescue LoadError
+        begin
+          # Platform gems carry the fat-binary layout
+          # (lib/expressir/<major.minor>/expressir_core.so); rubygems
+          # does not resolve versioned dirs under a nested require path,
+          # so the version segment is explicit - same contract as
+          # parsanol's loader.
+          ruby_version = RUBY_VERSION.split(".").take(2).join(".")
+          require "expressir/#{ruby_version}/expressir_core"
+          true
+        rescue LoadError
+          begin
+            require_relative "../../../ext/expressir_core/expressir_core"
+            true
+          rescue LoadError
+            false
+          end
+        end
+      end
+
+      # Parse EXPRESS source and return the model as a plain Hash in the
+      # lutaml wire shape (to_hash-compatible), ready for
+      # Expressir::Model::ExpFile.from_hash. `path` is the relative file
+      # path used for file/base_path wiring in the model.
+      def self.parse_to_model_hash(source, path)
+        JSON.parse(::Expressir::Core.parse_to_model_hash(source, path))
+      end
+
+      # Parse EXPRESS source into the hydrated model directly: the
+      # extension walks the wire definition once and constructs every
+      # node through Serializable.instantiate (lutaml-model's fast
+      # bulk constructor). Falls back to the hash path when either
+      # the extension or the lutaml-model instantiate API is absent.
+      def self.parse_to_model(source, path)
+        unless ::Expressir::Core.respond_to?(:parse_to_model) &&
+            Model::ExpFile.respond_to?(:instantiate)
+          raise NotImplementedError,
+                "direct model construction unavailable; use parse_to_model_hash"
+        end
+
+        ::Expressir::Core.parse_to_model(source, path)
+      end
+
+      # Lazy handle over a compiled-set artifact (M2): `wire_paths`
+      # lists the set's files without hydrating anything; `hydrate_one`
+      # builds a single file's model on demand. Renderers that touch
+      # one schema per page hydrate one schema per page instead of the
+      # whole repository.
+      def self.lazy_set(path)
+        unless NATIVE_AVAILABLE
+          raise NotImplementedError,
+                "lazy set unavailable without the native extension"
+        end
+        unless ::Expressir::Core.const_defined?(:Set) &&
+            ::Expressir::Core::Set.method_defined?(:hydrate_one)
+          raise NotImplementedError, "lazy set unavailable; ext too old"
+        end
+
+        ::Expressir::Core::Set.open(path)
+      end
+
+      # Compile many files concurrently: jobs are [read_path,
+      # wire_path] pairs; the block receives (wire_path, model, error)
+      # per job in completion order. Workers run on native threads, so
+      # they keep compiling while the block hydrates and post-processes
+      # each model.
+      def self.parse_batch(jobs, workers: 0)
+        unless ::Expressir::Core.respond_to?(:const_defined?) &&
+            ::Expressir::Core.const_defined?(:BatchStream)
+          raise NotImplementedError,
+                "batch compile unavailable; parse files individually"
+        end
+
+        stream = ::Expressir::Core::BatchStream.start(jobs, workers)
+        while (item = stream.next)
+          path, model, error = item
+          yield(path, model, error)
+        end
+      end
+    end
+  end
+end

data/lib/expressir/express/error.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "parsanol"
+
+module Expressir
+  module Express
+    # Module containing all Express-related errors
+    module Error
+      # Base error class for Express errors
+      class ExpressError < StandardError; end
+
+      # Error raised when a schema file fails to parse
+      class SchemaParseFailure < ExpressError
+        attr_reader :filename, :original_error, :parse_failure_cause
+
+        # Initialize a new SchemaParseFailure error
+        # @param filename [String] The name of the file that failed to parse
+        # @param original_error [Parsanol::ParseFailed] The original parsing error
+        def initialize(filename, original_error)
+          @filename = filename
+          @original_error = original_error
+          @parse_failure_cause = original_error.is_a?(Parsanol::ParseFailed) ? original_error.parse_failure_cause : nil
+          super("Failed to parse schema in file '#{filename}': #{original_error.message}")
+        end
+      end
+
+      # Error raised when there's a version mismatch in the cache
+      class CacheVersionMismatchError < ExpressError
+        attr_reader :cache_version, :expressir_version
+
+        # Initialize a new CacheVersionMismatchError
+        # @param cache_version [String] The version of the cache file
+        # @param expressir_version [String] The current Expressir version
+        def initialize(cache_version, expressir_version)
+          @cache_version = cache_version
+          @expressir_version = expressir_version
+          super("Cache version mismatch, cache version is #{cache_version}, Expressir version is #{expressir_version}")
+        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
+
+      # Error raised when parallel file parsing loses a worker or its data
+      class ParallelParseError < ExpressError
+        def initialize(message = "Parallel parsing failed")
+          super
+        end
+      end
+
+      # Error raised when streaming parsing is requested but unavailable.
+      # The streaming paths require a parsanol release whose
+      # parse_with_builder is stable; parse_fresh cannot parse EXPRESS
+      # without packrat memoization (see parsanol-ruby#52).
+      class StreamingUnsupportedError < ExpressError
+        def initialize(message = "Streaming parsing is not supported by the installed parsanol release")
+          super
+        end
+      end
+
+      # Base class for visitor-related errors
+      class VisitorError < ExpressError; end
+
+      # Error raised when visitor encounters invalid state
+      class VisitorInvalidStateError < VisitorError
+        # Initialize a new VisitorInvalidStateError
+        # @param message [String] Additional error information
+        def initialize(message = "Invalid state")
+          super("Visitor error: #{message}")
+        end
+      end
+
+      # Error raised when visitor encounters invalid input
+      class VisitorInvalidInputError < VisitorError
+        # Initialize a new VisitorInvalidInputError
+        # @param message [String] Additional error information
+        def initialize(message)
+          super("Invalid input error: #{message}")
+        end
+      end
+
+      # Error raised when a required method is missing
+      class FormatterMethodMissingError < ExpressError
+        # Initialize a new FormatterMethodMissingError
+        # @param formatter [String] Name of the formatter
+        # @param method [String] Name of the missing method
+        def initialize(formatter, method = nil)
+          method_msg = method ? " Missing method: #{method}" : " Missing required method."
+          super("Formatter error in #{formatter}.#{method_msg}")
+        end
+      end
+
+      # Error raised when an unknown AST node type is encountered
+      class UnknownNodeTypeError < ExpressError
+        attr_reader :node_type
+
+        # Initialize a new UnknownNodeTypeError
+        # @param node_type [Symbol] The unknown node type
+        def initialize(node_type)
+          @node_type = node_type
+          super("Unknown AST node type: #{node_type}")
+        end
+      end
+
+      # Error raised when reference resolution fails
+      class VisitorReferenceResolutionError < VisitorError
+        attr_reader :source, :reference
+
+        # Initialize a new VisitorReferenceResolutionError
+        # @param source [String] Source of the reference
+        # @param reference [String] The reference that failed to resolve
+        def initialize(source, reference)
+          @source = source
+          @reference = reference
+          super("Failed to resolve reference '#{reference}' from '#{source}'")
+        end
+      end
+    end
+  end
+end