expressir 2.4.29-arm-linux

data/lib/expressir/package/reader.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "zip"
+
+module Expressir
+  module Package
+    # Loads LER packages into Repository instances
+    # Single responsibility: Load .ler ZIP packages
+    class Reader
+      # Load repository from LER package
+      # @param package_path [String] Path to .ler file
+      # @return [Model::Repository] Loaded repository
+      def self.load(package_path)
+        new.load(package_path)
+      end
+
+      # Load repository from LER package
+      # @param package_path [String] Path to .ler file
+      # @return [Model::Repository] Loaded repository
+      def load(package_path)
+        unless File.exist?(package_path)
+          raise ArgumentError, "Package file not found: #{package_path}"
+        end
+
+        repository = nil
+        metadata = nil
+
+        Zip::File.open(package_path) do |zip|
+          # Read metadata first
+          metadata = load_metadata(zip)
+
+          # Load repository based on resolution mode
+          repository = if metadata.resolution_mode == "resolved"
+                         load_serialized_repository(zip,
+                                                    metadata.serialization_format)
+                       else
+                         load_from_express_files(zip)
+                       end
+
+          # Load and restore indexes
+          load_indexes(zip, repository)
+        end
+
+        repository
+      end
+
+      private
+
+      # Load metadata from package
+      # @param zip [Zip::File] ZIP archive
+      # @return [Metadata] Package metadata
+      def load_metadata(zip)
+        entry = zip.find_entry("metadata.yaml")
+        raise "Metadata not found in package" unless entry
+
+        Metadata.from_yaml(entry.get_input_stream.read)
+      end
+
+      # Load serialized repository from package
+      # @param zip [Zip::File] ZIP archive
+      # @param format [String] Serialization format
+      # @return [Model::Repository] Repository instance
+      def load_serialized_repository(zip, format)
+        case format
+        when "marshal"
+          load_marshal_repository(zip)
+        when "json"
+          load_json_repository(zip)
+        when "yaml"
+          load_yaml_repository(zip)
+        else
+          raise "Unknown serialization format: #{format}"
+        end
+      end
+
+      # Load repository from Marshal format
+      # @param zip [Zip::File] ZIP archive
+      # @return [Model::Repository] Repository instance
+      def load_marshal_repository(zip)
+        entry = zip.find_entry("repository.marshal")
+        raise "Serialized repository not found" unless entry
+
+        Marshal.load(entry.get_input_stream.read)
+      end
+
+      # Load repository from JSON format
+      # @param zip [Zip::File] ZIP archive
+      # @return [Model::Repository] Repository instance
+      def load_json_repository(zip)
+        entry = zip.find_entry("repository.json")
+        raise "Serialized repository not found" unless entry
+
+        Model::Repository.from_json(entry.get_input_stream.read)
+      end
+
+      # Load repository from YAML format
+      # @param zip [Zip::File] ZIP archive
+      # @return [Model::Repository] Repository instance
+      def load_yaml_repository(zip)
+        entry = zip.find_entry("repository.yaml")
+        raise "Serialized repository not found" unless entry
+
+        Model::Repository.from_yaml(entry.get_input_stream.read)
+      end
+
+      # Load repository from EXPRESS files
+      # @param zip [Zip::File] ZIP archive
+      # @return [Model::Repository] Repository instance
+      def load_from_express_files(zip)
+        repository = Model::Repository.new
+
+        # Find all EXPRESS files in the package
+        express_entries = zip.entries.select do |entry|
+          entry.name.start_with?("express_files/") && entry.name.end_with?(".exp")
+        end
+
+        # Parse each EXPRESS file
+        express_entries.each do |entry|
+          content = entry.get_input_stream.read
+          schema = Expressir::Express::Parser.from_exp(content)
+          repository.schemas << schema.schemas.first if schema.schemas.any?
+        end
+
+        # Resolve references
+        repository.resolve_all_references
+
+        repository
+      end
+
+      # Load and restore indexes
+      # @param zip [Zip::File] ZIP archive
+      # @param repository [Model::Repository] Repository instance
+      # @return [void]
+      def load_indexes(zip, repository)
+        indexes = {}
+
+        %w[entity_index type_index reference_index].each do |name|
+          entry = zip.find_entry("#{name}.marshal")
+          if entry
+            indexes[name.to_sym] =
+              Marshal.load(entry.get_input_stream.read)
+          end
+        end
+
+        repository.restore_indexes(**indexes) unless indexes.empty?
+      end
+    end
+  end
+end

