expressir 2.1.30 → 2.1.31

data/lib/expressir/package/builder.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "zip"
+require "time"
+require_relative "metadata"
+
+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, Zip::File::CREATE) 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,
+          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)
+        case format
+        when "marshal"
+          zip.get_output_stream("repository.marshal") do |stream|
+            stream.write(Marshal.dump(repository))
+          end
+        when "json"
+          zip.get_output_stream("repository.json") do |stream|
+            stream.write(repository.to_json)
+          end
+        when "yaml"
+          zip.get_output_stream("repository.yaml") do |stream|
+            stream.write(repository.to_yaml)
+          end
+        end
+      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,81 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+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,165 @@
+# frozen_string_literal: true
+
+require "zip"
+require_relative "metadata"
+
+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)
+        # Load entity index
+        entity_index_entry = zip.find_entry("entity_index.marshal")
+        if entity_index_entry
+          repository.instance_variable_set(
+            :@entity_index,
+            Marshal.load(entity_index_entry.get_input_stream.read),
+          )
+        end
+
+        # Load type index
+        type_index_entry = zip.find_entry("type_index.marshal")
+        if type_index_entry
+          repository.instance_variable_set(
+            :@type_index,
+            Marshal.load(type_index_entry.get_input_stream.read),
+          )
+        end
+
+        # Load reference index
+        reference_index_entry = zip.find_entry("reference_index.marshal")
+        if reference_index_entry
+          repository.instance_variable_set(
+            :@reference_index,
+            Marshal.load(reference_index_entry.get_input_stream.read),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/expressir/schema_manifest.rb

@@ -75,6 +75,8 @@ module Expressir
     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?
 
@@ -87,12 +89,20 @@ module Expressir
     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
-      Pathname.new(absolute_path).relative_path_from(container).to_s
+
+      # 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)

data/lib/expressir/version.rb

@@ -1,3 +1,3 @@
 module Expressir
-  VERSION = "2.1.30".freeze
+  VERSION = "2.1.31".freeze
 end

data/lib/expressir.rb

@@ -59,6 +59,14 @@ module Expressir
     autoload :Cache, "expressir/model/cache"
     autoload :Identifier, "expressir/model/identifier"
     autoload :Repository, "expressir/model/repository"
+    autoload :RepositoryValidator, "expressir/model/repository_validator"
+    autoload :DependencyResolver, "expressir/model/dependency_resolver"
+
+    module Indexes
+      autoload :EntityIndex, "expressir/model/indexes/entity_index"
+      autoload :TypeIndex, "expressir/model/indexes/type_index"
+      autoload :ReferenceIndex, "expressir/model/indexes/reference_index"
+    end
 
     module DataTypes
       autoload :Aggregate, "expressir/model/data_types/aggregate"
@@ -164,6 +172,13 @@ module Expressir
     end
   end
 
+  # Autoload for Package module classes
+  module Package
+    autoload :Metadata, "expressir/package/metadata"
+    autoload :Builder, "expressir/package/builder"
+    autoload :Reader, "expressir/package/reader"
+  end
+
   # Autoload for Commands module classes
   module Commands
     autoload :Base, "expressir/commands/base"
@@ -185,5 +200,3 @@ module Expressir
     autoload :MappingChange, "expressir/changes/mapping_change"
   end
 end
-
-require_relative "expressir/model"