suma 0.2.5 → 0.3.0

data/lib/suma/manifest_traverser.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "expressir"
+
+module Suma
+  # Tree-walking service over a CollectionManifest.
+  #
+  # ManifestTraverser owns all imperative operations that walk or mutate a
+  # manifest tree: finding schemas-only entries, expanding them into
+  # compiled-doc sub-trees, exporting a unified Expressir::SchemaManifest,
+  # and removing schemas-only sources after compilation.
+  #
+  # Each method takes the manifest passed at construction as its root;
+  # recursion instantiates a new traverser per child node so the surface
+  # stays instance-based and the data model (CollectionManifest) stays pure.
+  #
+  # Schema-config loading and doc-entry construction are delegated to
+  # SchemaDiscovery so this class owns traversal, not schema I/O.
+  class ManifestTraverser
+    attr_reader :manifest
+
+    def initialize(manifest)
+      @manifest = manifest
+    end
+
+    # Returns every entry (anywhere in the tree) whose `schemas_only` flag
+    # is truthy, plus +manifest+ itself if it is schemas-only.
+    def find_schemas_only
+      results = (manifest.entry || []).select(&:schemas_only)
+      results << manifest if manifest.schemas_only
+      results
+    end
+
+    # Recursively concatenate every nested schema_config into a single
+    # Expressir::SchemaManifest. The manifest's own schema_config (if set)
+    # seeds the result; otherwise an empty SchemaManifest is returned.
+    def export_schema_config(path)
+      export_config = manifest.schema_config || Expressir::SchemaManifest.new
+      return export_config unless manifest.entry
+
+      manifest.entry.each do |child|
+        child_config = self.class.new(child).export_schema_config(path)
+        export_config.concat(child_config) if child_config
+      end
+
+      export_config
+    end
+
+    # Expand schemas-only entries into compiled-doc sub-trees. If the
+    # manifest has no file, walks children via process_entry. Otherwise
+    # loads the schema_config (SchemaDiscovery), and if this entry is
+    # schemas-only, hides it from the output index and appends a new
+    # sub-collection that hosts the compiled docs.
+    def expand_schemas_only(schema_output_path)
+      return process_entry(schema_output_path) unless manifest.file
+
+      SchemaDiscovery.new(manifest).load_config
+
+      return process_entry(schema_output_path) unless manifest.schemas_only
+
+      manifest.index = false
+
+      added = SchemaDiscovery.new(manifest).build_added_manifest(schema_output_path)
+      [manifest, added]
+    end
+
+    # Drop every direct child whose `schemas_only` is truthy. Called after
+    # compilation so the schemas-only manifest file no longer shows up in
+    # the rendered collection.
+    def remove_schemas_only_sources
+      return unless manifest.entry
+
+      kept = manifest.entry.reject(&:schemas_only)
+      manifest.entry = kept
+    end
+
+    private
+
+    # Walk each child via expand_schemas_only, flattening the results back
+    # into manifest.entry.
+    def process_entry(schema_output_path)
+      return [manifest] unless manifest.entry
+
+      flattened = manifest.entry.each_with_object([]) do |child, acc|
+        acc.concat(self.class.new(child).expand_schemas_only(schema_output_path))
+      end
+
+      manifest.entry = flattened
+      [manifest]
+    end
+  end
+end

data/lib/suma/processor.rb

@@ -1,114 +1,85 @@
 # frozen_string_literal: true
 
-require_relative "schema_collection"
-require_relative "utils"
-require_relative "collection_config"
-require_relative "site_config"
 require "metanorma"
 
 module Suma
   class Processor
