suma 0.5.7 → 0.5.9

data/lib/suma/schema_exporter.rb

@@ -42,11 +42,14 @@ module Suma
         annotations: false,
         create_zip: false,
         structure: :preserve,
+        jobs: 1,
       }
     end
 
     def export_to_directory(schemas)
-      schemas.each { |schema| export_single_schema(schema) }
+      WorkerPool.new(size: options[:jobs]).map(schemas) do |schema|
+        export_single_schema(schema)
+      end
     end
 
     # Reuse cached plain/annotated output when the schema source is unchanged,
@@ -77,10 +80,7 @@ module Suma
     # (via the +:cache_dir+ option or the SUMA_SCHEMA_CACHE_DIR environment
     # variable), otherwise a null cache (caching disabled).
     def build_cache
-      directory = options[:cache_dir] || ENV.fetch("SUMA_SCHEMA_CACHE_DIR", nil)
-      return NullCache.new if directory.nil? || directory.empty?
-
-      SchemaCache.new(directory)
+      SchemaCache.build(options)
     end
 
     # rubocop:disable-next Metrics/MethodLength

data/lib/suma/schema_naming.rb

@@ -3,9 +3,12 @@
 module Suma
   # Converts EXPRESS schema identifiers into human-readable display names.
   #
-  # Naming is model-driven: the schema type (resource/module) and suffix
-  # determine how the identifier is formatted. Acronyms and numeric
-  # prefixes are preserved to match ISO 10303 conventions.
+  # Naming is profile-driven: the profile declares the suffixes
+  # stripped from the identifier (with their parenthesised labels) and
+  # the acronyms preserved during title-casing. The ISO 10303 profile
+  # reproduces the historical behavior — ARM/MIM/BOM labels and the ISO
+  # acronym set; the generic profile strips nothing and applies plain
+  # title-casing.
   #
   # @example
   #   SchemaNaming.display_name("topology_schema")
@@ -15,34 +18,19 @@ module Suma
   #   SchemaNaming.display_name("aic_advanced_brep")
   #   # => "AIC Advanced Brep"
   module SchemaNaming
-    # Acronyms preserved as uppercase during title-casing.
-    # Source: ISO 10303 naming conventions.
-    ACRONYMS = %w[
-      aic aec apu bom csg edraw id ifc pdf pld
-      xml xpdl 2d 3d
-    ].freeze
-
     # Lowercase function words (ISO title-case convention).
     LOWERCASE_WORDS = %w[a an and as for in of on or the to].freeze
 
-    # Suffixes stripped from the schema name before title-casing,
-    # mapped to the parenthesised label appended to the display name.
-    # A +nil+ label means the suffix is stripped silently.
-    SUFFIXES = {
-      "_arm" => "ARM",
-      "_mim" => "MIM",
-      "_bom" => "BOM",
-      "_schema" => nil,
-    }.freeze
-
     class << self
       # Produce a human-readable display name from a schema identifier.
       #
       # @param schema_id [String] the EXPRESS schema identifier
+      # @param profile [SchemaProfile, Symbol, String, nil] schema profile
       # @return [String] human-readable name
-      def display_name(schema_id)
-        base, label = decompose(schema_id)
-        title_cased = title_case(base)
+      def display_name(schema_id, profile: nil)
+        profile_obj = SchemaProfile.fetch(profile)
+        base, label = decompose(schema_id, profile_obj.suffix_labels)
+        title_cased = title_case(base, profile_obj)
         label ? "#{title_cased} (#{label})" : title_cased
       end
 
@@ -50,11 +38,13 @@ module Suma
       #
       # @param schema_id [String] the EXPRESS schema identifier
       # @param path [String, Pathname] the schema file path (for classification)
+      # @param profile [SchemaProfile, Symbol, String, nil] schema profile
       # @return [String] e.g. "Resource: Topology" or "Module: Activity (ARM)"
-      def prefixed_name(schema_id, path: nil)
-        type = ExpressSchema::Type.classify(id: schema_id, path: path)
+      def prefixed_name(schema_id, path: nil, profile: nil)
+        type = ExpressSchema::Type.classify(id: schema_id, path: path,
+                                            profile: profile)
         prefix = category_prefix(type)
-        "#{prefix}: #{display_name(schema_id)}"
+        "#{prefix}: #{display_name(schema_id, profile: profile)}"
       end
 
       # Determine the category prefix for a schema type.
