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

data/lib/expressir/express/xsd.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # EXPRESS → XML Schema writer (expressir #276 step 2,
+    # TODO.parity-ee 15) — the express2xsd counterpart, built on
+    # moxml.
+    #
+    # Mapping (v2):
+    #   ENTITY      → xs:element + xs:complexType (explicit attributes
+    #                 in declaration order); SUBTYPE OF a schema-local
+    #                 entity becomes a substitutionGroup reference.
+    #   ENUMERATION → xs:simpleType with enumeration facets.
+    #   SELECT      → xs:complexType with an xs:choice over the member
+    #                 types (ISO 10303-28 select mapping): entity
+    #                 members reference their global element
+    #                 declarations, defined-type members carry their
+    #                 simpleType. Declared members only — extensible
+    #                 selects and cross-schema members keep the
+    #                 documented v1 fallbacks.
+    #   defined TYPE over a simple type → xs:simpleType restriction.
+    #   attributes  → xs:element inside the complexType sequence;
+    #                 LIST/SET/BAG/ARRAY → maxOccurs="unbounded".
+    #
+    # Built-in EXPRESS types map to XML Schema built-ins (STRING→
+    # xs:string, INTEGER→xs:integer, REAL/NUMBER→xs:double,
+    # BOOLEAN→xs:boolean, LOGICAL→string restriction, BINARY→
+    # xs:hexBinary).
+    module Xsd
+      BUILTIN_TYPES = {
+        "string" => "xs:string",
+        "integer" => "xs:integer",
+        "real" => "xs:double",
+        "number" => "xs:double",
+        "boolean" => "xs:boolean",
+        "binary" => "xs:hexBinary",
+      }.freeze
+
+      AGGREGATES = %w[array list set bag].freeze
+
+      module_function
+
+      # @param schema [Model::Declarations::Schema]
+      # @return [String] the serialized xs:schema document
+      def format(schema)
+        ctx = Moxml::Context.new
+        doc = ctx.create_document
+        root = doc.create_element("xs:schema")
+        root.set_attributes("xmlns:xs" => "http://www.w3.org/2001/XMLSchema",
+                            "elementFormDefault" => "qualified")
+        doc.add_child(root)
+        schema.types.to_a.each { |type| root.add_child(type_node(doc, schema, type)) }
+        schema.entities.to_a.each do |entity|
+          root.add_child(entity_element(doc, schema, entity))
+          root.add_child(entity_type(doc, schema, entity))
+        end
+        doc.to_xml
+      end
+
+      def type_node(doc, schema, type)
+        underlying = type.underlying_type
+        if underlying.is_a?(Expressir::Model::DataTypes::Select)
+          return select_type_node(doc, schema, type, underlying)
+        end
+
+        node = doc.create_element("xs:simpleType")
+        node.set_attributes("name" => type.id)
+        restriction = doc.create_element("xs:restriction")
+        node.add_child(restriction)
+        if underlying.is_a?(Expressir::Model::DataTypes::Enumeration)
+          restriction.set_attributes("base" => "xs:string")
+          underlying.items.to_a.each do |item|
+            facet = doc.create_element("xs:enumeration")
+            facet.set_attributes("value" => item.id)
+            restriction.add_child(facet)
+          end
+        else
+          restriction.set_attributes("base" => xs_type(underlying, schema))
+        end
+        node
+      end
+
+      # ISO 10303-28: a select type maps to a complexType choosing
+      # among its member types. An extensible select with no declared
+      # items gets an empty sequence — an empty xs:choice is not
+      # schema-valid.
+      def select_type_node(doc, schema, type, select)
+        node = doc.create_element("xs:complexType")
+        node.set_attributes("name" => type.id)
+        container = select.items.to_a.empty? ? "xs:sequence" : "xs:choice"
+        choice = doc.create_element(container)
+        node.add_child(choice)
+        select.items.to_a.each do |item|
+          choice.add_child(select_member_element(doc, schema, item))
+        end
+        node
+      end
+
+      def select_member_element(doc, schema, item)
+        node = doc.create_element("xs:element")
+        if item.is_a?(Expressir::Model::References::SimpleReference)
+          id = item.respond_to?(:base_path) && item.base_path ? base_id(item.base_path) : item.id
+          member = select_member_target(schema, id)
+          if member == :entity
+            node.set_attributes("ref" => id)
+          elsif member == :type
+            node.set_attributes("name" => id, "type" => id)
+          else
+            node.set_attributes("name" => id, "type" => "xs:anyType")
+          end
+        else
+          name = item.class.name.split("::").last.downcase
+          node.set_attributes("name" => name,
+                              "type" => BUILTIN_TYPES.fetch(name, "xs:anyType"))
+        end
+        node
+      end
+
+      def select_member_target(schema, id)
+        if schema.entities.to_a.any? { |e| e.id.safe_downcase == id.safe_downcase }
+          :entity
+        elsif schema.types.to_a.any? { |t| t.id.safe_downcase == id.safe_downcase }
+          :type
+        else
+          :unknown
+        end
+      end
+
+      def entity_element(doc, schema, entity)
+        node = doc.create_element("xs:element")
+        node.set_attributes("name" => entity.id)
+        node.set_attributes("type" => entity.id)
+        parent = supertype_name(schema, entity)
+        node.set_attributes("substitutionGroup" => parent) if parent
+        node
+      end
+
+      def entity_type(doc, schema, entity)
+        node = doc.create_element("xs:complexType")
+        node.set_attributes("name" => entity.id)
+        container = node
+        parent = supertype_name(schema, entity)
+        if parent
+          content = doc.create_element("xs:complexContent")
+          extension = doc.create_element("xs:extension")
+          extension.set_attributes("base" => parent)
+          content.add_child(extension)
+          node.add_child(content)
+          container = extension
+        end
+        sequence = doc.create_element("xs:sequence")
+        container.add_child(sequence)
+        explicit_attributes(entity).each do |attr|
+          sequence.add_child(attribute_element(doc, schema, attr))
+        end
+        # EXPRESS multiple inheritance: the extension base carries the
+        # first parent's chain; later parents' attributes (transitively)
+        # become explicit members of the subtype's sequence.
+        additional_parent_attributes(schema, entity).each do |attr|
+          sequence.add_child(attribute_element(doc, schema, attr))
+        end
+        node
+      end
+
+      def explicit_attributes(entity)
+        entity.attributes.to_a.reject do |attr|
+          attr.kind == Expressir::Model::Declarations::Attribute::INVERSE ||
+            (attr.respond_to?(:derive?) && attr.derive?)
+        end
+      end
+
+      # Attributes contributed by multiple inheritance: every ancestor
+      # reachable from the additional local supertypes (all but the
+      # first), minus the first supertype's own chain — the extension
+      # base already carries that. Cycle-safe.
+      def additional_parent_attributes(schema, entity)
+        parents = local_supertypes(schema, entity)
+        return [] if parents.size <= 1
+
+        base_chain = ancestor_set(schema, parents.first)
+        seen = {}.compare_by_identity
+        queue = parents.drop(1)
+        attrs = []
+        until queue.empty?
+          current = queue.shift
+          next if seen[current] || base_chain[current]
+
+          seen[current] = true
+          attrs.concat(explicit_attributes(current))
+          queue.concat(local_supertypes(schema, current))
+        end
+        attrs
+      end
+
+      # Identity set of +entity+ and every supertype ancestor.
+      def ancestor_set(schema, entity)
+        seen = {}.compare_by_identity
+        queue = [entity]
+        until queue.empty?
+          current = queue.shift
+          next if seen[current]
+
+          seen[current] = true
+          queue.concat(local_supertypes(schema, current))
+        end
+        seen
+      end
+
+      def local_supertypes(schema, entity)
+        Array(entity.subtype_of).filter_map do |ref|
+          id = ref.is_a?(String) ? ref : ref.id
+          next nil unless id
+
+          schema.entities.to_a
+            .find { |e| e.id.safe_downcase == id.safe_downcase }
+        end
+      end
+
+      def attribute_element(doc, schema, attr)
+        node = doc.create_element("xs:element")
+        node.set_attributes("name" => attr.id)
+        node.set_attributes("type" => xs_type(attr.type, schema))
+        kind = attr.type.class.name.split("::").last.downcase
+        node.set_attributes("maxOccurs" => "unbounded") if AGGREGATES.include?(kind)
+        node
+      end
+
+      def xs_type(type, schema)
+        if type.is_a?(Expressir::Model::References::SimpleReference)
+          id = type.respond_to?(:base_path) && type.base_path ? base_id(type.base_path) : type.id
+          return schema.types.to_a.any? { |t| t.id.safe_downcase == id.safe_downcase } ? id : "xs:anyType"
+        end
+
+        if type.is_a?(Expressir::Model::DataTypes::Enumeration)
+          return type.id || "xs:string"
+        end
+
+        if type.respond_to?(:base_type)
+          inner = type.base_type
+          return xs_type(inner, schema) if inner
+
+          return "xs:anyType"
+        end
+
+        name = type.class.name.split("::").last.downcase
+        BUILTIN_TYPES.fetch(name, "xs:anyType")
+      end
+
+      def supertype_name(schema, entity)
+        local_supertypes(schema, entity).first&.id
+      end
+
+      def base_id(base_path)
+        parts = base_path.split(".")
+        parts[-1]
+      end
+    end
+  end
+end

