suma 0.2.6 → 0.4.0

data/lib/suma/term_extractor.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "fileutils"
-require_relative "utils"
 require "expressir"
 require "glossarist"
 
@@ -16,13 +15,16 @@ module Suma
         \s*?\.?$               # Optional whitespace and period at the end
       }x
 
-    def initialize(schema_manifest_file, output_path, language_code: "eng")
+    def initialize(schema_manifest_file, output_path, urn:,
+                   language_code: "eng")
       @schema_manifest_file = File.expand_path(schema_manifest_file)
       @output_path = output_path
       @language_code = language_code
+      @urn = Suma::Urn.new(urn)
     end
 
     def call
+      validate_inputs
       get_exp_files.map do |exp_file|
         extract(exp_file)
       end
@@ -30,12 +32,24 @@ module Suma
 
     private
 
+    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
+
     def get_exp_files
       config = Expressir::SchemaManifest.from_file(@schema_manifest_file)
       paths = config.schemas.map(&:path)
 
       if paths.empty?
-        raise Errno::ENOENT, "No EXPRESS files found in `#{@schema_manifest_file}`."
+        raise Errno::ENOENT,
+              "No EXPRESS files found in `#{@schema_manifest_file}`."
       end
 
       paths
@@ -50,39 +64,64 @@ module Suma
 
       raise Error, "Schema must have an associated file" unless schema.file
 
-      collection = build_managed_concept_collection(schema)
+      classification = TermClassification.for_schema(id: schema.id,
+                                                      path: schema.file)
+      collection = build_managed_concept_collection(schema, classification)
       output_data(collection)
       collection
     end
 
     def output_data(collection)
-      FileUtils.mkdir_p(File.expand_path(@output_path)) unless File.exist?(@output_path)
+      output_dir = File.expand_path(@output_path)
+      FileUtils.mkdir_p(output_dir)
       Utils.log "Saving collection to files in: #{@output_path}"
-      collection.save_to_files(File.expand_path(@output_path))
+
+      collection.each do |concept|
+        doc = Glossarist::V3::ConceptDocument.from_managed_concept(concept)
+        doc.localizations = concept.data.localizations.keys.map do |lang|
+          concept.localization(lang)
+        end
+
+        filename = "#{concept.uuid.gsub(/[^\w.-]/, '_')}.yaml"
+        File.write(File.join(output_dir, filename), doc.to_yamls,
+                   encoding: "utf-8")
+      end
     end
 
-    def build_managed_concept_collection(schema)
+    def build_managed_concept_collection(schema, classification)
       source_ref = get_source_ref(schema)
+      section_ref = get_section_ref(schema)
 
       Glossarist::ManagedConceptCollection.new.tap do |collection|
         schema.entities.each do |entity|
+          localized_concept_id = Glossarist::Utilities::UUID.uuid_v5(
+            Glossarist::Utilities::UUID::OID_NAMESPACE,
+            "#{schema.id}.#{entity.id}-#{@language_code}",
+          )
+
           localized_concept = build_localized_concept(
             schema: schema,
             entity: entity,
             source_ref: source_ref,
+            uuid: localized_concept_id,
+            classification: classification,
           )
-          localized_concept_id = get_localized_concept_identifier(schema, entity)
 
-          managed_data = Glossarist::ManagedConceptData.new.tap do |data|
-            data.id = get_entity_identifier(schema, entity)
-            data.localizations[@language_code] = localized_concept
+          managed_data = Glossarist::V3::ManagedConceptData.new.tap do |data|
+            data.id = "#{schema.id}.#{entity.id}"
+            data.localizations.store(@language_code, localized_concept)
             data.localized_concepts = { @language_code => localized_concept_id }
+            data.domains = [section_ref] if section_ref
           end
 
-          managed_concept = Glossarist::ManagedConcept.new.tap do |concept|
-            concept.id = get_entity_identifier(schema, entity)
-            concept.uuid = concept.id
+          managed_concept = Glossarist::V3::ManagedConcept.new.tap do |concept|
+            concept.id = managed_data.id
+            concept.uuid = Glossarist::Utilities::UUID.uuid_v5(
+              Glossarist::Utilities::UUID::OID_NAMESPACE,
+              managed_data.id,
+            )
             concept.data = managed_data
+            concept.schema_version = "v3"
           end
 
           collection.store(managed_concept)
@@ -90,12 +129,13 @@ module Suma
       end
     end
 
-    def build_localized_concept(schema:, entity:, source_ref:)
-      schema_domain = get_domain(schema)
+    def build_localized_concept(schema:, entity:, source_ref:, uuid:,
+                                classification:)
+      schema_domain = classification.domain_for(schema.id)
 