@@ -69,9 +59,11 @@ module Suma
 
       # Split a schema ID into (base_without_suffix, suffix_label_or_nil).
       #
+      # @param schema_id [String]
+      # @param suffix_labels [Hash{String => String, nil}]
       # @return [(String, String, nil)]
-      def decompose(schema_id)
-        SUFFIXES.each do |suffix, label|
+      def decompose(schema_id, suffix_labels)
+        suffix_labels.each do |suffix, label|
           if schema_id.end_with?(suffix)
             return [schema_id.delete_suffix(suffix),
                     label]
@@ -86,11 +78,12 @@ module Suma
       # separator.
       #
       # @param name [String] snake_case identifier
+      # @param acronyms [Array<String>] lowercased words kept uppercase
       # @return [String] title-cased name
-      def title_case(name)
+      def title_case(name, profile_obj)
         words = name.tr("_", " ").split
         words.each_with_index.map do |word, i|
-          capitalize_word(word, first: i.zero?)
+          capitalize_word(word, profile_obj: profile_obj, first: i.zero?)
         end.join(" ")
       end
 
@@ -98,11 +91,14 @@ module Suma
       # lowercasing function words (except when first in the name).
       #
       # @param word [String]
+      # @param acronyms [Array<String>]
       # @param first [Boolean] whether this is the first word
       # @return [String]
-      def capitalize_word(word, first: false)
-        return word.upcase if ACRONYMS.include?(word.downcase)
-        return word.downcase if LOWERCASE_WORDS.include?(word.downcase) && !first
+      def capitalize_word(word, profile_obj:, first: false)
+        lower = word.downcase
+        return word.upcase if profile_obj.acronyms.include?(lower)
+        return word.upcase if profile_obj.acronym_patterns.any? { |re| re.match?(lower) }
+        return word.downcase if LOWERCASE_WORDS.include?(lower) && !first
 
         word.capitalize
       end