data/lib/expressir/package.rb

@@ -0,0 +1,8 @@
+# lib/expressir/package.rb
+module Expressir
+  module Package
+    autoload :Metadata, "#{__dir__}/package/metadata"
+    autoload :Builder, "#{__dir__}/package/builder"
+    autoload :Reader, "#{__dir__}/package/reader"
+  end
+end

data/lib/expressir/schema_manifest.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Expressir
+  class SchemaManifest < Lutaml::Model::Serializable
+    attribute :schemas, "Expressir::SchemaManifestEntry",
+              collection: true,
+              initialize_empty: true
+    attribute :path, :string
+    attr_accessor :output_path
+
+    def initialize(**args)
+      @path = path_relative_to_absolute(path) if path
+      super
+    end
+
+    def base_path
+      File.dirname(@path)
+    end
+
+    yaml do
+      map "schemas", with: { from: :schemas_from_yaml, to: :schemas_to_yaml }
+    end
+
+    def self.from_file(path)
+      from_yaml(File.read(path)).tap do |x|
+        x.set_initial_path(path)
+      end
+    rescue StandardError => e
+      raise ManifestValidationError,
+            "Invalid schema manifest format: #{e.message}"
+    end
+
+    def to_file(to_path = path)
+      FileUtils.mkdir_p(File.dirname(to_path))
+      File.write(to_path, to_yaml)
+    end
+
+    def set_initial_path(new_path)
+      @path = path_relative_to_absolute(new_path)
+      schemas.each do |schema|
+        schema.path = path_relative_to_absolute(schema.path)
+        schema.container_path = File.expand_path(@path)
+      end
+    end
+
+    def schemas_from_yaml(model, value)
+      model.schemas = value.map do |k, v|
+        SchemaManifestEntry.new(id: k,
+                                path: path_relative_to_absolute(v["path"]))
+      end
+    end
+
+    def schemas_to_yaml(model, doc)
+      doc["schemas"] = model.schemas.sort_by(&:id).to_h do |schema|
+        # We are outputting the schemas collection file to the directory where
+        # the collection config is at (assumed to be Dir.pwd), not to the
+        # directory we sourced the manifest from, e.g.
+        # documents/iso-10303-41/schemas.yaml.
+
+        # So the schema.container_path = @config.path is not
+        # in fact needed, as the files are already absolute. This notion of
+        # using @path to create relative paths was misconceived
+        [
+          schema.id,
+          {
+            "path" => path_absolute_to_relative(
+              schema.path,
+              model.output_path || Dir.pwd,
+            ),
+          },
+        ]
+      end
+    end
+
+    def path_relative_to_absolute(relative_path)
+      return relative_path if relative_path.nil? || relative_path.empty?
+
+      eval_path = Pathname.new(relative_path)
+      return relative_path if eval_path.absolute?
+
+      # Or based on current working directory?
+      return relative_path unless @path
+
+      # ... but if this calculates path, we end up expanding it anyway
+
+      Pathname.new(File.dirname(@path)).join(eval_path).expand_path.to_s
+    end
+
+    def path_absolute_to_relative(absolute_path, container_path)
+      return absolute_path if absolute_path.nil? || absolute_path.empty?
+
+      container_path ||= @path
+      return absolute_path unless container_path
+      return absolute_path if container_path.empty?
+
+      p = Pathname.new(container_path)
+      container = p.directory? ? p.to_s : p.dirname
+
+      # Check if absolute_path is actually absolute
+      abs_pathname = Pathname.new(absolute_path)
+      return absolute_path unless abs_pathname.absolute?
+
+      abs_pathname.relative_path_from(container).to_s
+    end
+
+    def update_path(new_path)
+      if @path.nil?
+        @path = new_path
+        return @path
+      end
+
+      old_base_path = File.dirname(@path)
+      new_base_path = File.dirname(new_path)
+      update_schema_path(old_base_path, new_base_path)
+
+      @path = new_path
+    end
+
+    def concat(another_config)
+      unless another_config.is_a?(self.class)
+        raise StandardError,
+              "Can only concat a SchemaManifest object."
+      end
+
+      # We need to update the relative paths when paths exist
+      if path && another_config.path && path != another_config.path
+        new_config = another_config.dup
+        new_config.update_path(path)
+      end
+
+      schemas.concat(another_config.schemas)
+    end
+
+    def save_to_path(filename)
+      new_config = dup.tap do |c|
+        c.path = filename
+        c.update_path(File.dirname(filename))
+        c.output_path = filename
+      end
+
+      File.open(filename, "w") do |f|
+        puts "Writing #{filename}..."
+        f.write(new_config.to_yaml)
+        puts "Done."
+      end
+    end
+
+    def update_schema_path(old_base_path, new_base_path)
+      schemas.each do |schema|
+        schema_path = Pathname.new(schema.path)
+        next if schema_path.absolute?
+
+        schema_path = (Pathname.new(old_base_path) + schema_path).cleanpath
+        # This is the new relative schema_path
+        schema.path = schema_path.relative_path_from(new_base_path)
+      end
+    end
+  end
+end