-    class << self
-      # rubocop:disable Metrics/MethodLength
-      def run(metanorma_yaml_path:, schemas_all_path:, compile:,
-output_directory: "_site")
-        Utils.log "Current directory: #{Dir.getwd}, writing #{schemas_all_path}..."
-
-        # Generate EXPRESS Schema Manifest by traversing Metanorma Site Manifest
-        # This uses Expressir::SchemaManifest for all manifest operations
-        collection_config = export_schema_config(metanorma_yaml_path,
-                                                 schemas_all_path)
-
-        unless compile
-          Utils.log "No compile option set. Skipping schema compilation."
-          return nil
-        end
-
-        Utils.log "Compiling schema collection..."
-        compile_schema(schemas_all_path, collection_config)
-
-        Utils.log "Compiling complete collection..."
-        compile_collection(collection_config, output_directory)
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      private
-
-      # Generates EXPRESS Schema Manifest from Metanorma Site Manifest structure.
-      #
-      # This method:
-      # 1. Reads the Metanorma site manifest to discover collection files
-      # 2. Traverses collection manifests to find individual schemas.yaml files
-      # 3. Uses Expressir::SchemaManifest to aggregate and manage schema entries
-      # 4. Saves the unified schema manifest using Expressir's to_file method
-      #
-      # @param metanorma_yaml_path [String] Path to Metanorma site manifest
-      # @param schemas_all_path [String] Output path for unified schema manifest
-      # @return [CollectionConfig] The loaded collection configuration
-      # rubocop:disable Metrics/MethodLength
-      def export_schema_config(metanorma_yaml_path, schemas_all_path)
-        # This reads the metanorma.yml file
-        site_config = Suma::SiteConfig::Config.from_file(metanorma_yaml_path)
-
-        # TODO: only reading the first file, which is a collection.yml, which is a hack...
-        collection_config_path = site_config.metanorma.source.files.first
-        collection_config = Suma::CollectionConfig.from_file(collection_config_path)
-        collection_config.path = collection_config_path
-        collection_config.manifest.expand_schemas_only("schema_docs")
-
-        # Recursively traverse collection manifests to build unified schema manifest
-        # Uses Expressir::SchemaManifest methods (concat, to_file) for operations
-        exported_schema_config = collection_config.manifest.export_schema_config(schemas_all_path)
-        exported_schema_config.path = schemas_all_path
-
-        # Save using Expressir's SchemaManifest#to_file method
-        exported_schema_config.to_file
-
-        collection_config
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      def compile_schema(schemas_all_path, collection_config)
-        # now get rid of the source documents for schema sources
-        col = Suma::SchemaCollection.new(
-          config_yaml: schemas_all_path,
-          manifest: collection_config.manifest,
-          output_path_docs: "schema_docs",
-          output_path_schemas: "plain_schemas",
-        )
-
-        col.compile
-      end
-
-      def compile_collection(collection_config, output_directory)
-        metanorma_collection, collection_opts = build_collection(
-          collection_config, output_directory
-        )
-
-        metanorma_collection.render(collection_opts)
-
-        # TODO: Temporarily disable removal of XML files
-        Dir.glob(File.join(Dir.getwd, output_directory,
-                           "*.xml")).each do |file|
-          puts "NOT DELETING ANY FILE #{file.inspect}"
-          # File.delete(file)
-        end
-      end
-
-      def build_collection(collection_config, output_directory)
-        new_collection_config_path = "collection-output.yaml"
-        collection_config.manifest.remove_schemas_only_sources
-        collection_config.to_file(new_collection_config_path)
-
-        collection = Metanorma::Collection.parse(new_collection_config_path)
-
-        collection_opts = {
-          output_folder: output_directory,
-          compile: { install_fonts: false },
-          coverpage: collection_config.coverpage || "cover.html",
-        }
-        [collection, collection_opts]
-      end
+    attr_reader :metanorma_yaml_path, :output_directory, :schemas_all_path,
+                :compile_flag
+
+    def initialize(metanorma_yaml_path:, schemas_all_path:, compile: true,
+                   output_directory: "_site")
+      @metanorma_yaml_path = metanorma_yaml_path
+      @schemas_all_path = schemas_all_path
+      @compile_flag = compile
+      @output_directory = output_directory
+    end
+
+    def run
+      Utils.log "Current directory: #{Dir.getwd}, writing #{schemas_all_path}..."
+
+      collection_config = export_schema_config
+
+      return nil unless @compile_flag
+
+      Utils.log "Compiling schema collection..."
+      compile_schema(schemas_all_path, collection_config)
+
+      Utils.log "Compiling complete collection..."
+      compile_collection(collection_config, output_directory)
+    end
+
+    private
+
+    def export_schema_config
+      site_config = Suma::SiteConfig::Config.from_file(metanorma_yaml_path)
+
+      collection_config_path = site_config.metanorma.source.files.first
+      collection_config = Suma::CollectionConfig.from_file(collection_config_path)
+      collection_config.path = collection_config_path
+
+      traverser = ManifestTraverser.new(collection_config.manifest)
+      traverser.expand_schemas_only("schema_docs")
+
+      exported_schema_config = traverser.export_schema_config(schemas_all_path)
+      exported_schema_config.path = schemas_all_path
+      exported_schema_config.to_file
+
+      collection_config
+    end
+
+    def compile_schema(schemas_all_path, collection_config)
+      col = Suma::SchemaCollection.new(
+        config_yaml: schemas_all_path,
+        manifest: collection_config.manifest,
+        output_path_docs: "schema_docs",
+        output_path_schemas: "plain_schemas",
+      )
+
+      col.compile
+    end
+
+    def compile_collection(collection_config, output_directory)
+      metanorma_collection, collection_opts = build_collection(
+        collection_config, output_directory
+      )
+
+      metanorma_collection.render(collection_opts)
+    end
+
+    def build_collection(collection_config, output_directory)
+      new_collection_config_path = "collection-output.yaml"
+      ManifestTraverser.new(collection_config.manifest).remove_schemas_only_sources
+      collection_config.to_file(new_collection_config_path)
+
+      collection = Metanorma::Collection.parse(new_collection_config_path)
+
+      collection_opts = {
+        output_folder: output_directory,
+        compile: { install_fonts: false },
+        coverpage: collection_config.coverpage || "cover.html",
+      }
+      [collection, collection_opts]
     end
   end
 end