data/lib/expressir/express.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    autoload :AstKeyConverter, "#{__dir__}/express/ast_key_converter"
+    autoload :Builder, "#{__dir__}/express/builder"
+    autoload :BuilderContext, "#{__dir__}/express/builder_context"
+    autoload :BuilderRegistry, "#{__dir__}/express/builder_registry"
+    autoload :Builders, "#{__dir__}/express/builders"
+
+    # Core classes (autoloaded for lazy loading)
+    autoload :Cache, "#{__dir__}/express/cache"
+    autoload :AdocHyperlinkFormatter, "#{__dir__}/express/adoc_hyperlink_formatter"
+    autoload :AdocSourceFormatter, "#{__dir__}/express/adoc_source_formatter"
+    autoload :Checker, "#{__dir__}/express/checker"
+    autoload :Concatenator, "#{__dir__}/express/concatenator"
+    autoload :Core, "#{__dir__}/express/core"
+    autoload :RemarkOverlay, "#{__dir__}/express/remark_overlay"
+    autoload :ModelTraversal, "#{__dir__}/express/model_traversal"
+    autoload :RefsOverlay, "#{__dir__}/express/refs_overlay"
+    autoload :Error, "#{__dir__}/express/error"
+    autoload :Formatter, "#{__dir__}/express/formatter"
+    autoload :Formatters, "#{__dir__}/express/formatters"
+    autoload :Grammar, "#{__dir__}/express/grammar"
+    autoload :HyperlinkFormatter, "#{__dir__}/express/hyperlink_formatter"
+    autoload :InterfaceDot, "#{__dir__}/express/interface_dot"
+    autoload :LineMap, "#{__dir__}/express/line_map"
+    autoload :Listing, "#{__dir__}/express/listing"
+    autoload :ModelVisitor, "#{__dir__}/express/model_visitor"
+    autoload :NodePositionIndex, "#{__dir__}/express/node_position_index"
+    autoload :ParallelFiles, "#{__dir__}/express/parallel_files"
+    autoload :Parser, "#{__dir__}/express/parser"
+    autoload :PrettyFormatter, "#{__dir__}/express/pretty_formatter"
+    autoload :PrettyGate, "#{__dir__}/express/pretty_gate"
+    autoload :RemarkAttacher, "#{__dir__}/express/remark_attacher"
+    autoload :RemarkScanner, "#{__dir__}/express/remark_scanner"
+    autoload :ResolveReferencesModelVisitor,
+             "#{__dir__}/express/resolve_references_model_visitor"
+    autoload :SelfSchemaReference, "#{__dir__}/express/self_schema_reference"
+    autoload :Shtolo, "#{__dir__}/express/shtolo"
+    autoload :SchemaBlockScanner, "#{__dir__}/express/schema_block_scanner"
+    autoload :SchemaHeadFormatter, "#{__dir__}/express/schema_head_formatter"
+    autoload :SchemaPlainSourceFormatter,
+             "#{__dir__}/express/schema_plain_source_formatter"
+    autoload :SchemaSourceFormatter, "#{__dir__}/express/schema_source_formatter"
+    autoload :ScopeResolver, "#{__dir__}/express/scope_resolver"
+    autoload :LazyRepository, "#{__dir__}/express/lazy_repository"
+    autoload :SmrlXml, "#{__dir__}/express/smrl_xml"
+    autoload :Xsd, "#{__dir__}/express/xsd"
+    autoload :SourceFormatter, "#{__dir__}/express/source_formatter"
+    autoload :StreamingBuilder, "#{__dir__}/express/streaming_builder"
+  end
+end

data/lib/expressir/liquid.rb

@@ -0,0 +1 @@
+require "liquid"

data/lib/expressir/manifest/resolver.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+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)
+        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