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

data/lib/expressir/package/builder.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "zip"
+require "time"
+
+module Expressir
+  module Package
+    # Builds LER packages from Repository instances
+    # Single responsibility: Create .ler ZIP packages
+    class Builder
+      # Build LER package from repository
+      # @param repository [Model::Repository] Repository to package
+      # @param output_path [String] Output .ler file path
+      # @param options [Hash] Package options
+      # @option options [String] :name Package name
+      # @option options [String] :version Package version
+      # @option options [String] :description Package description
+      # @option options [String] :express_mode ('include_all') Bundling mode
+      # @option options [String] :resolution_mode ('resolved') Resolution mode
+      # @option options [String] :serialization_format ('marshal') Serialization format
+      # @return [String] Path to created package
+      def build(repository, output_path, options = {})
+        options = normalize_options(options)
+        metadata = build_metadata(repository, options)
+
+        # Validate metadata
+        validation = metadata.validate
+        unless validation[:valid?]
+          raise ArgumentError,
+                "Invalid metadata: #{validation[:errors].join(', ')}"
+        end
+
+        # Create ZIP package
+        Zip::File.open(output_path, create: true) do |zip|
+          add_metadata(zip, metadata)
+          add_schemas(zip, repository, options)
+          add_indexes(zip, repository)
+          add_manifest(zip, repository)
+        end
+
+        output_path
+      end
+
+      private
+
+      # Normalize options with defaults
+      # @param options [Hash] Raw options
+      # @return [Hash] Normalized options
+      def normalize_options(options)
+        {
+          name: options[:name] || "Unnamed Package",
+          version: options[:version] || "1.0.0",
+          description: options[:description] || "",
+          express_mode: options[:express_mode] || "include_all",
+          resolution_mode: options[:resolution_mode] || "resolved",
+          serialization_format: options[:serialization_format] || "marshal",
+        }
+      end
+
+      # Build metadata from repository and options
+      # @param repository [Model::Repository] Repository instance
+      # @param options [Hash] Package options
+      # @return [Metadata] Package metadata
+      def build_metadata(repository, options)
+        Metadata.new(
+          name: options[:name],
+          version: options[:version],
+          description: options[:description],
+          created_at: Time.now.utc.iso8601,
+          created_by: "expressir",
+          expressir_version: Expressir::Version::VERSION,
+          express_mode: options[:express_mode],
+          resolution_mode: options[:resolution_mode],
+          serialization_format: options[:serialization_format],
+          files: count_files(repository),
+          schemas: repository.schemas.size,
+        )
+      end
+
+      # Count files in repository
+      # @param repository [Model::Repository] Repository instance
+      # @return [Integer] File count
+      def count_files(repository)
+        repository.schemas.count(&:file)
+      end
+
+      # Add metadata to package
+      # @param zip [Zip::File] ZIP archive
+      # @param metadata [Metadata] Package metadata
+      # @return [void]
+      def add_metadata(zip, metadata)
+        zip.get_output_stream("metadata.yaml") do |stream|
+          stream.write(metadata.to_yaml)
+        end
+      end
+
+      # Add schemas to package based on resolution mode
+      # @param zip [Zip::File] ZIP archive
+      # @param repository [Model::Repository] Repository instance
+      # @param options [Hash] Package options
+      # @return [void]
+      def add_schemas(zip, repository, options)
+        case options[:resolution_mode]
+        when "resolved"
+          add_serialized_repository(zip, repository,
+                                    options[:serialization_format])
+        end
+
+        # Add EXPRESS files if include_all mode
+        if options[:express_mode] == "include_all"
+          add_express_files(zip, repository)
+        end
+      end
+
+      # Add serialized repository to package
+      # @param zip [Zip::File] ZIP archive
+      # @param repository [Model::Repository] Repository instance
+      # @param format [String] Serialization format
+      # @return [void]
+      def add_serialized_repository(zip, repository, format)
+        # Normalize repository - ensure all schemas are in files for serialization
+        normalized_repo = normalize_repository(repository)
+
+        case format
+        when "marshal"
+          zip.get_output_stream("repository.marshal") do |stream|
+            stream.write(Marshal.dump(normalized_repo))
+          end
+        when "json"
+          zip.get_output_stream("repository.json") do |stream|
+            stream.write(normalized_repo.to_json)
+          end
+        when "yaml"
+          zip.get_output_stream("repository.yaml") do |stream|
+            stream.write(normalized_repo.to_yaml)
+          end
+        end
+      end
+
+      # Normalize repository for serialization
+      # Ensures all schemas are in files (not in @_schemas)
+      # @param repository [Model::Repository] Repository to normalize
+      # @return [Model::Repository] Normalized repository
+      def normalize_repository(repository)
+        # Create a new repository with proper file structure
+        normalized = Model::Repository.new(base_dir: repository.base_dir)
+
+        # Copy existing files
+        repository.files&.each do |file|
+          normalized.files << file
+        end
+
+        # Get schemas that are not already in files
+        file_schema_ids = normalized.files.flat_map(&:schemas).compact.map(&:id)
+        direct_schemas = repository.schemas.reject do |s|
+          file_schema_ids.include?(s.id)
+        end
+
+        # Create an ExpFile for direct schemas
+        if direct_schemas.any?
+          exp_file = Model::ExpFile.new(path: "direct_schemas.exp")
+          exp_file.schemas = direct_schemas
+          normalized.files << exp_file
+        end
+
+        normalized
+      end
+
+      # Add EXPRESS files to package
+      # @param zip [Zip::File] ZIP archive
+      # @param repository [Model::Repository] Repository instance
+      # @return [void]
+      def add_express_files(zip, repository)
+        repository.schemas.each do |schema|
+          next unless schema.file && File.exist?(schema.file)
+
+          # Use schema id as filename
+          filename = "express_files/#{schema.id}.exp"
+          zip.get_output_stream(filename) do |stream|
+            stream.write(File.read(schema.file))
+          end
+        end
+      end
+
+      # Add indexes to package
+      # @param zip [Zip::File] ZIP archive
+      # @param repository [Model::Repository] Repository instance
+      # @return [void]
+      def add_indexes(zip, repository)
+        # Ensure indexes are built
+        repository.build_indexes if repository.entity_index.nil?
+
+        # Serialize indexes using Marshal for performance
+        zip.get_output_stream("entity_index.marshal") do |stream|
+          stream.write(Marshal.dump(repository.entity_index))
+        end
+
+        zip.get_output_stream("type_index.marshal") do |stream|
+          stream.write(Marshal.dump(repository.type_index))
+        end
+
+        zip.get_output_stream("reference_index.marshal") do |stream|
+          stream.write(Marshal.dump(repository.reference_index))
+        end
+      end
+
+      # Add manifest to package with rewritten paths
+      # @param zip [Zip::File] ZIP archive
+      # @param repository [Model::Repository] Repository instance
+      # @return [void]
+      def add_manifest(zip, repository)
+        # Create manifest with package-internal paths
+        manifest = Expressir::SchemaManifest.new
+
+        repository.schemas.each do |schema|
+          manifest.schemas << Expressir::SchemaManifestEntry.new(
+            id: schema.id,
+            path: "express_files/#{schema.id}.exp", # Package-internal path
+          )
+        end
+
+        # Set output_path to suppress relative path calculation
+        manifest.output_path = "manifest.yaml"
+
+        zip.get_output_stream("manifest.yaml") do |stream|
+          stream.write(manifest.to_yaml)
+        end
+      end
+    end
+  end
+end