data/lib/suma/register_manifest_generator.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+require "expressir"
+require "glossarist"
+
+module Suma
+  # Generates a Glossarist v3 register.yaml from an EXPRESS schema manifest.
+  #
+  # The schema manifest (schemas-smrl-part-2.yml) is the single source of
+  # truth for schema identities and paths. This class reads it, classifies
+  # each schema by type (resource/module), and emits a register.yaml with
+  # hierarchical sections and human-readable names.
+  #
+  # Architecture:
+  #   - Classification: delegates to ExpressSchema::Type (DRY)
+  #   - Naming: delegates to SchemaNaming (OCP — extend naming without
+  #     touching this class)
+  #   - Sections: built from Glossarist::Section models (model-driven)
+  #   - URN semantics: delegates to Suma::Urn (OCP)
+  #
+  # @example
+  #   generator = RegisterManifestGenerator.new(
+  #     "schemas-smrl-part-2.yml",
+  #     urn: "urn:iso:std:iso:10303:-2:ed-2:en:tech:*",
+  #     id: "iso10303-2-express",
+  #     ref: "ISO 10303-2 EXPRESS Concepts",
+  #   )
+  #   generator.generate  # writes register.yaml
+  class RegisterManifestGenerator
+    DEFAULT_OWNER = "ISO/TC 184/SC 4"
+    DEFAULT_STATUS = "current"
+    DEFAULT_ORDERING = "systematic"
+    DEFAULT_SCHEMA_TYPE = "glossarist"
+    DEFAULT_SCHEMA_VERSION = "3"
+
+    # @param schema_manifest_file [String] path to schemas-smrl-part-2.yml
+    # @param output_path [String] directory to write register.yaml
+    # @param urn [String] base URN for the dataset
+    # @param id [String] dataset identifier
+    # @param ref [String] human-readable reference label
+    # @param language_code [String] language for section names
+    # @param owner [String] dataset owner organisation
+    def initialize(schema_manifest_file, output_path, urn:, id:, ref:,
+                   language_code: "eng", owner: DEFAULT_OWNER)
+      @schema_manifest_file = File.expand_path(schema_manifest_file)
+      @output_path = output_path
+      @urn = Suma::Urn.new(urn)
+      @id = id
+      @ref = ref
+      @language_code = language_code
+      @owner = owner
+    end
+
+    # Generate and write register.yaml.
+    #
+    # @return [Glossarist::DatasetRegister] the generated register
+    def generate
+      validate_inputs
+      schemas = load_schemas
+      register = build_register(schemas)
+
+      FileUtils.mkdir_p(@output_path)
+      output_file = File.join(@output_path, "register.yaml")
+      File.write(output_file, register.to_yaml)
+      Utils.log "Generated register.yaml: #{output_file}"
+      Utils.log "  #{schemas.length} schemas in #{register.sections.length} categories"
+
+      register
+    end
+
+    private
+
+    # Verify that the manifest path exists, is a regular file, and contains
+    # at least one schema entry. Called from {#generate} so both the CLI
+    # shell and direct construction get the same validation behavior.
+    #
+    # @raise [Errno::ENOENT] when the manifest path is missing or not a file
+    # @raise [ArgumentError] when the manifest is empty
+    def validate_inputs
+      unless File.exist?(@schema_manifest_file)
+        raise Errno::ENOENT, "Specified SCHEMA_MANIFEST_FILE " \
+                             "`#{@schema_manifest_file}` not found."
+      end
+      unless File.file?(@schema_manifest_file)
+        raise Errno::ENOENT, "Specified SCHEMA_MANIFEST_FILE " \
+                             "`#{@schema_manifest_file}` is not a file."
+      end
+    end
+
+    # Load all schemas from the manifest file as SchemaManifestEntry models.
+    #
+    # @return [Array<Expressir::SchemaManifestEntry>]
+    def load_schemas
+      manifest = Expressir::SchemaManifest.from_file(@schema_manifest_file)
+      schemas = manifest.schemas.sort_by { |s| s.id.downcase }
+      if schemas.empty?
+        raise ArgumentError, "No schemas found in manifest " \
+                             "`#{@schema_manifest_file}`."
+      end
+      schemas
+    end
+
+    # Build a fully-populated DatasetRegister model.
+    #
+    # @param schemas [Array<Expressir::SchemaManifestEntry>]
+    # @return [Glossarist::DatasetRegister]
+    def build_register(schemas)
+      Glossarist::DatasetRegister.new(
+        schema_type: DEFAULT_SCHEMA_TYPE,
+        schema_version: DEFAULT_SCHEMA_VERSION,
+        id: @id,
+        ref: @ref,
+        urn: @urn.to_s,
+        urn_aliases: @urn.aliases,
+        status: DEFAULT_STATUS,
+        owner: @owner,
+        languages: [@language_code],
+        ordering: DEFAULT_ORDERING,
+        sections: build_sections(schemas),
+      )
+    end
+
+    # Build a list of top-level sections, one per category, in
+    # SchemaCategory::ALL declaration order. Categories with no
+    # schemas are omitted.
+    #
+    # @param schemas [Array<Expressir::SchemaManifestEntry>]
+    # @return [Array<Glossarist::Section>]
+    def build_sections(schemas)
+      groups = schemas.group_by do |s|
+        SchemaCategory.for_schema(id: s.id, path: s.path)
+      end
+
+      SchemaCategory::ALL.filter_map do |category|
+        children = groups[category] || []
+        next if children.empty?
+
+        Glossarist::Section.new(
+          id: category.id,
+          names: { @language_code => category.label },
+          children: children.map { |s| build_section(s) },
+        )
+      end
+    end
+
+    # Build a single leaf section from a schema descriptor.
+    #
+    # @param schema [Expressir::SchemaManifestEntry]
+    # @return [Glossarist::Section]
+    def build_section(schema)
+      Glossarist::Section.new(
+        id: schema.id,
+        names: {
+          @language_code => SchemaNaming.prefixed_name(
+            schema.id, path: schema.path
+          ),
+        },
+      )
+    end
+  end
+end

