glossarist 2.6.4 → 2.6.6

data/lib/glossarist/gcr_validator.rb

@@ -4,7 +4,7 @@ require "zip"
 
 module Glossarist
   class GcrValidator
-    def validate(zip_path) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def validate(zip_path)
       result = ValidationResult.new
 
       unless File.exist?(zip_path)
@@ -13,123 +13,48 @@ module Glossarist
       end
 
       begin
-        Zip::File.open(zip_path) do |zip_file|
-          validate_zip_contents(zip_file, result)
-        end
+        zip_entries = Zip::File.open(zip_path) { |zf| zf.entries.to_set(&:name) }
       rescue StandardError => e
         result.add_error("Failed to read ZIP: #{e.message}")
+        return result
       end
 
-      result
-    end
-
-    private
-
-    def validate_zip_contents(zip_file, result) # rubocop:disable Metrics/AbcSize
-      unless zip_file.find_entry("metadata.yaml")
+      unless zip_entries.include?("metadata.yaml")
         result.add_error("Missing metadata.yaml")
-        return
-      end
-
-      metadata = GcrMetadata.from_yaml(
-        zip_file.find_entry("metadata.yaml").get_input_stream.read,
-      )
-      validate_metadata(metadata, result)
-
-      concept_entries = zip_file.entries.select do |e|
-        e.name.start_with?("concepts/") && e.name.end_with?(".yaml")
-      end
-      if concept_entries.empty?
-        result.add_error("No concept files found in concepts/")
-      end
-
-      concept_entries.each do |entry|
-        validate_concept_entry(entry, metadata, result)
-      end
-
-      validate_assets(zip_file, result)
-    end
-
-    def validate_metadata(metadata, result)
-      unless metadata&.concept_count
-        result.add_error("metadata.yaml missing required fields (concept_count)")
-      end
-
-      unless metadata&.shortname
-        result.add_error("metadata.yaml missing shortname")
+        return result
       end
 
-      unless metadata&.version
-        result.add_error("metadata.yaml missing version")
+      begin
+        context = Validation::Rules::GcrContext.new(zip_path)
+      rescue StandardError => e
+        result.add_error("Failed to load GCR: #{e.message}")
+        return result
       end
-    end
 
-    def validate_concept_entry(entry, metadata, result) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      raw = entry.get_input_stream.read
-      doc = ConceptDocument.from_yamls(raw)
-    rescue Psych::SyntaxError => e
-      result.add_error("#{entry.name}: invalid YAML at line #{e.line}: #{e.message}")
-    rescue StandardError => e
-      result.add_error("#{entry.name}: parse error: #{e.message}")
-    else
-      concept = doc.concept
-      unless concept&.data&.id
-        result.add_error("#{entry.name}: document 0 missing data.identifier")
-      end
+      # Collection-level rules (metadata, structure, integrity)
+      collection_rules = Validation::Rules::Registry.for_scope(:collection)
+      collection_rules.each do |rule|
+        next unless rule.applicable?(context)
 
-      localizations = doc.localizations
-      if localizations.empty?
-        result.add_error("#{entry.name}: expected at least 1 localization document")
-      else
-        localizations.each_with_index do |l10n, idx|
-          unless l10n&.language_code
-            result.add_error("#{entry.name}: document #{idx + 1} missing data.language_code")
-          end
-        end
+        rule.check(context).each { |i| result.add_issue(i) }
       end
 
-      validate_concept_uri(entry, concept, metadata, result)
-    end
-
-    def validate_concept_uri(entry, concept, metadata, result) # rubocop:disable Metrics/CyclomaticComplexity
-      concept_uri = concept&.data&.uri
-      template = metadata&.concept_uri_template
-      uri_prefix = metadata&.uri_prefix
+      # Per-concept rules
+      concept_rules = Validation::Rules::Registry.for_scope(:concept)
+      context.concepts.each_with_index do |concept, idx|
+        fname = concept.data&.id ? "concepts/#{concept.data.id}.yaml" : "concepts/concept-#{idx}.yaml"
+        concept_context = Validation::Rules::ConceptContext.new(
+          concept, file_name: fname, collection_context: context
+        )
 
-      if concept_uri.nil? && template.nil? && uri_prefix.nil?
-        result.add_warning("#{entry.name}: no concept URI (data.uri) and no concept_uri_template or uri_prefix in metadata")
-      end
-    end
+        concept_rules.each do |rule|
+          next unless rule.applicable?(concept_context)
 