data/lib/expressir/schema_manifest_entry.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Expressir
+  class SchemaManifestEntry < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :path, :string
+    # attribute :schemas_only, :boolean
+
+    # container_path is a copy of Expressir::SchemaManifest.path,
+    # used to resolve the path of each schema within
+    # Expressir::SchemaManifest.schemas,
+    # when Expressir::SchemaManifest.schemas is recursively flattened
+    attr_accessor :container_path
+  end
+end

data/lib/expressir/version.rb

@@ -0,0 +1,8 @@
+module Expressir
+  # Gem version. Wrapped in a Version module so that lib/expressir.rb can
+  # autoload it (Ruby autoload only works for module/class constants, not
+  # for string constants like `Expressir::VERSION`).
+  module Version
+    VERSION = "2.4.29".freeze
+  end
+end

data/lib/expressir.rb

@@ -0,0 +1,94 @@
+require "lutaml/model"
+# Liquid is intentionally NOT required here: lutaml-model's Liquefiable
+# lazily loads it on first #to_liquid (lutaml-model#800), keeping ~170ms
+# off the boot of every consumer that never renders Liquid templates.
+
+# ..........................................................
+# https://bugs.ruby-lang.org/issues/19319
+# The issue is that this bug is fixed for 3.1 and above,
+# but not for 3.0 or 2.7, so we need a "safe" function
+# ..........................................................
+if RUBY_VERSION < "3.1"
+  class String
+    def safe_downcase
+      each_char.map(&:downcase).join
+    end
+  end
+else
+  class String
+    def safe_downcase
+      downcase
+    end
+  end
+end
+
+module Expressir
+  # Namespace modules - autoload loads the namespace file which contains
+  # autoload definitions for classes within that namespace
+  autoload :Config, "#{__dir__}/expressir/config"
+  extend Config
+
+  autoload :Version, "#{__dir__}/expressir/version"
+  autoload :Mapping, "#{__dir__}/expressir/mapping"
+
+  # Error classes — autoload the same errors.rb file from each name.
+  # The first reference triggers the load; the file defines all 21 classes.
+  autoload :Error, "#{__dir__}/expressir/errors"
+  autoload :FileNotFoundError, "#{__dir__}/expressir/errors"
+  autoload :ManifestNotFoundError, "#{__dir__}/expressir/errors"
+  autoload :PackageNotFoundError, "#{__dir__}/expressir/errors"
+  autoload :SchemaNotFoundError, "#{__dir__}/expressir/errors"
+  autoload :UsageError, "#{__dir__}/expressir/errors"
+  autoload :MissingRequiredArgumentError, "#{__dir__}/expressir/errors"
+  autoload :InvalidOptionError, "#{__dir__}/expressir/errors"
+  autoload :ValidationError, "#{__dir__}/expressir/errors"
+  autoload :ManifestValidationError, "#{__dir__}/expressir/errors"
+  autoload :SchemaValidationError, "#{__dir__}/expressir/errors"
+  autoload :ReferentialIntegrityError, "#{__dir__}/expressir/errors"
+  autoload :NoValidSchemaPathsError, "#{__dir__}/expressir/errors"
+  autoload :CommandError, "#{__dir__}/expressir/errors"
+  autoload :PackageBuildError, "#{__dir__}/expressir/errors"
+  autoload :PackageReadError, "#{__dir__}/expressir/errors"
+  autoload :PackageExtractError, "#{__dir__}/expressir/errors"
+  autoload :PackageValidationError, "#{__dir__}/expressir/errors"
+  autoload :PackageListError, "#{__dir__}/expressir/errors"
+  autoload :PackageSearchError, "#{__dir__}/expressir/errors"
+  autoload :PackageTreeError, "#{__dir__}/expressir/errors"
+
+  # Backward-compatible top-level VERSION constant.
+  # Expressir::VERSION is a string, which Ruby autoload cannot lazy-load
+  # (autoload only works for module/class constants). The actual value
+  # lives in Expressir::Version::VERSION, autoloaded on first reference.
+  # This const_missing triggers the autoload when Expressir::VERSION is
+  # referenced, then caches the result.
+  def self.const_missing(name)
+    return Version::VERSION if name == :VERSION
+
+    super
+  end
+
+  autoload :Benchmark, "#{__dir__}/expressir/benchmark"
+  autoload :Coverage, "#{__dir__}/expressir/coverage"
+
+  autoload :Express, "#{__dir__}/expressir/express"
+  autoload :Model, "#{__dir__}/expressir/model"
+  autoload :Commands, "#{__dir__}/expressir/commands"
+  autoload :Changes, "#{__dir__}/expressir/changes"
+  autoload :Package, "#{__dir__}/expressir/package"
+  autoload :Manifest, "#{__dir__}/expressir/manifest"
+  autoload :Eengine, "#{__dir__}/expressir/eengine"
+  autoload :SchemaManifest, "#{__dir__}/expressir/schema_manifest"
+  autoload :SchemaManifestEntry, "#{__dir__}/expressir/schema_manifest_entry"
+
+  # CLI is loaded last so that namespace autoloads are defined first
+  # CLI uses Expressir::Commands::* which triggers autoload
+  autoload :Cli, "#{__dir__}/expressir/cli"
+
+  def self.root
+    File.dirname(__dir__)
+  end
+
+  def self.root_path
+    @root_path ||= Pathname.new(Expressir.root)
+  end
+end