data/lib/suma/schema_category.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Suma
+  # Value object mapping an ExpressSchema::Type to its register/export category.
+  #
+  # Single source of truth for category identity across the codebase:
+  # directory layout (SchemaExporter), display prefix (SchemaNaming), and
+  # register.yaml sections (RegisterManifestGenerator) all derive from this.
+  #
+  # Each category carries: +id+ (slug used in register.yaml section id and
+  # export subdirectory), +label+ (human-readable section heading),
+  # +prefix+ (prefix used when forming display names, e.g. "Resource: ..."),
+  # +types+ (Array of ExpressSchema::Type symbols that belong to it),
+  # and +directory+ (subdirectory name; "." for the root output path).
+  class SchemaCategory
+    attr_reader :id, :label, :prefix, :types, :directory
+
+    def initialize(id:, label:, prefix:, types:, directory:)
+      @id = id
+      @label = label
+      @prefix = prefix
+      @types = types
+      @directory = directory
+    end
+
+    def member?(type)
+      types.include?(type)
+    end
+
+    RESOURCES = new(
+      id: "resources",
+      label: "Resources",
+      prefix: "Resource",
+      types: [ExpressSchema::Type::RESOURCE].freeze,
+      directory: "resources",
+    )
+    MODULES = new(
+      id: "modules",
+      label: "Application Modules",
+      prefix: "Module",
+      types: [ExpressSchema::Type::MODULE_ARM, ExpressSchema::Type::MODULE_MIM].freeze,
+      directory: "modules",
+    )
+    BUSINESS_OBJECT_MODELS = new(
+      id: "business_object_models",
+      label: "Business Object Models",
+      prefix: "Business Object Model",
+      types: [ExpressSchema::Type::BUSINESS_OBJECT_MODEL].freeze,
+      directory: "business_object_models",
+    )
+    CORE_MODEL = new(
+      id: "core_model",
+      label: "Core Model",
+      prefix: "Core Model",
+      types: [ExpressSchema::Type::CORE_MODEL].freeze,
+      directory: "core_model",
+    )
+    OTHER = new(
+      id: "other",
+      label: "Other Schemas",
+      prefix: "Schema",
+      types: [ExpressSchema::Type::STANDALONE].freeze,
+      directory: ".",
+    )
+
+    ALL = [
+      RESOURCES,
+      MODULES,
+      BUSINESS_OBJECT_MODELS,
+      CORE_MODEL,
+      OTHER,
+    ].freeze
+
+    def self.for_type(type)
+      ALL.find { |category| category.member?(type) } || OTHER
+    end
+
+    def self.for_schema(id:, path:)
+      type = ExpressSchema::Type.classify(id: id, path: path)
+      for_type(type)
+    end
+  end
+end