-    def validate_assets(zip_file, result)
-      GcrPackage::DATASET_ASSETS.each do |asset|
-        case asset[:type]
-        when :file
-          validate_file_asset_entry(zip_file, asset[:path], result)
-        when :directory
-          validate_directory_asset(zip_file, asset[:path], result)
+          rule.check(concept_context).each { |i| result.add_issue(i) }
         end
       end
-    end
-
-    def validate_file_asset_entry(zip_file, path, result)
-      entry = zip_file.find_entry(path)
-      return unless entry
-
-      YAML.safe_load(entry.get_input_stream.read)
-    rescue Psych::SyntaxError => e
-      result.add_error("#{path}: invalid YAML at line #{e.line}: #{e.message}")
-    end
 
-    def validate_directory_asset(zip_file, dir_path, result)
-      dir_entries = zip_file.entries.select do |e|
-        e.name.start_with?("#{dir_path}/")
-      end
-      return unless dir_entries.any? && dir_entries.all? do |e|
-        e.name.end_with?("/")
-      end
-
-      result.add_warning("#{dir_path}/ directory is empty")
+      result
     end
   end
 end

data/lib/glossarist/glossary_definition.rb

@@ -28,5 +28,10 @@ module Glossarist
     CONCEPT_DATE_TYPES = config.dig("concept_date", "type").freeze
 
     CONCEPT_STATUSES = config.dig("concept", "status").freeze
+
+    DESIGNATION_RELATIONSHIP_TYPES = config.dig("designation",
+                                                 "relationship_type")&.freeze
+
+    ISO12620_TERM_TYPES = config.dig("iso12620", "term_type").freeze
   end
 end

data/lib/glossarist/managed_concept_data.rb

@@ -5,7 +5,7 @@ module Glossarist
     attribute :id, :string
     attribute :uri, :string
     attribute :localized_concepts, :hash
-    attribute :groups, :string, collection: true
+    attribute :domains, ConceptReference, collection: true
     attribute :sources, ConceptSource, collection: true
     attribute :localizations, LocalizedConcept,
               collection: Collections::LocalizationCollection,
@@ -16,7 +16,8 @@ module Glossarist
                              with: { to: :id_to_yaml, from: :id_from_yaml }
       map :uri, to: :uri
       map %i[localized_concepts localizedConcepts], to: :localized_concepts
-      map :groups, to: :groups
+      map %i[domains groups], to: :domains,
+                             with: { from: :domains_from_yaml, to: :domains_to_yaml }
       map :sources, to: :sources
       map :localizations, to: :localizations,
                           with: { from: :localizations_from_yaml, to: :localizations_to_yaml }
@@ -41,6 +42,24 @@ module Glossarist
 
     def localizations_to_yaml(model, doc); end
 
+    def domains_from_yaml(model, value)
+      return unless value.is_a?(Array)
+
+      model.domains = value.map do |item|
+        if item.is_a?(Hash)
+          ConceptReference.of_yaml(item)
+        else
+          ConceptReference.new(concept_id: item.to_s, ref_type: "domain")
+        end
+      end
+    end
+
+    def domains_to_yaml(model, doc)
+      return if model.domains.nil? || model.domains.empty?
+
+      doc["domains"] = model.domains.map(&:to_hash)
+    end
+
     def authoritative_source
       return [] unless sources
 

data/lib/glossarist/non_verb_rep.rb

@@ -1,14 +1,29 @@
+# frozen_string_literal: true
+
 module Glossarist
+  # A non-verbal representation used to help define a concept, following
+  # ISO 10241-1 §6.5.
+  #
+  # Non-verbal representations are associated resources (images, tables,
+  # formulas) that live outside the concept model. They are referenced by URI
+  # and can be shared across concepts. The resource belongs either to the
+  # dataset package (relative path) or is externally referenced (URL/URN).
+  #
+  # Each non-verbal representation specifies:
+  # - +type+: one of "image", "table", "formula"
+  # - +ref+: URI reference to the resource (relative path, URN, or URL)
+  # - +text+: optional text description or alt text
+  # - +sources+: bibliographic sources for the representation
   class NonVerbRep < Lutaml::Model::Serializable
-    attribute :image, :string
-    attribute :table, :string
-    attribute :formula, :string
+    attribute :type, :string
+    attribute :ref, :string
+    attribute :text, :string
     attribute :sources, ConceptSource, collection: true
 
     key_value do
-      map :image, to: :image
-      map :table, to: :table
-      map :formula, to: :formula
+      map :type, to: :type
+      map :ref, to: :ref
+      map :text, to: :text
       map :sources, to: :sources
     end
   end

data/lib/glossarist/pronunciation.rb