-      localized_concept_data = Glossarist::ConceptData.new.tap do |data|
+      localized_concept_data = Glossarist::V3::ConceptData.new.tap do |data|
         data.terms = get_entity_terms(entity)
-        data.definition = get_entity_definitions(entity, schema)
+        data.definition = get_entity_definitions(entity, schema, classification)
         data.language_code = @language_code
         data.domain = schema_domain
         data.sources = [source_ref] if source_ref
@@ -105,49 +145,65 @@ module Suma
         data.examples = []
       end
 
-      Glossarist::LocalizedConcept.new.tap { |c| c.data = localized_concept_data }
+      Glossarist::V3::LocalizedConcept.new(
+        data: localized_concept_data, uuid: uuid,
+      )
+    end
+
+    def schema_urn(schema)
+      @urn.for_schema(schema.id)
+    end
+
+    def term_urn(concept_identifier)
+      @urn.for_term(concept_identifier)
     end
 
-    def get_entity_identifier(schema, entity)
-      "#{schema.id}.#{entity.id}"
+    def express_entity_urn(full_ref)
+      @urn.for_entity(full_ref)
     end
 
-    def get_localized_concept_identifier(schema, entity)
-      "#{schema.id}.#{entity.id}-#{@language_code}"
+    def urn_mention(urn, display)
+      "{{#{urn},#{display}}}"
+    end
+
+    def get_section_ref(schema)
+      return nil unless @urn
+
+      Glossarist::ConceptReference.new(
+        concept_id: "section-#{schema.id}",
+        source: schema_urn(schema),
+        ref_type: "section",
+      )
     end
 
     def get_source_ref(schema)
-      origin = Glossarist::Citation.new.tap do |citation|
-        citation.ref = "ISO 10303"
-        custom_locality = build_custom_locality(schema)
-        citation.custom_locality = custom_locality unless custom_locality.empty?
+      ref = Glossarist::Citation::Ref.new
+      ref.source = schema_urn(schema)
+
+      build_custom_locality(schema).each do |cl|
+        case cl.name
+        when "version" then ref.version = cl.value
+        end
       end
 
-      Glossarist::ConceptSource.new(type: "authoritative", origin: origin)
+      origin = Glossarist::V3::Citation.new
+      origin.ref = ref
+      Glossarist::V3::ConceptSource.new(id: schema.id, type: "authoritative",
+                                        origin: origin)
     end
 
     def build_custom_locality(schema)
       localities = []
-      localities << Glossarist::CustomLocality.new(name: "schema", value: schema.id)
 
       version_item = schema.version.items.detect { |i| i.name == "version" }
       if version_item
-        localities << Glossarist::CustomLocality.new(name: "version", value: version_item.value)
+        localities << Glossarist::CustomLocality.new(name: "version",
+                                                     value: version_item.value)
       end
 
       localities
     end
 
