suma 0.2.6 → 0.3.0

data/lib/suma/cli/extract_terms.rb

@@ -1,28 +1,25 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "../thor_ext"
-require_relative "../term_extractor"
 
 module Suma
   module Cli
     class ExtractTerms < Thor
       desc "extract_terms SCHEMA_MANIFEST_FILE GLOSSARIST_OUTPUT_PATH",
            "Extract terms from SCHEMA_MANIFEST_FILE into " \
-           "Glossarist v2 format"
+           "Glossarist v3 format"
       option :language_code, type: :string, default: "eng", aliases: "-l",
                              desc: "Language code for the Glossarist"
+      option :urn, type: :string, required: true, aliases: "-u",
+                   desc: "URN for the dataset source " \
+                         "(used for section references)"
 
       def extract_terms(schema_manifest_file, output_path)
-        unless File.exist?(File.expand_path(schema_manifest_file))
-          raise Errno::ENOENT, "Specified SCHEMA_MANIFEST_FILE " \
-                               "`#{schema_manifest_file}` not found."
-        end
-
         TermExtractor.new(
           schema_manifest_file,
           output_path,
           language_code: options[:language_code],
+          urn: options[:urn],
         ).call
       end
     end

data/lib/suma/cli/generate_register.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Suma
+  module Cli
+    class GenerateRegister < Thor
+      desc "generate_register SCHEMA_MANIFEST_FILE OUTPUT_PATH",
+           "Generate a Glossarist register.yaml with hierarchical sections"
+      option :language_code, type: :string, default: "eng", aliases: "-l",
+                             desc: "Language code for section names"
+      option :urn, type: :string, required: true, aliases: "-u",
+                   desc: "URN prefix for the dataset"
+      option :id, type: :string, required: true,
+                  desc: "Dataset identifier (e.g. iso10303-2-express)"
+      option :ref, type: :string, required: true,
+                   desc: "Human-readable reference label"
+      option :owner, type: :string, default: Suma::RegisterManifestGenerator::DEFAULT_OWNER,
+                     desc: "Owner of the dataset (e.g. 'ISO/TC 184/SC 4')"
+
+      def generate_register(schema_manifest_file, output_path)
+        RegisterManifestGenerator.new(
+          schema_manifest_file,
+          output_path,
+          urn: options[:urn],
+          id: options[:id],
+          ref: options[:ref],
+          language_code: options[:language_code],
+          owner: options[:owner],
+        ).generate
+      end
+    end
+  end
+end

data/lib/suma/cli/generate_schemas.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "../thor_ext"
-require_relative "../schema_manifest_generator"
 
 module Suma
   module Cli

data/lib/suma/cli/reformat.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "../thor_ext"
 
 module Suma
   module Cli

data/lib/suma/cli/validate.rb

@@ -9,8 +9,6 @@ module Suma
       desc "links SCHEMAS_FILE DOCUMENTS_PATH [OUTPUT_FILE]",
            "Extract and validate express links without creating intermediate file"
       def links(*args)
-        require_relative "validate_links"
-
         # Forward the command to ValidateLinks
         links = Cli::ValidateLinks.new
         links.extract_and_validate(*args)

data/lib/suma/cli/validate_links.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "../utils"
-require_relative "../link_validator"
 require "expressir"
 
 module Suma

data/lib/suma/cli.rb

@@ -1,147 +1,18 @@
 # frozen_string_literal: true
 
-require "thor"
-require_relative "thor_ext"
-require_relative "cli/validate"
-require_relative "cli/check_svg_quality"
-require "expressir"
-require "expressir/cli"
-
 module Suma
   module Cli