@@ -0,0 +1,32 @@
+module Glossarist
+  # A pronunciation or transcription of a designation, following ISO 24229
+  # spelling system conventions.
+  #
+  # Each pronunciation entry specifies the text of the pronunciation and the
+  # context in which it is expressed:
+  # - +language+ (ISO 639) identifies the language or dialect being pronounced
+  # - +script+ (ISO 15924) identifies the script used for the pronunciation text
+  # - +country+ (ISO 3166-1) identifies the country variant
+  # - +system+ identifies the transcription/romanization system used (ISO 24229
+  #   conversion system code or a simple identifier like "IPA")
+  #
+  # A designation can have multiple pronunciations, e.g.:
+  #   - IPA:       { content: "toːkjoː", script: "Latn", language: "jpn", system: "IPA" }
+  #   - Hepburn:   { content: "Tōkyō",   script: "Latn", language: "jpn", system: "Var:jpn-Hrkt:Latn:Hepburn-1886" }
+  #   - Cyrillic:  { content: "Токио",   script: "Cyrl", language: "rus", system: "polivanov" }
+  class Pronunciation < Lutaml::Model::Serializable
+    attribute :content, :string
+    attribute :language, :string
+    attribute :script, :string
+    attribute :country, :string
+    attribute :system, :string
+
+    key_value do
+      map :content, to: :content
+      map :language, to: :language
+      map :script, to: :script
+      map :country, to: :country
+      map :system, to: :system
+    end
+  end
+end

data/lib/glossarist/reference_extractor.rb

@@ -152,6 +152,63 @@ module Glossarist
 
     LANG_CODES = Glossarist::LANG_CODES
 
+    # Extract asset references from model attributes (NonVerbRep, GraphicalSymbol).
+    def extract_asset_refs_from_concept(concept)
+      refs = []
+
+      concept.localizations.each do |l10n|
+        Array(l10n.non_verb_rep).each do |nvr|
+          next unless nvr.is_a?(NonVerbRep) && nvr.ref && !nvr.ref.strip.empty?
+          refs << AssetReference.new(path: nvr.ref.strip)
+        end
+
+        (l10n.data&.terms || []).each do |term|
+          if term.is_a?(Designation::GraphicalSymbol) && term.image && !term.image.strip.empty?
+            refs << AssetReference.new(path: term.image.strip)
+          end
+        end
+      end
+
+      refs
+    end
+
+    # Extract bibliographic xrefs from model-level source citations.
+    def extract_bib_refs_from_concept(concept)
+      refs = []
+      concept.localizations.each do |l10n|
+        gather_all_sources(l10n).each do |source|
+          origin = source.origin
+          next unless origin
+
+          if origin.text && !origin.text.strip.empty?
+            refs << BibliographicReference.new(anchor: origin.text)
+          end
+
+          next unless origin.source && origin.id
+
+          key = "#{origin.source} #{origin.id}"
+          refs << BibliographicReference.new(anchor: key)
+          refs << BibliographicReference.new(anchor: origin.id.to_s)
+        end
+      end
+      refs
+    end
+
+    # Extract all reference types from a managed concept.
+    def extract_all_from_managed_concept(concept)
+      concept_refs = extract_from_managed_concept(concept)
+      asset_refs = extract_asset_refs_from_concept(concept)
+      concept_refs + asset_refs
+    end
+
+    def resolve_asciidoc_xref(target)
+      BibliographicReference.new(anchor: target.strip)
+    end
+
+    def resolve_image_ref(path)
+      AssetReference.new(path: path.strip)
+    end
+
     private
 
     def gather_texts(lc_hash)
@@ -170,16 +227,7 @@ module Glossarist
 
     def deduplicate(refs)
       seen = Set.new
-      refs.select do |ref|
-        key = if ref.concept_id
-                [ref.source,
-                 ref.concept_id]
-              else
-                [ref.source, ref.concept_id,
-                 ref.term]
-              end
-        seen.add?(key)
-      end
+      refs.select { |ref| seen.add?(ref.dedup_key) }
     end
 
     def extract_term_id_from_urn_tail(tail)
@@ -212,6 +260,18 @@ module Glossarist
       regex: /\{\{([^}]+)\}\}/,
     ) { |ext, content| ext.resolve_mention(content) }
 