data/lib/tasks/verify_remarks.rake

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# `rake verify:remarks` — the remark conservation gate. Runs only the
+# production-scale checks (`:production_scale` tag; see spec_helper's
+# filter), which the default suite excludes: they parse a full-size
+# schema and cost about a minute.
+#
+# Guarded: rake-compiler-dock's bundle carries production dependencies
+# only, and cross-gem rake invocations must still load the task files.
+if defined?(RSpec)
+  RSpec::Core::RakeTask.new(:"verify:remarks") do |task|
+    task.rspec_opts = "--tag production_scale"
+  end
+else
+  warn "verify_remarks: rspec not available — task not defined"
+end

data/rakelib/native.rake

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Prebuilt platform gems (TODO.suma-improvements/01): the compiled Rust
+# core ships inside per-platform gems, mirroring the parsanol-ruby
+# pattern (RbSys::ExtensionTask + cross_compiling staging). The source
+# gem keeps its gemspec-declared extconf build; platform gems carry the
+# artifact in lib/expressir/, which core.rb's first require finds.
+begin
+  require "rb_sys/extensiontask"
+
+  gemspec = Gem::Specification.load("expressir.gemspec")
+
+  RbSys::ExtensionTask.new("expressir_core", gemspec) do |ext|
+    ext.lib_dir = "lib/expressir"
+    # rb-sys stages the cross-built artifact itself; a manual cp into
+    # lib_dir here would claim the file rake-compiler's own
+    # copy:expressir_core:<host-platform> task owns, and the cross gem's
+    # dependency chain would then force a host-ruby build (rb-sys
+    # refuses windows bindings from linux headers).
+  end
+rescue LoadError
+  # rake-compiler/rb_sys not installed (consumer checkouts); the native
+  # gem tasks are a maintainer/CI concern only.
+end