-    def get_domain(schema)
-      prefix = if schema.id.end_with?("_arm", "_mim")
-                 "application module"
-               else
-                 "resource"
-               end
-
-      "#{prefix}: #{schema.id}"
-    end
-
     def get_entity_terms(entity)
       [
         Glossarist::Designation::Base.new(
@@ -158,12 +214,9 @@ module Suma
       ]
     end
 
-    def get_entity_definitions(entity, schema)
-      schema_type = extract_file_type(schema.file)
-      schema_domain = get_domain(schema)
-
-      definition = generate_entity_definition(entity, schema_domain, schema_type)
-      [Glossarist::DetailedDefinition.new(content: definition)]
+    def get_entity_definitions(entity, schema, classification)
+      definition = generate_entity_definition(entity, schema, classification)
+      [Glossarist::V3::DetailedDefinition.new(content: definition)]
     end
 
     def get_entity_notes(entity, schema_domain, definitions)
@@ -172,7 +225,7 @@ module Suma
       if entity.remarks && !entity.remarks.empty?
         trimmed_def = trim_definition(entity.remarks)
         if trimmed_def && !trimmed_def.empty?
-          notes << Glossarist::DetailedDefinition.new(
+          notes << Glossarist::V3::DetailedDefinition.new(
             content: convert_express_xref(trimmed_def, schema_domain),
           )
         end
@@ -246,17 +299,6 @@ module Suma
       end
     end
 
-    def extract_file_type(filename)
-      match = filename.match(/(arm|mim|bom)_annotated\.exp$/)
-      return "resource" unless match
-
-      {
-        "arm" => "module_arm",
-        "mim" => "module_mim",
-        "bom" => "business_object_model",
-      }[match.captures[0]] || "resource"
-    end
-
     def starts_with_list?(content)
       return false if content.nil? || content.empty?
 
@@ -343,11 +385,14 @@ module Suma
 
     def express_reference_to_mention(description)
       description
-        .gsub(/<<express:([^,]+)>>/) do |_match|
-          "{{#{Regexp.last_match[1].split('.').last}}}"
-        end.gsub(/<<express:([^,]+),([^>]+)>>/) do |_match|
-          "{{#{Regexp.last_match[1].split('.').last}," \
-            "#{Regexp.last_match[2]}}}"
+        .gsub(/<<express:([\w.]+)>>/) do |_match|
+          full_ref = Regexp.last_match[1]
+          entity_id = full_ref.split(".").last
+          urn_mention(express_entity_urn(full_ref), entity_id)
+        end.gsub(/<<express:([\w.]+),([\w. ][\w. ]*)>>/) do |_match|
+          full_ref = Regexp.last_match[1]
+          display = Regexp.last_match(2)
+          urn_mention(express_entity_urn(full_ref), display)
         end
     end
 
@@ -355,38 +400,37 @@ module Suma
       entity_id.downcase.gsub("_", " ")
     end
 
-    def generate_entity_definition(entity, _domain, schema_type)
+    def generate_entity_definition(entity, schema, classification)
       return "" if entity.nil?
 
-      entity_type = case schema_type
-                    when "module_arm"
-                      "{{application object}}"
-                    when "module_mim"
-                      "{{entity data type}}"
-                    when "resource", "business_object_model"
-                      "{{entity data type}}"
-                    else
-                      raise Error, "[suma] encountered unsupported schema_type"
-                    end
+      entity_type = urn_mention(
+        term_urn(classification.entity_term),
+        classification.entity_display,
+      )
+
+      entity_ref = urn_mention(term_urn("express-language.entity"), "entity")
 
       if entity.subtype_of.empty?
         "#{entity_type} " \
           "that represents the " \
-          "#{entity_name_to_text(entity.id)} {{entity}}"
+          "#{entity_name_to_text(entity.id)} #{entity_ref}"
       else
-        entity_subtypes = entity.subtype_of.map { |e| "{{#{e.id}}}" }
+        entity_subtypes = entity.subtype_of.map do |e|
+          urn_mention(express_entity_urn("#{schema.id}.#{e.id}"), e.id)
+        end
 
         "#{entity_type} that is a type of " \
           "#{entity_subtypes.join(' and ')} " \
           "that represents the " \
-          "#{entity_name_to_text(entity.id)} {{entity}}"
+          "#{entity_name_to_text(entity.id)} #{entity_ref}"
       end
     end
 
-    def convert_express_xref(content, schema_domain)
-      content.gsub(/<<express:(.*),(.*)>>/) do
-        "{{<#{schema_domain}>" \
-          "#{Regexp.last_match(1).split('.').last},#{Regexp.last_match(2)}}}"
+    def convert_express_xref(content, _schema_domain)
+      content.gsub(/<<express:([\w.]+),([\w. ][\w. ]*)>>/) do
+        full_ref = Regexp.last_match(1)
+        display = Regexp.last_match(2)
+        urn_mention(express_entity_urn(full_ref), display)
       end
     end
   end

data/lib/suma/urn.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Suma
+  # Value object encapsulating URN semantics for ISO 10303 datasets.
+  #
+  # Normalises a URN prefix (stripping any trailing wildcard `:*`) and
+  # provides factory methods for composing leaf URNs:
+  #
+  # - `#for_schema(id)`   → `<base>:tech:<id>`
+  # - `#for_term(id)`     → `<base>:term:<id>`
+  # - `#for_entity(ref)`  → `<base>:tech:<ref>`
+  #
+  # The wildcard form is preserved via `#wildcard` and `#aliases` so callers
+  # can populate `urnAliases` in register.yaml without re-implementing the
+  # normalisation logic.
+  class Urn
+    WILDCARD_SUFFIX = ":*"
+    TECH_COMPONENT = "tech"
+    TERM_COMPONENT = "term"
+
+    attr_reader :base
+
+    def initialize(raw)
+      @base = strip_wildcard(raw.to_s)
+    end
+
+    def to_s
+      base
+    end
+
+    def wildcard
+      "#{base}#{WILDCARD_SUFFIX}"
+    end
+
+    def aliases
+      [wildcard]
+    end
+
+    def for_schema(schema_id)
+      compose(TECH_COMPONENT, schema_id)
+    end
+
+    def for_term(concept_identifier)
+      compose(TERM_COMPONENT, concept_identifier)
+    end
+
+    def for_entity(full_ref)
+      compose(TECH_COMPONENT, full_ref)
+    end
+
+    private
+
+    def strip_wildcard(value)
+      value.sub(/#{Regexp.escape(WILDCARD_SUFFIX)}\z/o, "")
+    end
+
+    def compose(component, identifier)
+      "#{base}:#{component}:#{identifier}"
+    end
+  end
+end

data/lib/suma/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Suma
-  VERSION = "0.2.6"
+  VERSION = "0.4.0"
 end

data/lib/suma.rb

@@ -2,11 +2,43 @@
 
 require "expressir"
 require "lutaml/model"
-
-require_relative "suma/version"
-require_relative "suma/processor"
+require "fileutils"
 
 module Suma
+  autoload :VERSION, "suma/version"
+
+  autoload :Processor,              "suma/processor"
+  autoload :CollectionConfig,       "suma/collection_config"
+  autoload :CollectionManifest,     "suma/collection_manifest"
+  autoload :EengineConverter,       "suma/eengine_converter"
+  autoload :ExpressReformatter,     "suma/express_reformatter"
+  autoload :ExpressSchema,          "suma/express_schema"
+  autoload :LinkValidation,         "suma/link_validation"
+  autoload :LinkValidator,          "suma/link_validator"
+  autoload :ManifestTraverser,      "suma/manifest_traverser"
+  autoload :RegisterManifestGenerator, "suma/register_manifest_generator"
+  autoload :SchemaCategory,         "suma/schema_category"
+  autoload :SchemaCollection,       "suma/schema_collection"
+  autoload :SchemaComparer,         "suma/schema_comparer"
+  autoload :SchemaCompiler,         "suma/schema_compiler"
+  autoload :SchemaDiscovery,        "suma/schema_discovery"
+  autoload :SchemaExporter,         "suma/schema_exporter"
+  autoload :SchemaIndex,            "suma/schema_index"
+  autoload :SchemaManifestGenerator, "suma/schema_manifest_generator"
+  autoload :SchemaNaming,           "suma/schema_naming"
+  autoload :SchemaTemplate,         "suma/schema_template"
+  autoload :SiteConfig,             "suma/site_config"
+  autoload :SvgQuality,             "suma/svg_quality"
+  autoload :TermClassification,     "suma/term_classification"
+  autoload :TermExtractor,          "suma/term_extractor"
+  autoload :ThorExt,                "suma/thor_ext"
+  autoload :Urn,                    "suma/urn"
+  autoload :Utils,                  "suma/utils"
+
+  autoload :Cli, "suma/cli"
+  autoload :Eengine, "suma/eengine"
+  autoload :Jsdai, "suma/jsdai"
+
   class Error < StandardError; end
   class SchemaNotFoundError < Error; end
   class CompilationError < Error; end

data/suma.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
   spec.require_paths = ["lib"]
 
   spec.add_dependency "expressir", ">= 2.1.29", "~> 2.1"
-  spec.add_dependency "glossarist", "~> 2.4"
+  spec.add_dependency "glossarist", "~> 2.8", ">= 2.8.7"
   spec.add_dependency "lutaml-model", "~> 0.8.0"
   spec.add_dependency "metanorma", "~> 2.3"
   spec.add_dependency "plurimath"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: suma
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.4.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-12 00:00:00.000000000 Z
+date: 2026-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: expressir
@@ -36,14 +36,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '2.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '2.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.7
 - !ruby/object:Gem::Dependency
   name: lutaml-model
   requirement: !ruby/object:Gem::Requirement
@@ -186,40 +192,56 @@ files:
 - lib/suma/cli/check_svg_quality.rb
 - lib/suma/cli/compare.rb
 - lib/suma/cli/convert_jsdai.rb
+- lib/suma/cli/core.rb
 - lib/suma/cli/export.rb
 - lib/suma/cli/extract_terms.rb
+- lib/suma/cli/generate_register.rb
 - lib/suma/cli/generate_schemas.rb
 - lib/suma/cli/reformat.rb
 - lib/suma/cli/validate.rb
 - lib/suma/cli/validate_links.rb
 - lib/suma/collection_config.rb
 - lib/suma/collection_manifest.rb
+- lib/suma/eengine.rb
 - lib/suma/eengine/errors.rb
 - lib/suma/eengine/wrapper.rb
 - lib/suma/eengine_converter.rb
+- lib/suma/express_reformatter.rb
 - lib/suma/express_schema.rb
 - lib/suma/jsdai.rb
 - lib/suma/jsdai/figure.rb
 - lib/suma/jsdai/figure_image.rb
 - lib/suma/jsdai/figure_xml.rb
+- lib/suma/link_validation.rb
 - lib/suma/link_validator.rb
+- lib/suma/manifest_traverser.rb
 - lib/suma/processor.rb
-- lib/suma/schema_attachment.rb
+- lib/suma/register_manifest_generator.rb
+- lib/suma/schema_category.rb
 - lib/suma/schema_collection.rb
 - lib/suma/schema_comparer.rb
-- lib/suma/schema_document.rb
+- lib/suma/schema_compiler.rb
+- lib/suma/schema_discovery.rb
 - lib/suma/schema_exporter.rb
 - lib/suma/schema_index.rb
 - lib/suma/schema_manifest_generator.rb
+- lib/suma/schema_naming.rb
+- lib/suma/schema_template.rb
+- lib/suma/schema_template/document.rb
+- lib/suma/schema_template/plain.rb
 - lib/suma/site_config.rb
 - lib/suma/svg_quality.rb
 - lib/suma/svg_quality/batch_report.rb
+- lib/suma/svg_quality/formatters.rb
 - lib/suma/svg_quality/formatters/json_formatter.rb
 - lib/suma/svg_quality/formatters/terminal_formatter.rb
 - lib/suma/svg_quality/formatters/yaml_formatter.rb
 - lib/suma/svg_quality/report.rb
+- lib/suma/svg_quality/scanner.rb
+- lib/suma/term_classification.rb
 - lib/suma/term_extractor.rb
 - lib/suma/thor_ext.rb
+- lib/suma/urn.rb
 - lib/suma/utils.rb
 - lib/suma/version.rb
 - sig/suma.rbs

data/lib/suma/schema_attachment.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "expressir"
-
-module Suma
-  class SchemaAttachment
-    attr_accessor :schema, :output_path, :config, :id
-
-    def initialize(schema:, output_path:)
-      @schema = schema
-      @id = schema.id
-      @output_path = output_path
-    end
-
-    def output_extensions
-      "xml,html"
-    end
-
-    def to_adoc(path_to_schema_yaml)
-      <<~HEREDOC
-        = #{@id}
-        :lutaml-express-index: schemas; #{path_to_schema_yaml};
-        :bare: true
-        :mn-document-class: iso
-        :mn-output-extensions: #{output_extensions}
-
-        [lutaml_express_liquid,schemas,context]
-        ----
-        {% for schema in context.schemas %}
-
-        [%unnumbered]
-        == #{@id}
-
-        [source%unnumbered]
-        --
-        {{ schema.formatted }}
-        --
-        {% endfor %}
-        ----
-
-      HEREDOC
-    end
-
-    def filename_adoc(ext = "adoc")
-      File.join(@output_path, "doc_#{@schema.id}.#{ext}")
-    end
-
-    def save_adoc
-      relative_path = Pathname.new(filename_adoc).relative_path_from(Dir.pwd)
-      Utils.log "Save EXPRESS adoc: #{relative_path}"
-
-      FileUtils.mkdir_p(File.dirname(filename_adoc))
-
-      config_relative = Pathname.new(filename_config)
-        .relative_path_from(Pathname.new(File.dirname(filename_adoc)))
-
-      File.write(filename_adoc, to_adoc(config_relative))
-    end
-
-    def filename_config
-      File.join(@output_path, "schema_#{@schema.id}.yaml")
-    end
-
-    def to_config(path: nil)
-      @config = Expressir::SchemaManifest.new
-      @config.schemas << Expressir::SchemaManifestEntry.new(
-        id: @schema.id,
-        path: @schema.path,
-      )
-      path and @config.path = path
-
-      @config
-    end
-
-    def save_config
-      relative_path = Pathname.new(filename_config).relative_path_from(Dir.pwd)
-      Utils.log "Save schema config: #{relative_path}"
-
-      FileUtils.mkdir_p(File.dirname(filename_config))
-
-      to_config.save_to_path(filename_config)
-    end
-
-    # Compile Metanorma adoc per EXPRESS schema
-    def compile
-      save_config
-      save_adoc
-
-      relative_path = Pathname.new(filename_adoc).relative_path_from(Dir.pwd)
-      Utils.log "Compiling schema (id: #{id}, type: #{self.class}) => #{relative_path}"
-      Metanorma::Compile.new.compile(filename_adoc, agree_to_terms: true,
-                                                    install_fonts: false)
-      Utils.log "Compiling schema (id: #{id}, type: #{self.class}) => #{relative_path}... done!"
-
-      self
-    end
-
-    def output_xml_path
-      filename_adoc("xml")
-    end
-  end
-end