-    # Core command class for handling CLI entrypoints
-    class Core < Thor
-      extend ThorExt::Start
-
-      desc "build METANORMA_SITE_MANIFEST",
-           "Build collection specified in site manifest (`metanorma*.yml`)"
-      option :compile, type: :boolean, default: true,
-                       desc: "Compile or skip compile of collection"
-      option :schemas_all_path, type: :string, aliases: "-s",
-                                desc: "Generate file that contains all " \
-                                      "schemas in the collection."
-      def build(_site_manifest)
-        require_relative "cli/build"
-        Cli::Build.start
-      end
-
-      desc "generate-schemas METANORMA_MANIFEST_FILE SCHEMA_MANIFEST_FILE",
-           "Generate EXPRESS schema manifest file from Metanorma site manifest"
-      option :exclude_paths, type: :string, default: nil, aliases: "-e",
-                             desc: "Exclude schemas paths by pattern " \
-                                   "(e.g. `*_lf.exp`)"
-      def generate_schemas(_metanorma_manifest_file, _schema_manifest_file)
-        require_relative "cli/generate_schemas"
-        Cli::GenerateSchemas.start
-      end
-
-      desc "reformat EXPRESS_FILE_PATH",
-           "Reformat EXPRESS files"
-      option :recursive, type: :boolean, default: false, aliases: "-r",
-                         desc: "Reformat EXPRESS files under the specified " \
-                               "path recursively"
-      def reformat(_express_file_path)
-        require_relative "cli/reformat"
-        Cli::Reformat.start
-      end
-
-      desc "extract-terms SCHEMA_MANIFEST_FILE GLOSSARIST_OUTPUT_PATH",
-           "Extract terms from SCHEMA_MANIFEST_FILE into " \
-           "Glossarist v2 format"
-      option :language_code, type: :string, default: "eng", aliases: "-l",
-                             desc: "Language code for the Glossarist"
-      def extract_terms(_schema_manifest_file, _glossarist_output_path)
-        require_relative "cli/extract_terms"
-        Cli::ExtractTerms.start
-      end
-
-      desc "convert-jsdai XML_FILE IMAGE_FILE OUTPUT_DIR",
-           "Convert JSDAI XML and image files to SVG and EXP files"
-      def convert_jsdai(_xml_file, _image_file, _output_dir)
-        require_relative "cli/convert_jsdai"
-        Cli::ConvertJsdai.start
-      end
-
-      desc "export *FILES",
-           "Export EXPRESS schemas from manifest files or " \
-           "standalone EXPRESS files"
-      option :output, type: :string, aliases: "-o", required: true,
-                      desc: "Output directory path"
-      option :annotations, type: :boolean, default: false,
-                           desc: "Include annotations (remarks/comments)"
-      option :zip, type: :boolean, default: false,
-                   desc: "Create ZIP archive of exported schemas"
-      def export(*_files)
-        require_relative "cli/export"
-        Cli::Export.start
-      end
-
-      desc "compare TRIAL_SCHEMA REFERENCE_SCHEMA",
-           "Compare EXPRESS schemas using eengine and generate Change YAML"
-      option :output, type: :string, aliases: "-o",
-                      desc: "Output Change YAML file path"
-      option :version, type: :string, aliases: "-v", required: true,
-                       desc: "Version number for this change version"
-      option :mode, type: :string, default: "resource",
-                    desc: "Schema comparison mode (resource/module)"
-      option :trial_stepmod, type: :string,
-                             desc: "Override auto-detected trial repo root"
-      option :reference_stepmod, type: :string,
-                                 desc: "Override auto-detected reference repo root"
-      option :verbose, type: :boolean, default: false,
-                       desc: "Enable verbose output"
-      def compare(_trial_schema, _reference_schema)
-        require_relative "cli/compare"
-        Cli::Compare.start
-      end
-
-      desc "validate SUBCOMMAND ...ARGS", "Validate express documents"
-      subcommand "validate", Cli::Validate
-
-      desc "check_svg_quality [PATH]",
-           "Check SVG quality and sort by severity (critical files first)"
-      option :pattern, type: :string, default: Cli::CheckSvgQuality::DEFAULT_PATTERN,
-                       desc: "Glob pattern for finding SVG files"
-      option :profile, type: :string,
-                       default: Cli::CheckSvgQuality::DEFAULT_PROFILE,
-                       desc: "Validation profile to use (metanorma, svg_1_2_rfc, etc.)"
-      option :format, type: :string, default: "terminal",
-                      desc: "Output format: terminal, yaml, json"
-      option :output, type: :string, aliases: "-o",
-                      desc: "Output file path"
-      option :min_errors, type: :numeric,
-                          desc: "Minimum error count threshold"
-      option :limit, type: :numeric, default: nil,
-                     desc: "Maximum number of files to show (default: unlimited)"
-      option :sort, type: :string, default: "errors",
-                    desc: "Sort by: errors (most errors first) or quality (lowest scores first)"
-      option :progress, type: :boolean, default: false,
-                        desc: "Show progress during processing"
-      option :summary_only, type: :boolean, default: false,
-                            desc: "Show only summary"
-      def check_svg_quality(path = Cli::CheckSvgQuality::DATA_PATH)
-        require_relative "cli/check_svg_quality"
-
-        analyzer = Cli::CheckSvgQuality.new(
-          pattern: options[:pattern],
-          profile: options[:profile],
-          format: options[:format],
-          output: options[:output],
-          min_errors: options[:min_errors],
-          summary_only: options[:summary_only],
-          progress: options[:progress],
-          limit: options[:limit],
-          sort: options[:sort],
-        )
-        analyzer.run(path)
-      end
-
-      desc "expressir SUBCOMMAND ...ARGS", "Expressir commands"
-      subcommand "expressir", Expressir::Cli
-
-      def self.exit_on_failure?
-        true
-      end
-    end
+    autoload :Core,             "suma/cli/core"
+    autoload :Build,            "suma/cli/build"
+    autoload :CheckSvgQuality,  "suma/cli/check_svg_quality"
+    autoload :Compare,          "suma/cli/compare"
+    autoload :ConvertJsdai,     "suma/cli/convert_jsdai"
+    autoload :Export,           "suma/cli/export"
+    autoload :ExtractTerms,     "suma/cli/extract_terms"
+    autoload :GenerateRegister, "suma/cli/generate_register"
+    autoload :GenerateSchemas,  "suma/cli/generate_schemas"
+    autoload :Reformat,         "suma/cli/reformat"
+    autoload :Validate,         "suma/cli/validate"
+    autoload :ValidateLinks,    "suma/cli/validate_links"
   end
 end

