expressir 2.1.30 → 2.1.31

data/lib/expressir/express/formatter.rb

@@ -1,6 +1,10 @@
+require_relative "formatters/remark_item_formatter"
+
 module Expressir
   module Express
     class Formatter
+      include RemarkItemFormatter
+
       INDENT_CHAR = " ".freeze
       INDENT_WIDTH = 2
       INDENT = INDENT_CHAR * INDENT_WIDTH
@@ -194,7 +198,7 @@ module Expressir
         when Model::Declarations::InterfacedItem
           # not implemented yet
         when Model::Declarations::RemarkItem
-          # not implemented yet
+          format_remark_item(node)
         when Model::Cache
           # not implemented yet
         when Model::ModelElement

data/lib/expressir/express/formatters/remark_item_formatter.rb

@@ -0,0 +1,25 @@
+module Expressir
+  module Express
+    # Formatter for RemarkItem declarations
+    module RemarkItemFormatter
+      # Format a RemarkItem as an EXPRESS remark
+      # @param node [Model::Declarations::RemarkItem] The remark item to format
+      # @return [String] Formatted remark
+      def format_remark_item(node)
+        return "" unless node.remarks&.any?
+
+        # Check if any remark contains newlines
+        has_newlines = node.remarks.any? { |r| r.to_s.include?("\n") }
+
+        if has_newlines
+          # Multi-line format: (*"path" remarks *)
+          remarks_text = node.remarks.join("\n")
+          "(*\"#{node.path}\"\n#{remarks_text}\n*)"
+        else
+          # Single-line format: --"path"
+          "--\"#{node.path}\""
+        end
+      end
+    end
+  end
+end

data/lib/expressir/express/parser.rb

@@ -680,6 +680,39 @@ root_path: nil)
 
         @repository
       end
+
+      # Parses Express content string into an Express model
+      # @param [String] content Express content as string
+      # @param [Boolean] skip_references skip resolving references
+      # @param [Boolean] include_source attach original source code to model elements
+      # @return [Model::Repository]
+      # @raise [SchemaParseFailure] if the content fails to parse
+      def self.from_exp(content, skip_references: nil, include_source: nil)
+        begin
+          ast = Parser.new.parse content
+        rescue Parslet::ParseFailed => e
+          raise Error::SchemaParseFailure.new("(from string)", e)
+        end
+
+        visitor = Expressir::Express::Visitor.new(content,
+                                                  include_source: include_source)
+        repository = visitor.visit_ast ast, :top
+
+        repository.schemas.each do |schema|
+          schema.file = nil
+          schema.file_basename = nil
+          schema.formatted = schema.to_s(no_remarks: true)
+        end
+
+        unless skip_references
+          Expressir::Benchmark.measure_references do
+            resolve_references_model_visitor = ResolveReferencesModelVisitor.new
+            resolve_references_model_visitor.visit(repository)
+          end
+        end
+
+        repository
+      end
     end
   end
 end