data/lib/suma/schema_collection.rb

@@ -1,11 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "express_schema"
-require_relative "schema_attachment"
-require_relative "schema_document"
-require_relative "schema_exporter"
 require "expressir"
-require_relative "utils"
 
 module Suma
   class SchemaCollection
@@ -30,46 +25,20 @@ module Suma
       @schema_name_to_docs[schema_name]
     end
 
-    def process_schemas(schemas, klass)
-      schemas.each do |config_schema|
-        process_schema(config_schema, klass)
-      end
-    end
-
-    def process_schema(config_schema, klass)
-      s = ExpressSchema.new(
-        id: config_schema.id, path: config_schema.path.to_s,
-        output_path: @output_path_schemas.to_s
-      )
-
-      doc = klass.new(
-        schema: s, output_path: @output_path_docs.join(s.id),
-      )
-
-      @docs[s.id] = doc
-      @schemas[s.id] = s
-      @schema_name_to_docs[s.id] = doc
-    end
-
     def finalize
-      # Process each schema in @config.schemas
-      process_schemas(@config.schemas, SchemaAttachment)
+      process_schemas(@config.schemas, SchemaTemplate::Plain)
 
-      manifest_entry = @manifest.lookup(:schemas_only, true)
-
-      manifest_entry.each do |entry|
+      schemas_only_entries = ManifestTraverser.new(@manifest).find_schemas_only
+      schemas_only_entries.each do |entry|
         next unless entry.schema_config
 
-        # Process each schema in entry.schema_config.schemas
-        process_schemas(entry.schema_config.schemas, SchemaDocument)
+        process_schemas(entry.schema_config.schemas, SchemaTemplate::Document)
       end
     end
 
-    # rubocop:disable Metrics/MethodLength
     def compile
       finalize
 
-      # Use SchemaExporter for schema export
       exporter = SchemaExporter.new(
         schemas: @config.schemas,
         output_path: @output_path_schemas,
@@ -77,36 +46,32 @@ module Suma
       )
       exporter.export
 
-      docs.each_pair do |_schema_id, entry|
-        entry.compile
+      docs.each_pair do |_schema_id, compiler|
+        compiler.compile
       end
+    end
+
+    private
+
+    def process_schemas(schemas, template_class)
+      schemas.each { |s| process_schema(s, template_class) }
+    end
+
+    def process_schema(config_schema, template_class)
+      express = ExpressSchema.new(
+        id: config_schema.id, path: config_schema.path.to_s,
+        output_path: @output_path_schemas.to_s
+      )
+
+      compiler = SchemaCompiler.new(
+        schema: express,
+        output_path: @output_path_docs.join(express.id),
+        template: template_class.new(express.id),
+      )
 
-      # TODO: make this parallel
-      # Utils.log"Starting Ractor processing"
-      # pool = Ractor.new do
-      #   loop do
-      #     Ractor.yield(Ractor.receive)
-      #   end
-      # end
-      # workers = (1..4).map do |i|
-      #   Ractor.new(pool, name: "r#{i}") do |p|
-      #     loop do
-      #       input = p.take
-      #       Utils.log"compiling in ractor for #{input.filename_adoc}"
-      #       output_value = input.compile
-      #       Ractor.yield(output_value)
-      #     end
-      #   end
-      # end
-      # docs.each do |doc|
-      #   pool.send(doc)
-      # end
-      # results = []
-      # docs.size.times do
-      #   results << Ractor.select(*workers)
-      # end
-      # pp results
+      @docs[express.id] = compiler
+      @schemas[express.id] = express
+      @schema_name_to_docs[express.id] = compiler
     end
-    # rubocop:enable Metrics/MethodLength
   end
 end