data/lib/suma/collection_config.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "utils"
 require "lutaml/model"
-require_relative "collection_manifest"
 require "metanorma"
 
 module Suma

data/lib/suma/collection_manifest.rb

@@ -4,6 +4,13 @@ require "metanorma"
 require "expressir"
 
 module Suma
+  # Pure data model for one node of a Metanorma collection manifest.
+  #
+  # CollectionManifest extends the Metanorma config manifest to add the
+  # `schemas_only` flag and an `entry` sub-collection. It owns only state:
+  # attributes, YAML mappings, and the `schema_config` slot populated by
+  # SchemaDiscovery. Tree-walking logic lives in ManifestTraverser; schema
+  # I/O lives in SchemaDiscovery.
   class CollectionManifest < Metanorma::Collection::Config::Manifest
     attribute :schemas_only, Lutaml::Model::Type::Boolean
     attribute :entry, CollectionManifest, collection: true,
@@ -32,115 +39,5 @@ module Suma
     def docref_from_yaml(model, value)
       model.entry = CollectionManifest.from_yaml(value.to_yaml)
     end
-
-    # Recursively exports schema configuration by traversing collection manifests.
-    #
-    # This method builds an EXPRESS Schema Manifest (Expressir::SchemaManifest) by:
-    # 1. Starting with an empty or existing Expressir::SchemaManifest
-    # 2. Recursively traversing child entries to collect schemas
-    # 3. Using Expressir::SchemaManifest#concat to combine manifests
-    #
-    # The actual schema manifest operations (creation, concatenation, serialization)
-    # are handled by Expressir's SchemaManifest class, keeping the logic DRY.
-    #
-    # @param path [String] Base path for resolving relative schema paths
-    # @return [Expressir::SchemaManifest] Combined schema manifest
-    def export_schema_config(path)
-      export_config = @schema_config || Expressir::SchemaManifest.new
-      return export_config unless entry
-
-      entry.each do |x|
-        child_config = x.export_schema_config(path)
-        # Use Expressir's concat method to combine schema manifests
-        export_config.concat(child_config) if child_config
-      end
-
-      export_config
-    end
-
-    def lookup_schemas_only
-      results = entry.select(&:schemas_only)
-      results << self if schemas_only
-      results
-    end
-
-    def process_entry(schema_output_path)
-      return [self] unless entry
-
-      ret = entry.each_with_object([]) do |e, m|
-        add = e.expand_schemas_only(schema_output_path)
-        m.concat(add)
-      end
-
-      self.entry = ret
-      [self]
-    end
-
-    def expand_schemas_only(schema_output_path)
-      return process_entry(schema_output_path) unless file
-
-      update_schema_config
-
-      return process_entry(schema_output_path) unless schemas_only
-
-      # If we are going to keep the schemas-only file and compile it, we can't
-      # have it showing up in output.
-      self.index = false
-
-      [self, added_collection_manifest(schema_output_path)]
-    end
-
-    def remove_schemas_only_sources
-      ret = entry.each_with_object([]) do |e, m|
-        e.schemas_only or m << e
-      end
-      self.entry = ret
-    end
-
-    def entries(schema_output_path)
-      @schema_config.schemas.map do |schema|
-        fname = [File.basename(schema.path, ".exp"), ".xml"].join
-
-        CollectionManifest.new(
-          identifier: schema.id,
-          title: schema.id,
-          file: File.join(schema_output_path, schema.id, "doc_#{fname}"),
-          # schema_source: schema.path
-        )
-      end
-    end
-
-    def added_collection_manifest(schema_output_path)
-      doc = CollectionConfig.from_file(file)
-      doc_id = doc.bibdata.id
-
-      # we need to separate this file from the following new entries
-      added = CollectionManifest.new(
-        title: "Collection",
-        type: "collection",
-        identifier: "#{identifier}_",
-      )
-
-      added.entry = [
-        CollectionManifest.new(
-          title: doc_id,
-          type: "document",
-          entry: entries(schema_output_path),
-        ),
-      ]
-
-      added
-    end
-
-    def update_schema_config
-      # If there is collection.yml, this is a document collection, we process
-      # schemas.yaml.
-      if File.basename(file) == "collection.yml"
-        schemas_yaml_path = File.join(File.dirname(file), "schemas.yaml")
-        if schemas_yaml_path && File.exist?(schemas_yaml_path)
-          @schema_config = Expressir::SchemaManifest.from_file(schemas_yaml_path)
-        end
-      end
-    end
   end
 end