data/lib/expressir/manifest/resolver.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require_relative "../model/dependency_resolver"
+
+module Expressir
+  module Manifest
+    # Resolves schema paths in manifests using pattern-based path discovery
+    # Attempts to find file paths for schemas with missing or empty paths
+    class Resolver
+      attr_reader :manifest, :options, :base_dirs
+
+      # Initialize resolver
+      # @param manifest [SchemaManifest] The manifest to resolve
+      # @param options [Hash] Resolution options
+      # @option options [Array<String>] :base_dirs Base directories to search
+      # @option options [Boolean] :verbose Enable verbose output
+      def initialize(manifest, options = {})
+        @manifest = manifest
+        @options = options
+        @base_dirs = extract_base_dirs_from_manifest
+
+        # Override with explicit base_dirs if provided
+        if options[:base_dirs]
+          @base_dirs = Array(options[:base_dirs]).map do |d|
+            File.expand_path(d)
+          end
+        end
+      end
+
+      # Resolve paths for all schemas in manifest
+      # Works like manifest create - resolves all dependencies from schemas with paths
+      # @return [SchemaManifest] New manifest with resolved paths and dependencies
+      def resolve_paths
+        # Create new manifest to avoid modifying original
+        resolved_manifest = SchemaManifest.new
+
+        # Track all resolved schema paths
+        all_resolved_paths = Set.new
+        all_unresolved = []
+
+        # Find schemas with valid paths to use as roots
+        root_schemas = manifest.schemas.select do |s|
+          !s.path.nil? && !s.path.empty? && File.exist?(s.path)
+        end
+
+        if root_schemas.empty?
+          # No roots, just try to resolve individual schemas
+          say "No valid schema paths found, attempting simple path resolution..." if options[:verbose]
+          return resolve_paths_simple
+        end
+
+        say "Resolving dependencies from #{root_schemas.size} root schema(s)..." if options[:verbose]
+        say_base_dirs
+
+        # For each root schema, resolve all its dependencies
+        root_schemas.each do |root_entry|
+          resolver = Model::DependencyResolver.new(
+            base_dirs: @base_dirs,
+            schema_registry: build_schema_registry,
+            verbose: options[:verbose],
+          )
+
+          # Resolve all dependencies for this root
+          resolved_paths = resolver.resolve_dependencies(root_entry.path)
+          all_resolved_paths.merge(resolved_paths)
+          all_unresolved.concat(resolver.unresolved)
+        end
+
+        # Add all resolved schemas to manifest
+        all_resolved_paths.each do |path|
+          schema_id = extract_schema_name(path)
+          resolved_manifest.schemas << SchemaManifestEntry.new(
+            id: schema_id,
+            path: path,
+          )
+        end
+
+        # Add unresolved schemas with empty paths
+        all_unresolved.uniq { |e| e[:schema_name] }.each do |entry|
+          # Only add if not already in manifest
+          unless resolved_manifest.schemas.any? do |s|
+            s.id == entry[:schema_name]
+          end
+            resolved_manifest.schemas << SchemaManifestEntry.new(
+              id: entry[:schema_name],
+              path: "",
+            )
+          end
+        end
+
+        resolved_manifest
+      end
+
+      # Simple path resolution - just try to find missing paths
+      # Used when no valid root schemas are available
+      # @return [SchemaManifest] New manifest with resolved paths
+      def resolve_paths_simple
+        resolved_manifest = SchemaManifest.new
+
+        resolver = Model::DependencyResolver.new(
+          base_dirs: @base_dirs,
+          schema_registry: build_schema_registry,
+          verbose: options[:verbose],
+        )
+
+        manifest.schemas.each do |schema_entry|
+          resolved_entry = resolve_schema_entry(schema_entry, resolver)
+          resolved_manifest.schemas << resolved_entry
+        end
+
+        resolved_manifest
+      end
+
+      # Get resolution statistics
+      # @return [Hash] Resolution statistics
+      def statistics
+        unresolved_count = manifest.schemas.count do |s|
+          s.path.nil? || s.path.empty?
+        end
+        {
+          total_schemas: manifest.schemas.size,
+          resolved: manifest.schemas.size - unresolved_count,
+          unresolved: unresolved_count,
+          base_dirs: @base_dirs,
+        }
+      end
+
+      private
+
+      # Extract the actual schema name from a schema file by parsing it
+      # @param schema_path [String] Path to the schema file
+      # @return [String] The schema name declared in the file
+      def extract_schema_name(schema_path)
+        require_relative "../express/parser"
+        repo = Expressir::Express::Parser.from_file(schema_path)
+        schema = repo.schemas.first
+        schema&.id || File.basename(schema_path, ".*")
+      rescue StandardError
+        # Fallback to filename if parsing fails
+        File.basename(schema_path, ".*")
+      end
+
+      # Say message (only used when verbose is enabled)
+      def say(message)
+        puts message if options[:verbose]
+      end
+
+      # Say base directories with numbered labels
+      def say_base_dirs
+        if options[:verbose] && @base_dirs
+          say "  Using base directories:"
+          @base_dirs.each_with_index do |dir, index|
+            say "    - [source #{index + 1}]: #{dir}"
+          end
+        end
+      end
+
+      # Resolve a single schema entry
+      # @param schema_entry [SchemaManifestEntry] The entry to resolve
+      # @param resolver [Model::DependencyResolver] The resolver to use
+      # @return [SchemaManifestEntry] New entry with resolved path
+      def resolve_schema_entry(schema_entry, resolver)
+        # If path already exists and is valid, keep it
+        if schema_entry.path && !schema_entry.path.empty? && File.exist?(schema_entry.path)
+          return SchemaManifestEntry.new(
+            id: schema_entry.id,
+            path: schema_entry.path,
+          )
+        end
+
+        # Try to resolve path using DependencyResolver
+        resolved_path = resolver.resolve_schema_location(
+          schema_entry.id,
+          "USE", # Kind doesn't matter for location resolution
+          nil, # No current path context
+        )
+
+        SchemaManifestEntry.new(
+          id: schema_entry.id,
+          path: resolved_path || schema_entry.path || "",
+        )
+      end
+
+      # Build schema registry from manifest entries with valid paths
+      # Maps schema IDs to their file paths
+      # @return [Hash<String, String>] Schema name => path mapping
+      def build_schema_registry
+        registry = {}
+        manifest.schemas.each do |schema_entry|
+          next if schema_entry.id.nil?
+          next if schema_entry.path.nil? || schema_entry.path.empty?
+          next unless File.exist?(schema_entry.path)
+
+          registry[schema_entry.id] = schema_entry.path
+        end
+        registry
+      end
+
+      # Extract base directories from manifest schema paths
+      # @return [Array<String>] List of unique base directories
+      def extract_base_dirs_from_manifest
+        dirs = manifest.schemas
+          .reject { |s| s.path.nil? || s.path.empty? }
+          .select { |s| File.exist?(s.path) }
+          .map { |s| File.dirname(File.expand_path(s.path)) }
+          .uniq
+
+        # If no directories found, use current directory
+        dirs.empty? ? [Dir.pwd] : dirs
+      end
+    end
+  end
+end