data/lib/suma/schema_profile.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Suma
+  # Declares how a schema collection maps schema identifiers and paths
+  # to schema types, and how identifiers become display names.
+  #
+  # Suma works with any schema collection: ISO 10303 conventions (the
+  # `_arm`/`_mim` suffixes, the `resources/`+`modules/` directory tree,
+  # the ARM/MIM display labels) are one profile among many, not
+  # hardcoded behavior. A new collection's conventions are a new profile
+  # declaration — no changes to classification, naming, categories, or
+  # term extraction.
+  #
+  # Rules are ordered: the first matching rule classifies the schema.
+  # In the ISO 10303 profile the `/applications/` path rule precedes the
+  # suffix rules so an AP publication's `_arm`/`_mim` schemas classify as
+  # application protocols, while the same suffixes under `modules/`
+  # classify as before.
+  #
+  # @example
+  #   SchemaProfile.fetch("iso10303").classify(
+  #     id: "ap242_foo_mim", path: "applications/ap242/foo.exp"
+  #   ) # => :application_protocol
+  #   SchemaProfile.fetch("generic").classify(id: "x", path: "y.exp")
+  #   # => :standalone
+  class SchemaProfile
+    # A single classification rule: +kind+ is :suffix (matched against the
+    # lowercased schema identifier) or :path (matched against the schema
+    # file path); +pattern+ is the string to match; +type+ is the
+    # ExpressSchema::Type symbol the rule produces.
+    Rule = Struct.new(:kind, :pattern, :type) do
+      def match(schema_id, schema_path)
+        case kind
+        when :suffix
+          schema_id&.downcase&.end_with?(pattern)
+        when :path
+          schema_path.to_s.include?(pattern)
+        end
+      end
+    end
+
+    attr_reader :id, :rules, :suffix_labels, :acronyms,
+                :acronym_patterns, :category_ids
+
+    # (a data-declaring initializer; six keywords by design)
+    def initialize(id:, rules: [], suffix_labels: {}, acronyms: [], # rubocop:disable Metrics/ParameterLists
+                   acronym_patterns: [], category_ids: %w[other])
+      @id = id
+      @rules = rules.freeze
+      @suffix_labels = suffix_labels.freeze
+      @acronyms = acronyms.freeze
+      @acronym_patterns = acronym_patterns.freeze
+      @category_ids = category_ids.freeze
+      freeze
+    end
+
+    # Classify a schema under this profile.
+    #
+    # @param id [String, nil] schema identifier
+    # @param path [String, Pathname, nil] schema file path
+    # @return [Symbol] an ExpressSchema::Type value; +:standalone+ when no
+    #   rule matches
+    def classify(id:, path:)
+      rules.each do |rule|
+        return rule.type if rule.match(id, path)
+      end
+      ExpressSchema::Type::STANDALONE
+    end
+
+    # The default (ISO 10303) profile.
+    #
+    # @return [SchemaProfile]
+    def self.default
+      fetch("iso10303")
+    end
+
+    # Look up a registered profile by id; +nil+ yields the default.
+    #
+    # @param id [String, Symbol, SchemaProfile, nil]
+    # @return [SchemaProfile]
+    # @raise [Suma::Error] on an unknown profile id
+    def self.fetch(id)
+      return id if id.is_a?(SchemaProfile)
+      return default if id.nil?
+
+      REGISTRY.fetch(id.to_s) do
+        raise Error, "[suma] unknown schema profile #{id.inspect} " \
+                     "(registered: #{REGISTRY.keys.sort.join(', ')})"
+      end
+    end
+
+    ISO_10303 = new(
+      id: "iso10303",
+      rules: [
+        Rule.new(:path, "/applications/", :application_protocol),
+        Rule.new(:suffix, "_arm", :module_arm),
+        Rule.new(:suffix, "_mim", :module_mim),
+        Rule.new(:suffix, "_bom", :business_object_model),
+        Rule.new(:path, "/resources/", :resource),
+        Rule.new(:path, "/modules/", :module_arm),
+        Rule.new(:path, "/core_model/", :core_model),
+      ],
+      suffix_labels: {
+        "_arm" => "ARM",
+        "_mim" => "MIM",
+        "_bom" => "BOM",
+        "_schema" => nil,
+      },
+      acronyms: %w[
+        aic aec ap apu bom csg edraw id ifc pdf pld
+        xml xpdl 2d 3d
+      ],
+      # AP publications glue the number to the prefix: ap203, ap242, ...
+      acronym_patterns: [/\Aap\d+\z/],
+      category_ids: %w[
+        resources application_protocols modules
+        business_object_models core_model other
+      ],
+    )
+
+    GENERIC = new(
+      id: "generic",
+      rules: [],
+      suffix_labels: {},
+      acronyms: [],
+      category_ids: %w[other],
+    )
+
+    REGISTRY = {
+      "iso10303" => ISO_10303,
+      "generic" => GENERIC,
+    }.freeze
+  end
+end

data/lib/suma/term_classification.rb

@@ -36,6 +36,12 @@ module Suma
         entity_term: "express-language.entity_data_type",
         entity_display: "entity data type",
       ),
+      ExpressSchema::Type::APPLICATION_PROTOCOL => new(
+        type: ExpressSchema::Type::APPLICATION_PROTOCOL,
+        domain_label: "application protocol",
+        entity_term: "express-language.entity_data_type",
+        entity_display: "entity data type",
+      ),
       ExpressSchema::Type::MODULE_ARM => new(
         type: ExpressSchema::Type::MODULE_ARM,
         domain_label: "application module",
@@ -68,8 +74,9 @@ module Suma
       ),
     }.freeze
 
-    def self.for_schema(id:, path:)
-      type = ExpressSchema::Type.classify(id: id, path: path)
+    def self.for_schema(id:, path:, profile: nil)
+      type = ExpressSchema::Type.classify(id: id, path: path,
+                                          profile: profile)
       BY_TYPE.fetch(type) do |t|
         raise Error, "[suma] no term classification for type #{t.inspect}"
       end

data/lib/suma/term_extractor.rb

@@ -7,11 +7,15 @@ require "glossarist"
 module Suma
   class TermExtractor
     def initialize(schema_manifest_file, output_path, urn:,
-                   language_code: "eng")
+                   language_code: "eng", profile: nil, edition: nil,
+                   language_codes: nil)
       @schema_manifest_file = File.expand_path(schema_manifest_file)
       @output_path = output_path
       @language_code = language_code
+      @language_codes = normalize_languages(language_code, language_codes)
       @urn = Suma::Urn.new(urn)
+      @profile = SchemaProfile.fetch(profile)
+      @edition = edition
     end
 
     def call
@@ -23,6 +27,12 @@ module Suma
 
     private
 