+    # AsciiDoc cross-references: <<anchor>> or <<anchor,display text>>
+    register_pattern(
+      name: :asciidoc_xref,
+      regex: /<<([^,>\n]+?)(?:,[^>\n]*)?>>/,
+    ) { |ext, target| ext.resolve_asciidoc_xref(target) }
+
+    # Image references: image::path[] or image:path[]
+    register_pattern(
+      name: :asciidoc_image,
+      regex: /image::?([^\[\]]+)\[/,
+    ) { |ext, path| ext.resolve_image_ref(path) }
+
     register_identifier_resolver("urn:iec:std:iec:60050") do |ext, identifier, display|
       ext.resolve_iec_urn(identifier, display)
     end
@@ -223,5 +283,13 @@ module Glossarist
     register_identifier_resolver("urn:") do |ext, identifier, display|
       ext.resolve_generic_urn(identifier, display)
     end
+
+    def gather_all_sources(l10n)
+      sources = Array(l10n.data&.sources)
+      sources += Array((l10n.data&.definition || []).flat_map(&:sources).compact)
+      sources += Array((l10n.data&.notes || []).flat_map(&:sources).compact)
+      sources += Array((l10n.data&.examples || []).flat_map(&:sources).compact)
+      sources
+    end
   end
 end

data/lib/glossarist/reference_resolver.rb

@@ -153,6 +153,7 @@ module Glossarist
     def extract_refs(concept, extractor)
       if concept.is_a?(ManagedConcept)
         extractor.extract_from_managed_concept(concept)
+          .grep(ConceptReference)
       else
         extractor.extract_from_concept_hash(concept)
       end

data/lib/glossarist/urn_resolver.rb

@@ -64,7 +64,19 @@ module Glossarist
     def to_urn(urn_or_reference)
       case urn_or_reference
       when String then urn_or_reference
-      when ConceptReference then urn_or_reference.to_urn
+      when ConceptReference then concept_reference_to_urn(urn_or_reference)
+      end
+    end
+
+    def concept_reference_to_urn(ref)
+      return ref.urn if ref.urn && !ref.urn.strip.empty?
+      return nil unless ref.external?
+      return nil unless ref.source && ref.concept_id
+
+      case ref.source
+      when /\Aurn:iec/ then "#{ref.source}-#{ref.concept_id}"
+      when /\Aurn:iso/ then "#{ref.source}:term:#{ref.concept_id}"
+      else "#{ref.source}/#{ref.concept_id}"
       end
     end
   end

data/lib/glossarist/v1/concept.rb

@@ -42,6 +42,7 @@ module Glossarist
           mc.add_localization(LocalizedConcept.of_yaml({ "data" => data }))
         end
 
+        assign_domains(mc) if groups.is_a?(Array) && groups.any?
         assign_references(mc) if references.is_a?(Array) && references.any?
 
         mc
@@ -49,6 +50,12 @@ module Glossarist
 
       private
 
+      def assign_domains(concept)
+        concept.data.domains = groups.map do |g|
+          ConceptReference.new(concept_id: g.to_s, ref_type: "domain")
+        end
+      end
+
       def assign_references(concept)
         l10n = concept.localization("eng") || concept.localizations.values.first
         return unless l10n

data/lib/glossarist/validation/asset_index.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "set"
+require "zip"
+
+module Glossarist
+  module Validation
+    class AssetIndex
+      IMAGE_TERMS = %w[id ref text anchor].freeze
+      private_constant :IMAGE_TERMS
+
+      attr_reader :paths
+
+      def initialize
+        @paths = Set.new
+      end
+
+      def register(path)
+        @paths.add(normalize_path(path))
+      end
+
+      def resolve?(path)
+        @paths.include?(normalize_path(path))
+      end
+
+      def each_path(&block)
+        @paths.each(&block)
+      end
+
+      def self.build_from_directory(dataset_path)
+        index = new
+        index_image_files(index, dataset_path)
+        index_model_assets(index, dataset_path)
+        index
+      end
+
+      def self.build_from_zip(zip_path)
+        index = new
+        index_zip_images(index, zip_path)
+        index_zip_concept_assets(index, zip_path)
+        index
+      end
+
+      private
+
+      def normalize_path(path)
+        path.to_s.delete_prefix("/")
+      end
+
+      class << self
+        private
+
+        def index_image_files(index, dataset_path)
+          images_dir = File.join(dataset_path, "images")
+          return unless File.directory?(images_dir)
+
+          base = File.expand_path(dataset_path)
+          Dir.glob(File.join(images_dir, "**", "*")).each do |file|
+            next unless File.file?(file)
+
+            relative = file.sub("#{base}/", "")
+            index.register(relative)
+          end
+        end
+
+        def index_model_assets(index, dataset_path)
+          concepts = ConceptCollector.collect(dataset_path)
+          index_concept_assets(index, concepts)
+        end
+
+        def index_zip_images(index, zip_path)
+          Zip::File.open(zip_path) do |zf|
+            zf.entries.each do |entry|
+              next if entry.name.end_with?("/")
+              next unless entry.name.start_with?("images/")
+
+              index.register(entry.name)
+            end
+          end
+        end
+
+        def index_zip_concept_assets(index, zip_path)
+          pkg = GcrPackage.load(zip_path)
+          index_concept_assets(index, pkg.concepts)
+        end
+
+        def index_concept_assets(index, concepts)
+          concepts.each do |concept|
+            concept.localizations.each do |l10n|
+              register_non_verb_rep(index, l10n)
+              register_graphical_symbols(index, l10n)
+            end
+          end
+        end
+
+        def register_non_verb_rep(index, l10n)
+          Array(l10n.non_verb_rep).each do |nvr|
+            next unless nvr.is_a?(NonVerbRep) && nvr.ref && !nvr.ref.strip.empty?
+
+            index.register(nvr.ref.strip)
+          end
+        end
+
+        def register_graphical_symbols(index, l10n)
+          (l10n.data&.terms || []).each do |term|
+            next unless term.is_a?(Designation::GraphicalSymbol) && term.image
+
+            index.register(term.image)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/validation/bibliography_index.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    class BibliographyIndex
+      BIB_ENTRY_KEYS = %w[id ref text anchor].freeze
+      private_constant :BIB_ENTRY_KEYS
+
+      attr_reader :entries
+
+      def initialize
+        @entries = {}
+      end
+
+      def register(anchor, source = nil)
+        @entries[normalize_anchor(anchor)] = { anchor: anchor, source: source }
+      end
+
+      def resolve?(anchor)
+        @entries.key?(normalize_anchor(anchor))
+      end
+
+      def anchors
+        @entries.keys
+      end
+
+      def each_entry(&block)
+        @entries.each_value(&block)
+      end
+
+      def self.build_from_concepts(concepts, dataset_path: nil,
+bibliography_yaml: nil)
+        index = new
+
+        concepts.each { |concept| index_concept_sources(index, concept) }
+
+        yaml = bibliography_yaml || read_bibliography_file(dataset_path)
+        index_bibliography_yaml(index, yaml) if yaml
+
+        index
+      end
+
+      private
+
+      def normalize_anchor(anchor)
+        anchor.to_s.gsub(/[ \/:]/, "_").gsub(/__+/, "_")
+      end
+
+      class << self
+        private
+
+        def read_bibliography_file(dataset_path)
+          return nil unless dataset_path
+
+          bib_path = File.join(dataset_path, "bibliography.yaml")
+          File.exist?(bib_path) ? File.read(bib_path) : nil
+        end
+
+        def index_concept_sources(index, concept)
+          concept.localizations.each do |l10n|
+            index_l10n_sources(index, l10n)
+          end
+        end
+
+        def index_l10n_sources(index, l10n)
+          data = l10n.data
+          return unless data
+
+          register_source_collection(index, data.sources)
+          register_source_collection(index,
+                                     data.definition&.flat_map(&:sources))
+          register_source_collection(index, data.notes&.flat_map(&:sources))
+          register_source_collection(index, data.examples&.flat_map(&:sources))
+        end
+
+        def register_source_collection(index, sources)
+          Array(sources).compact.each { |s| register_source(index, s) }
+        end
+
+        def register_source(index, source)
+          origin = source.origin
+          return unless origin
+
+          register_origin_text(index, origin)
+          register_origin_ref(index, origin)
+        end
+
+        def register_origin_text(index, origin)
+          return unless origin.text && !origin.text.strip.empty?
+
+          index.register(origin.text, origin)
+        end
+
+        def register_origin_ref(index, origin)
+          return unless origin.source && origin.id
+
+          key = "#{origin.source} #{origin.id}"
+          index.register(key, origin)
+          index.register(origin.id.to_s, origin)
+        end
+
+        def index_bibliography_yaml(index, yaml_content)
+          data = YAML.safe_load(yaml_content)
+          return unless data.is_a?(Hash) || data.is_a?(Array)
+
+          entries = data.is_a?(Hash) ? data.values : data
+          entries.each do |entry|
+            next unless entry.is_a?(Hash)
+
+            BIB_ENTRY_KEYS.each do |key|
+              val = entry[key]
+              index.register(val.to_s, entry) if val && !val.to_s.strip.empty?
+            end
+          end
+        rescue Psych::SyntaxError, Psych::DisallowedClass
+          nil
+        end
+      end
+    end
+  end
+end