data/lib/suma/eengine/wrapper.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "open3"
-require_relative "errors"
 
 module Suma
   module Eengine

data/lib/suma/eengine.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Suma
+  module Eengine
+    autoload :Errors,  "suma/eengine/errors"
+    autoload :Wrapper, "suma/eengine/wrapper"
+  end
+end

data/lib/suma/express_schema.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "utils"
 require "fileutils"
 require "expressir"
 

data/lib/suma/jsdai/figure.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "figure_xml"
-require_relative "figure_image"
-
 module Suma
   module Jsdai
     # Main class for JSDAI figure conversion

data/lib/suma/jsdai.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module Suma
   module Jsdai
+    autoload :Figure,      "suma/jsdai/figure"
+    autoload :FigureImage, "suma/jsdai/figure_image"
+    autoload :FigureXml,   "suma/jsdai/figure_xml"
   end
 end
-
-require_relative "jsdai/figure"

data/lib/suma/link_validator.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "schema_index"
 require "expressir"
 
 module Suma
-  LinkValidationResult = Struct.new(:file, :line, :link, :reason, keyword_init: true)
+  LinkValidationResult = Struct.new(:file, :line, :link, :reason,
+                                    keyword_init: true)
 
   class LinkValidator
     def initialize(index)
@@ -93,18 +93,22 @@ module Suma
 
       return unless parts.size > 2
 
-      error = validate_deep_path(schema, element, parts[2..], file, line_idx, link)
+      error = validate_deep_path(schema, element, parts[2..], file, line_idx,
+                                 link)
       unresolved << error if error
     end
 
-    def validate_deep_path(schema, element, path_parts, file, line_idx, full_link)
+    def validate_deep_path(schema, element, path_parts, file, line_idx,
+full_link)
       current = element
       current_path = "#{schema.id}.#{element.id}"
 
       path_parts.each do |part|
         case current
         when Expressir::Model::Declarations::Entity
-          attribute = current.attributes&.find { |a| a.id.downcase == part.downcase }
+          attribute = current.attributes&.find do |a|
+            a.id.downcase == part.downcase
+          end
 
           unless attribute
             return LinkValidationResult.new(
@@ -122,7 +126,9 @@ module Suma
           underlying = current.underlying_type
 
           if underlying.is_a?(Expressir::Model::DataTypes::Enumeration)
-            enum_value = underlying.items.find { |e| e.id.downcase == part.downcase }
+            enum_value = underlying.items.find do |e|
+              e.id.downcase == part.downcase
+            end
 
             unless enum_value
               return LinkValidationResult.new(
@@ -193,7 +199,9 @@ module Suma
         schema.procedures,
         schema.subtype_constraints,
       ].each do |collection|
-        element = collection&.find { |e| e.id.downcase == element_name.downcase }
+        element = collection&.find do |e|
+          e.id.downcase == element_name.downcase
+        end
         return element if element
       end
 

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,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "schema_collection"
-require_relative "utils"
-require_relative "collection_config"
-require_relative "site_config"
 require "metanorma"
 
 module Suma
@@ -41,11 +37,12 @@ module Suma
       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")
 
-      exported_schema_config = collection_config.manifest.export_schema_config(schemas_all_path)
-      exported_schema_config.path = schemas_all_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
@@ -72,7 +69,7 @@ module Suma
 
     def build_collection(collection_config, output_directory)
       new_collection_config_path = "collection-output.yaml"
-      collection_config.manifest.remove_schemas_only_sources
+      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)