data/lib/expressir/package/metadata.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Package
+    # Package metadata with serialization support
+    # Stores configuration and statistics for LER packages
+    class Metadata < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :version, :string
+      attribute :description, :string
+      attribute :created_at, :string
+      attribute :created_by, :string, default: -> { "expressir" }
+      attribute :expressir_version, :string
+      attribute :express_mode, :string, default: -> { "include_all" }
+      attribute :resolution_mode, :string, default: -> { "resolved" }
+      attribute :serialization_format, :string, default: -> { "marshal" }
+      attribute :files, :integer
+      attribute :schemas, :integer
+
+      yaml do
+        map "name", to: :name
+        map "version", to: :version
+        map "description", to: :description
+        map "created_at", to: :created_at
+        map "created_by", to: :created_by
+        map "expressir_version", to: :expressir_version
+        map "express_mode", to: :express_mode
+        map "resolution_mode", to: :resolution_mode
+        map "serialization_format", to: :serialization_format
+        map "files", to: :files
+        map "schemas", to: :schemas
+      end
+
+      # Validate metadata configuration
+      # @return [Hash] Validation result with :valid? and :errors
+      def validate
+        errors = []
+
+        errors << "name is required" if name.nil? || name.empty?
+        errors << "version is required" if version.nil? || version.empty?
+
+        unless %w[include_all allow_external].include?(express_mode)
+          errors << "express_mode must be 'include_all' or 'allow_external'"
+        end
+
+        unless %w[resolved bare].include?(resolution_mode)
+          errors << "resolution_mode must be 'resolved' or 'bare'"
+        end
+
+        unless %w[marshal json yaml].include?(serialization_format)
+          errors << "serialization_format must be 'marshal', 'json', or 'yaml'"
+        end
+
+        {
+          valid?: errors.empty?,
+          errors: errors,
+        }
+      end
+
+      # Convert metadata to hash
+      # @return [Hash] Metadata as hash
+      def to_h
+        {
+          "name" => name,
+          "version" => version,
+          "description" => description,
+          "created_at" => created_at,
+          "created_by" => created_by,
+          "expressir_version" => expressir_version,
+          "express_mode" => express_mode,
+          "resolution_mode" => resolution_mode,
+          "serialization_format" => serialization_format,
+          "files" => files,
+          "schemas" => schemas,
+        }
+      end
+    end
+  end
+end

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

@@ -1,3 +1,8 @@
 module Expressir
-  VERSION = "1.2.10".freeze
+  # 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