+    # The primary language is always first; additional languages produce
+    # linked localizations of the same managed concept.
+    def normalize_languages(primary, extra)
+      ([primary] + Array(extra).map(&:to_s)).map(&:to_s).uniq
+    end
+
     def validate_inputs
       unless File.exist?(@schema_manifest_file)
         raise Errno::ENOENT, "Specified SCHEMA_MANIFEST_FILE " \
@@ -56,7 +66,8 @@ module Suma
       raise Error, "Schema must have an associated file" unless schema.file
 
       classification = TermClassification.for_schema(id: schema.id,
-                                                      path: schema.file)
+                                                      path: schema.file,
+                                                      profile: @profile)
       collection = build_managed_concept_collection(schema, classification)
       output_data(collection)
       collection
@@ -80,30 +91,12 @@ module Suma
     end
 
     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,
-          )
-
-          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_data = build_managed_data(schema, entity, section_ref,
+                                            classification)
 
           managed_concept = Glossarist::V3::ManagedConcept.new.tap do |concept|
             concept.id = managed_data.id
@@ -120,16 +113,45 @@ module Suma
       end
     end
 
-    def build_localized_concept(schema:, entity:, source_ref:, uuid:,
+    def build_managed_data(schema, entity, section_ref, classification)
+      Glossarist::V3::ManagedConceptData.new.tap do |data|
+        data.id = "#{schema.id}.#{entity.id}"
+        data.localized_concepts = {}
+
+        @language_codes.each do |language|
+          localized_id = localized_concept_id(schema, entity, language)
+          localized = build_localized_concept(
+            schema: schema,
+            entity: entity,
+            language: language,
+            uuid: localized_id,
+            classification: classification,
+          )
+          data.localizations.store(language, localized)
+          data.localized_concepts[language] = localized_id
+        end
+
+        data.domains = [section_ref] if section_ref
+      end
+    end
+
+    def localized_concept_id(schema, entity, language)
+      Glossarist::Utilities::UUID.uuid_v5(
+        Glossarist::Utilities::UUID::OID_NAMESPACE,
+        "#{schema.id}.#{entity.id}-#{language}",
+      )
+    end
+
+    def build_localized_concept(schema:, entity:, language:, uuid:,
                                 classification:)
       schema_domain = classification.domain_for(schema.id)
 
       localized_concept_data = Glossarist::V3::ConceptData.new.tap do |data|
         data.terms = get_entity_terms(entity)
         data.definition = get_entity_definitions(entity, schema, classification)
-        data.language_code = @language_code
+        data.language_code = language
         data.domain = schema_domain
-        data.sources = [source_ref] if source_ref
+        data.sources = [build_source_ref(schema, entity)]
 
         notes = NoteProcessor.call(
           entity.remarks,
@@ -175,26 +197,45 @@ module Suma
       )
     end
 
-    def get_source_ref(schema)
+    # Provenance: the schema is the authoritative source, the entity URN is
+    # what the concept is about, and the edition/version identifies the
+    # owning release.
+    def build_source_ref(schema, entity)
       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
+      ref.version = edition_label(schema)
 
       origin = Glossarist::V3::Citation.new
       origin.ref = ref
-      Glossarist::V3::ConceptSource.new(id: schema.id, type: "authoritative",
-                                        origin: origin)
+      Glossarist::V3::ConceptSource.new(
+        id: schema.id,
+        type: "authoritative",
+        origin: origin,
+        sourced_from: [entity_citation(schema, entity)],
+      )
+    end
+
+    def entity_citation(schema, entity)
+      ref = Glossarist::Citation::Ref.new
+      ref.source = express_entity_urn("#{schema.id}.#{entity.id}")
+      ref.version = edition_label(schema)
+
+      Glossarist::V3::Citation.new.tap { |citation| citation.ref = ref }
+    end
+
+    def edition_label(schema)
+      return @edition.to_s if @edition
+
+      build_custom_locality(schema)
+        .find { |locality| locality.name == "version" }&.value
     end
 
     def build_custom_locality(schema)
       localities = []
 
-      version_item = schema.version.items.detect { |i| i.name == "version" }
+      version_item = Array(schema.version&.items).detect do |item|
+        item.name == "version"
+      end
       if version_item
         localities << Glossarist::CustomLocality.new(name: "version",
                                                      value: version_item.value)