data/lib/expressir/manifest/validator.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require_relative "../model/dependency_resolver"
+
+module Expressir
+  module Manifest
+    # Validates schema manifests for completeness and integrity
+    # Performs three types of validation:
+    # 1. File existence - checks if schema files exist
+    # 2. Path completeness - warns about missing paths
+    # 3. Referential integrity - validates USE/REFERENCE FROM resolution
+    class Validator
+      attr_reader :manifest, :options
+
+      # Initialize validator
+      # @param manifest [SchemaManifest] The manifest to validate
+      # @param options [Hash] Validation options
+      # @option options [Boolean] :verbose Enable verbose output
+      def initialize(manifest, options = {})
+        @manifest = manifest
+        @options = options
+        @base_dirs = extract_base_dirs_from_manifest
+      end
+
+      # Validate that all schema files exist on disk
+      # @return [Array<Hash>] Array of error hashes with :schema, :path, :message
+      def validate_file_existence
+        errors = []
+        manifest.schemas.each do |schema_entry|
+          next if schema_entry.path.nil? || schema_entry.path.empty?
+
+          unless File.exist?(schema_entry.path)
+            errors << {
+              schema: schema_entry.id,
+              path: schema_entry.path,
+              message: "Schema file not found: #{schema_entry.path} (#{schema_entry.id})",
+            }
+          end
+        end
+        errors
+      end
+
+      # Validate that all schemas have paths specified
+      # @return [Array<Hash>] Array of warning hashes with :schema, :message
+      def validate_path_completeness
+        warnings = []
+        manifest.schemas.each do |schema_entry|
+          if schema_entry.path.nil? || schema_entry.path.empty?
+            warnings << {
+              schema: schema_entry.id,
+              message: "Schema '#{schema_entry.id}' has no path specified - please provide path",
+            }
+          end
+        end
+        warnings
+      end
+
+      # Validate that manifest IDs match actual schema names in files
+      # @return [Array<Hash>] Array of error hashes with :schema, :path, :actual_name, :message
+      def validate_schema_names
+        errors = []
+        manifest.schemas.each do |schema_entry|
+          next if schema_entry.path.nil? || schema_entry.path.empty?
+          next unless File.exist?(schema_entry.path)
+
+          begin
+            actual_name = extract_schema_name(schema_entry.path)
+            if actual_name != schema_entry.id
+              errors << {
+                schema: schema_entry.id,
+                path: schema_entry.path,
+                actual_name: actual_name,
+                message: "Schema ID mismatch: manifest has '#{schema_entry.id}' but file declares '#{actual_name}'",
+              }
+            end
+          rescue StandardError
+            # Skip validation if we can't parse the file
+            next
+          end
+        end
+        errors
+      end
+
+      # Validate referential integrity using DependencyResolver
+      # Checks that all USE FROM and REFERENCE FROM interfaces can be resolved
+      # @return [Array<Hash>] Array of error hashes with interface details
+      def validate_referential_integrity
+        errors = []
+
+        # Filter schemas to validate
+        schemas_to_validate = manifest.schemas.select do |s|
+          !s.path.nil? && !s.path.empty? && File.exist?(s.path)
+        end
+
+        # Show header if verbose
+        if @options[:verbose]
+          puts "Validating referential integrity for #{schemas_to_validate.size} schemas..."
+          puts ""
+        end
+
+        # Create resolver ONCE for all schemas (efficiency)
+        # Share verbose output behavior with manifest create command (DRY)
+        resolver = Model::DependencyResolver.new(
+          base_dirs: @base_dirs,
+          schema_registry: build_schema_registry,
+          verbose: @options[:verbose], # Let resolver show detailed interface resolution
+        )
+
+        schemas_to_validate.each do |schema_entry|
+          # Extract interfaces from this schema
+          begin
+            interfaces = resolver.extract_interfaces(schema_entry.path)
+          rescue StandardError => e
+            errors << {
+              schema: schema_entry.id,
+              path: schema_entry.path,
+              message: "Failed to parse schema: #{e.message}",
+            }
+            next
+          end
+
+          # Check each interface can be resolved
+          # The resolver will print verbose output for each resolution when verbose=true
+          interfaces.each do |interface|
+            # Print schema name context if verbose (matches create command style)
+            if @options[:verbose]
+              print "  #{interface[:kind]} FROM #{interface[:schema_name]} (in #{schema_entry.id}): "
+            end
+
+            resolved_path = resolver.resolve_schema_location(
+              interface[:schema_name],
+              interface[:kind],
+              schema_entry.path,
+            )
+
+            if resolved_path.nil?
+              puts "\e[31m✗ not found\e[0m" if @options[:verbose]
+
+              errors << {
+                schema: schema_entry.id,
+                path: schema_entry.path,
+                interface_kind: interface[:kind],
+                referenced_schema: interface[:schema_name],
+                message: "Cannot resolve #{interface[:kind]} FROM #{interface[:schema_name]} in #{schema_entry.id}",
+              }
+            elsif @options[:verbose]
+              relative_path = File.basename(resolved_path)
+              puts "\e[32m✓\e[0m #{relative_path}"
+            end
+          end
+        end
+
+        errors
+      end
+
+      private
+
+      # Extract the actual schema name from a schema file by parsing it
+      # @param schema_path [String] Path to the schema file
+      # @return [String] The schema name declared in the file
+      def extract_schema_name(schema_path)
+        require_relative "../express/parser"
+        repo = Expressir::Express::Parser.from_file(schema_path)
+        schema = repo.schemas.first
+        schema&.id || File.basename(schema_path, ".*")
+      end
+
+      # Build schema registry from manifest entries
+      # Maps schema IDs to their file paths
+      # @return [Hash<String, String>] Schema name => path mapping
+      def build_schema_registry
+        registry = {}
+        manifest.schemas.each do |schema_entry|
+          next if schema_entry.id.nil?
+          next if schema_entry.path.nil? || schema_entry.path.empty?
+
+          registry[schema_entry.id] = schema_entry.path
+        end
+        registry
+      end
+
+      # Extract base directories from manifest schema paths
+      # @return [Array<String>] List of unique base directories
+      def extract_base_dirs_from_manifest
+        dirs = manifest.schemas
+          .reject { |s| s.path.nil? || s.path.empty? }
+          .map { |s| File.dirname(File.expand_path(s.path)) }
+          .uniq
+
+        # If no directories found, use current directory
+        dirs.empty? ? [Dir.pwd] : dirs
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/entity.rb

@@ -10,6 +10,8 @@ module Expressir
         attribute :supertype_expression, ModelElement
         attribute :subtype_of, ModelElement, collection: true
         attribute :attributes, Attribute, collection: true
+        attribute :derived_attributes, DerivedAttribute, collection: true
+        attribute :inverse_attributes, InverseAttribute, collection: true
         attribute :unique_rules, UniqueRule, collection: true
         attribute :where_rules, WhereRule, collection: true
         attribute :informal_propositions, InformalPropositionRule,
@@ -22,6 +24,8 @@ module Expressir
           map "supertype_expression", to: :supertype_expression
           map "subtype_of", to: :subtype_of
           map "attributes", to: :attributes
+          map "derived_attributes", to: :derived_attributes
+          map "inverse_attributes", to: :inverse_attributes
           map "unique_rules", to: :unique_rules
           map "where_rules", to: :where_rules
           map "informal_propositions", to: :informal_propositions
@@ -31,6 +35,8 @@ module Expressir
         def children
           [
             *attributes,
+            *derived_attributes,
+            *inverse_attributes,
             *unique_rules,
             *where_rules,
             *informal_propositions,