data/rakelib/oracle.rake

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+
+ORACLE_TAG = "eeng-5.2.8"
+ORACLE_BASE =
+  "https://github.com/expresslang/eengine-releases/releases/download/#{ORACLE_TAG}".freeze
+# Release-asset naming convention for the pinned tag: platform prefix
+# and CPU tag used by expresslang/eengine-releases.
+ORACLE_ASSET_NAMES = {
+  %w[darwin arm64] => "mac-arm64",
+  %w[darwin x86_64] => "mac-x86-64",
+  %w[linux x86_64] => "lnx-x86-64",
+  %w[linux arm64] => "lnx-arm64",
+  %w[mingw x86_64] => "win-x86-64",
+}.freeze
+
+namespace :oracle do
+  desc "Fetch the eengine oracle (#{ORACLE_TAG}) into tmp/oracle/eengine " \
+       "for the SHTOLO corpus differential"
+  task :fetch do
+    platform = [Gem::Platform.local.os, Gem::Platform.local.cpu]
+    tag = ORACLE_ASSET_NAMES[platform]
+    abort "no #{ORACLE_TAG} asset for #{platform.join('-')}" unless tag
+
+    version = ORACLE_TAG.delete_prefix("eeng-")
+    asset = "eengine-#{version}-#{tag}-sbcl#{'.exe' if platform.first == 'mingw'}"
+    target = File.expand_path("../tmp/oracle/eengine", __dir__)
+    digest = "#{target}.sha256"
+
+    if File.executable?(target)
+      expected = File.read(digest).strip.split(/\s+/).first if File.exist?(digest)
+      if expected && Digest::SHA256.file(target).hexdigest == expected
+        warn "oracle already present: #{target}"
+        exit 0
+      end
+      warn "cached oracle is missing or corrupt; refetching"
+      rm_f target
+    end
+
+    dir = File.dirname(target)
+    mkdir_p dir
+    download = File.join(dir, "#{asset}.part")
+    sh "curl", "-fSL", "-o", download, "#{ORACLE_BASE}/#{asset}"
+    sha = Digest::SHA256.file(download).hexdigest
+    mv download, target
+    chmod 0o755, target
+    File.write(digest, "#{sha}  eengine\n")
+    puts "oracle ready: #{target} (#{sha})"
+  end
+end

data/rakelib/verify_remarks.rake

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+namespace :verify do
+  desc "Check remarks against the recorded round-trip gaps, production included"
+  task :remarks do
+    specs = %w[
+      spec/expressir/remark_conservation_spec.rb
+      spec/expressir/remark_ownership_spec.rb
+      spec/expressir/express/formatter_remark_conservation_spec.rb
+      spec/expressir/express/formatter_remark_ownership_spec.rb
+    ]
+
+    sh({ "EXPRESSIR_PRODUCTION_SCALE" => "1" },
+       "bundle", "exec", "rspec", *specs)
+  end
+end