glossarist 2.6.5 → 2.6.7

data/lib/glossarist/rdf/v3.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Load shared infrastructure first
+require_relative "ext"
+require_relative "namespaces"
+require_relative "relationships"
+require_relative "localized_literal"
+
+# V3 Configuration must be loaded before view classes are registered
+require_relative "v3/configuration"
+
+# Load all view class files (must precede V3 constant assignments)
+require_relative "gloss_locality"
+require_relative "gloss_reference"
+require_relative "gloss_concept_source"
+require_relative "gloss_detailed_definition"
+require_relative "gloss_pronunciation"
+require_relative "gloss_grammar_info"
+require_relative "gloss_non_verbal_rep"
+require_relative "gloss_concept_date"
+require_relative "gloss_designation"
+require_relative "gloss_localized_concept"
+require_relative "gloss_concept"
+
+module Glossarist
+  module Rdf
+    # V3 is the current (and only) RDF schema version.
+    #
+    # All RDF view classes produce v3 gloss ontology output:
+    # namespace URI: https://www.glossarist.org/ontologies/v3/
+    #
+    # Each version has its own Configuration module with a unique CONTEXT_ID
+    # so that V3 and (future) V4 classes are isolated in separate
+    # Lutaml::Model::GlobalContext registries.
+    #
+    # When v4 is added:
+    #   - Create Rdf::V4::Configuration with CONTEXT_ID = :glossarist_rdf_v4
+    #   - Create V4 view classes (standalone or inheriting from V3)
+    #   - Register V4 classes in Rdf::V4::Configuration
+    #   - Update ConceptToGlossTransform to support v4
+    #   - V3 and V4 coexist — consumers choose which to use
+    module V3
+      # Namespace
+      GlossaristNamespace = Namespaces::GlossaristNamespace
+
+      # Single source of truth: add new view classes here once.
+      # Each entry is registered in the V3 type registry and
+      # re-exported as a V3:: constant.
+      VIEW_CLASS_NAMES = %i[
+        GlossLocality
+        GlossPronunciation
+        GlossGrammarInfo
+        GlossConceptDate
+        GlossReference
+        GlossConceptSource
+        GlossDetailedDefinition
+        GlossNonVerbalRep
+        GlossDesignation
+        GlossExpression
+        GlossAbbreviation
+        GlossSymbol
+        GlossLetterSymbol
+        GlossGraphicalSymbol
+        GlossPrefix
+        GlossSuffix
+        GlossLocalizedConcept
+        GlossConcept
+        GlossDocument
+      ].freeze
+
+      VIEW_CLASS_NAMES.each do |name|
+        klass = ::Glossarist::Rdf.const_get(name)
+        registry_id = name.to_s.gsub(/([A-Z])/) { |c| "_#{c.downcase}" }.sub(/^_/, "").to_sym
+        Configuration.register_model(klass, id: registry_id)
+        const_set(name, klass)
+      end
+    end
+  end
+end

data/lib/glossarist/rdf.rb

@@ -1,10 +1,30 @@
 # frozen_string_literal: true
 
+# Load lutaml-model RDF extensions before any RDF view classes
+require_relative "rdf/ext"
+
 module Glossarist
   module Rdf
     autoload :Namespaces, "#{__dir__}/rdf/namespaces"
     autoload :LocalizedLiteral, "#{__dir__}/rdf/localized_literal"
-    autoload :SkosConcept, "#{__dir__}/rdf/skos_concept"
-    autoload :SkosVocabulary, "#{__dir__}/rdf/skos_vocabulary"
+    autoload :Relationships, "#{__dir__}/rdf/relationships"
+    autoload :GlossLocality, "#{__dir__}/rdf/gloss_locality"
+    autoload :GlossCitation, "#{__dir__}/rdf/gloss_citation"
+    autoload :GlossConceptSource, "#{__dir__}/rdf/gloss_concept_source"
+    autoload :GlossDetailedDefinition, "#{__dir__}/rdf/gloss_detailed_definition"
+    autoload :GlossPronunciation, "#{__dir__}/rdf/gloss_pronunciation"
+    autoload :GlossGrammarInfo, "#{__dir__}/rdf/gloss_grammar_info"
+    autoload :GlossNonVerbalRep, "#{__dir__}/rdf/gloss_non_verbal_rep"
+    autoload :GlossConceptReference, "#{__dir__}/rdf/gloss_concept_reference"
+    autoload :GlossConceptDate, "#{__dir__}/rdf/gloss_concept_date"
+    autoload :GlossDesignation, "#{__dir__}/rdf/gloss_designation"
+    autoload :GlossExpression, "#{__dir__}/rdf/gloss_designation"
+    autoload :GlossAbbreviation, "#{__dir__}/rdf/gloss_designation"
+    autoload :GlossSymbol, "#{__dir__}/rdf/gloss_designation"
+    autoload :GlossLetterSymbol, "#{__dir__}/rdf/gloss_designation"
+    autoload :GlossGraphicalSymbol, "#{__dir__}/rdf/gloss_designation"
+    autoload :GlossLocalizedConcept, "#{__dir__}/rdf/gloss_localized_concept"
+    autoload :GlossConcept, "#{__dir__}/rdf/gloss_concept"
+    autoload :GlossDocument, "#{__dir__}/rdf/gloss_concept"
   end
 end

data/lib/glossarist/reference_extractor.rb

@@ -62,11 +62,7 @@ module Glossarist
     end
 
     def extract_from_localized_concept(l10n)
-      texts = []
-      l10n.data.definition&.each { |d| texts << d.content if d.content }
-      l10n.data.notes&.each { |n| texts << n.content if n.content }
-      l10n.data.examples&.each { |e| texts << e.content if e.content }
-      texts.flat_map { |t| extract_from_text(t) }
+      l10n.text_content.flat_map { |t| extract_from_text(t) }
     end
 
     # Unified concept mention dispatcher.
@@ -157,11 +153,10 @@ module Glossarist
       refs = []
 
       concept.localizations.each do |l10n|
-        nvr = l10n.non_verb_rep
-        if nvr.is_a?(String) && !nvr.strip.empty?
-          nvr.strip.split.each do |p|
-            refs << AssetReference.new(path: p) unless p.empty?
-          end
+        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|
@@ -178,19 +173,23 @@ module Glossarist
     def extract_bib_refs_from_concept(concept)
       refs = []
       concept.localizations.each do |l10n|
-        gather_all_sources(l10n).each do |source|
+        l10n.all_sources.each do |source|
           origin = source.origin
           next unless origin
 
-          if origin.text && !origin.text.strip.empty?
-            refs << BibliographicReference.new(anchor: origin.text)
+          ref = origin.ref
+          next unless ref
+
+          source_text = ref.source
+          if source_text && !source_text.strip.empty?
+            refs << BibliographicReference.new(anchor: source_text)
           end
 
-          next unless origin.source && origin.id
+          next unless ref.source && ref.id
 
-          key = "#{origin.source} #{origin.id}"
+          key = "#{ref.source} #{ref.id}"
           refs << BibliographicReference.new(anchor: key)
-          refs << BibliographicReference.new(anchor: origin.id.to_s)
+          refs << BibliographicReference.new(anchor: ref.id.to_s)
         end
       end
       refs
@@ -285,13 +284,5 @@ 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

@@ -116,7 +116,7 @@ module Glossarist
 
     def infer_uri_prefix(package_or_concepts)
       case package_or_concepts
-      when GcrPackage then package_or_concepts.metadata&.dig("uri_prefix")
+      when GcrPackage then package_or_concepts.metadata&.uri_prefix
       end
     end
 
@@ -128,7 +128,7 @@ module Glossarist
         next unless File.exist?(gcr_path)
 
         gcr = GcrPackage.load(gcr_path)
-        prefix = pkg["uri_prefix"] || gcr.metadata&.dig("uri_prefix")
+        prefix = pkg["uri_prefix"] || gcr.metadata&.uri_prefix
         register_package(gcr, uri_prefix: prefix)
       end
 
@@ -145,7 +145,7 @@ module Glossarist
     def load_gcr_directory(dir)
       Dir.glob(File.join(dir, "*.gcr")).each do |gcr_path|
         pkg = GcrPackage.load(gcr_path)
-        prefix = pkg.metadata&.dig("uri_prefix")
+        prefix = pkg.metadata&.uri_prefix
         register_package(pkg, uri_prefix: prefix)
       end
     end

data/lib/glossarist/related_concept.rb

@@ -5,20 +5,12 @@ module Glossarist
     attribute :content, :string
     attribute :type, :string,
               values: Glossarist::GlossaryDefinition::RELATED_CONCEPT_TYPES
-    attribute :ref, Citation
+    attribute :ref, ConceptRef
 
     key_value do
       map :content, to: :content
       map :type, to: :type
-      map :ref, with: { from: :ref_from_yaml, to: :ref_to_yaml }
-    end
-
-    def ref_to_yaml(model, doc)
-      doc["ref"] = Citation.as_yaml(model.ref)["ref"] if model.ref
-    end
-
-    def ref_from_yaml(model, value)
-      model.ref = Citation.of_yaml(value)
+      map :ref, to: :ref
     end
   end
 end

data/lib/glossarist/schema_migration.rb

@@ -6,6 +6,45 @@ module Glossarist
   class SchemaMigration
     CURRENT_SCHEMA_VERSION = "1"
 
+    def self.migrate_concept(concept, target_version: Glossarist::SCHEMA_VERSION)
+      current = concept_version(concept)
+      target = target_version.to_s
+
+      return concept if current == target
+
+      max_steps = 5
+      max_steps.times do
+        break if current == target
+
+        case current
+        when "2" then current = step_v2_to_v3(concept)
+        else
+          raise Error, "No concept migration step from version #{current}"
+        end
+      end
+
+      raise Error, "Migration chain too long or unresolvable" unless current == target
+
+      concept.schema_version = target
+      concept
+    end
+
+    def self.concept_version(concept)
+      version = concept.schema_version
+      return version.to_s if version && !version.to_s.empty?
+
+      ManagedConcept.detect_schema_version(concept)
+    end
+
+    def self.step_v2_to_v3(concept)
+      if concept.data&.related&.any?
+        concept.related ||= []
+        concept.related = (concept.related + concept.data.related).uniq
+        concept.data.related = []
+      end
+      "3"
+    end
+
     ENTRY_STATUS_MAP = {
       "Standard" => "valid",
       "Confirmed" => "valid",

data/lib/glossarist/sts/term_mapper.rb

@@ -98,7 +98,7 @@ module Glossarist
           sources << {
             "status" => "identical",
             "type" => "authoritative",
-            "origin" => { "text" => source_ref },
+            "origin" => { "ref" => { "source" => source_ref } },
           }
         end
 
@@ -107,7 +107,7 @@ module Glossarist
 
           sources << {
             "type" => "authoritative",
-            "origin" => { "text" => text },
+            "origin" => { "ref" => { "source" => text } },
           }
         end
 

data/lib/glossarist/transforms/concept_to_gloss_transform.rb

@@ -0,0 +1,355 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Transforms
+    # Transforms Glossarist domain model objects into ontology-faithful RDF
+    # using lutaml-model serializable view classes.
+    #
+    # Creates GlossConcept/GlossLocalizedConcept/GlossDesignation instances
+    # and delegates Turtle/JSON-LD serialization to lutaml-model.
+    class ConceptToGlossTransform
+      GLOSS  = Rdf::Namespaces::GlossaristNamespace.uri
+      SKOS   = Rdf::Namespaces::SkosNamespace.uri
+      XL     = Rdf::Namespaces::SkosxlNamespace.uri
+      ISO    = Rdf::Namespaces::IsoThesNamespace.uri
+      DCT    = Rdf::Namespaces::DctermsNamespace.uri
+      RDF_NS = Rdf::Namespaces::RdfNamespace.uri
+
+      REL_PROPERTY_MAP = {
+        "broader" => "#{SKOS}broader",
+        "narrower" => "#{SKOS}narrower",
+        "broader_generic" => "#{ISO}broaderGeneric",
+        "narrower_generic" => "#{ISO}narrowerGeneric",
+        "broader_partitive" => "#{ISO}broaderPartitive",
+        "narrower_partitive" => "#{ISO}narrowerPartitive",
+        "broader_instantial" => "#{ISO}broaderInstantial",
+        "narrower_instantial" => "#{ISO}narrowerInstantial",
+        "equivalent" => "#{SKOS}exactMatch",
+        "close_match" => "#{SKOS}closeMatch",
+        "broad_match" => "#{SKOS}broadMatch",
+        "narrow_match" => "#{SKOS}narrowMatch",
+        "related_match" => "#{SKOS}relatedMatch",
+        "see" => "#{SKOS}related",
+        "deprecates" => "#{GLOSS}deprecates",
+        "supersedes" => "#{GLOSS}supersedes",
+        "superseded_by" => "#{GLOSS}supersededBy",
+        "compare" => "#{GLOSS}compares",
+        "contrast" => "#{GLOSS}contrasts",
+        "sequentially_related_concept" => "#{GLOSS}sequentiallyRelated",
+        "spatially_related_concept" => "#{GLOSS}spatiallyRelated",
+        "temporally_related_concept" => "#{GLOSS}temporallyRelated",
+        "homograph" => "#{GLOSS}hasHomograph",
+        "false_friend" => "#{GLOSS}hasFalseFriend",
+        "related_concept_broader" => "#{GLOSS}relatedConceptBroader",
+        "related_concept_narrower" => "#{GLOSS}relatedConceptNarrower",
+        "abbreviated_form_for" => "#{GLOSS}abbreviatedFormFor",
+        "short_form_for" => "#{GLOSS}shortFormFor",
+      }.freeze
+
+      DATE_TYPE_MAP = {
+        "accepted" => "#{GLOSS}status/accepted",
+        "amended" => "#{GLOSS}status/amended",
+        "retired" => "#{GLOSS}status/retired",
+      }.freeze
+
+      def self.transform(managed_concept, options = {})
+        new(managed_concept, options).build
+      end
+
+      def self.transform_document(concepts, options = {})
+        new(nil, options).build_document(concepts)
+      end
+
+      def initialize(managed_concept, options = {})
+        @concept = managed_concept
+        @options = options
+      end
+
+      def build
+        build_gloss_concept(concept)
+      end
+
+      def build_document(concepts)
+        gloss_concepts = concepts.map { |c| build_gloss_concept(c) }
+        doc = Rdf::GlossDocument.new(concepts: gloss_concepts)
+        Rdf::GlossDocument.to_turtle(doc)
+      end
+
+      def to_turtle(concepts_or_concept = nil)
+        if concepts_or_concept.is_a?(Array)
+          build_document(concepts_or_concept)
+        else
+          target = concepts_or_concept || @concept
+          return "" unless target
+
+          gc = build_gloss_concept(target)
+          Rdf::GlossConcept.to_turtle(gc)
+        end
+      end
+
+      def to_jsonld(concepts_or_concept = nil)
+        if concepts_or_concept.is_a?(Array)
+          gloss_concepts = concepts_or_concept.map { |c| build_gloss_concept(c) }
+          doc = Rdf::GlossDocument.new(concepts: gloss_concepts)
+          Rdf::GlossDocument.to_jsonld(doc)
+        else
+          target = concepts_or_concept || @concept
+          return "" unless target
+
+          gc = build_gloss_concept(target)
+          Rdf::GlossConcept.to_jsonld(gc)
+        end
+      end
+
+      def to_jsonl_line
+        return "" unless @concept
+
+        gc = build_gloss_concept(@concept)
+        Rdf::GlossConcept.to_jsonld(gc)
+      end
+
+      private
+
+      attr_reader :concept, :options
+
+      # ── Build RDF view instances from domain model ─────────────────────
+
+      def build_gloss_concept(managed_concept)
+        identifier = managed_concept.data&.id || managed_concept.identifier
+
+        localizations = managed_concept.localizations.each_value.map do |l10n|
+          build_gloss_localized_concept(l10n, identifier)
+        end
+
+        gc = Rdf::GlossConcept.new(
+          identifier: identifier.to_s,
+          status: status_uri(managed_concept.status),
+          localizations: localizations,
+          sources: build_gloss_sources(managed_concept.data&.sources),
+          domains: build_gloss_domains(managed_concept.data&.domains, identifier),
+          dates: build_gloss_dates(managed_concept.dates, identifier),
+        )
+
+        gc.relationship_triples = build_relationship_triples(managed_concept.related)
+        gc
+      end
+
+      def build_gloss_localized_concept(l10n, concept_id)
+        lang = l10n.language_code
+        data = l10n.data
+
+        designations = Array(l10n.designations).each_with_index.map do |desig, idx|
+          build_gloss_designation(desig, concept_id, lang, idx)
+        end
+
+        definitions = build_gloss_definitions(data&.definition)
+        notes = build_gloss_definitions(data&.notes)
+        examples = build_gloss_definitions(data&.examples)
+        sources = build_gloss_sources(data&.sources)
+        non_verb_reps = build_gloss_non_verbal_reps(l10n.non_verb_rep, concept_id, lang)
+
+        Rdf::GlossLocalizedConcept.new(
+          concept_id: concept_id.to_s,
+          language_code: lang,
+          domain: data&.domain,
+          entry_status: data&.entry_status ? "gloss:entstatus/#{data.entry_status}" : nil,
+          release: data&.release,
+          lineage_similarity: data&.lineage_source_similarity,
+          script: data&.script,
+          system: data&.system,
+          designations: designations,
+          definitions: definitions,
+          notes: notes,
+          examples: examples,
+          sources: sources,
+          non_verb_reps: non_verb_reps,
+        )
+      end
+
+      def build_gloss_designation(desig, concept_id, lang, index)
+        common_attrs = designation_common_attrs(desig, concept_id, lang, index)
+
+        instance = case desig
+                   when Designation::Abbreviation
+                     build_gloss_abbreviation(desig, common_attrs, concept_id, lang, index)
+                   when Designation::Expression
+                     build_gloss_expression(desig, common_attrs, concept_id, lang, index)
+                   when Designation::GraphicalSymbol
+                     Rdf::GlossGraphicalSymbol.new(common_attrs.merge(text: desig.text, image: desig.image))
+                   when Designation::LetterSymbol
+                     Rdf::GlossLetterSymbol.new(common_attrs.merge(text: desig.text))
+                   when Designation::Symbol
+                     Rdf::GlossSymbol.new(common_attrs)
+                   else
+                     Rdf::GlossExpression.new(common_attrs)
+                   end
+
+        instance.relationship_triples = build_relationship_triples(desig.related)
+        instance
+      end
+
+      def designation_common_attrs(desig, concept_id, lang, index)
+        norm_status = desig.normative_status
+        {
+          designation: desig.designation,
+          normative_status: norm_status ? "gloss:norm/#{norm_status}" : nil,
+          type: desig.type,
+          language: desig.language || lang,
+          script: desig.script,
+          system: desig.system,
+          international: desig.international,
+          absent: desig.absent,
+          term_type: desig.term_type ? "gloss:termtype/#{desig.term_type}" : nil,
+          concept_id: concept_id.to_s,
+          lang_code: (desig.language || lang).to_s,
+          index: index.to_s,
+          pronunciations: build_gloss_pronunciations(desig.pronunciation, concept_id, lang, index),
+          sources: build_gloss_sources(desig.sources),
+        }
+      end
+
+      def build_gloss_abbreviation(desig, common_attrs, concept_id, lang, index)
+        Rdf::GlossAbbreviation.new(common_attrs.merge(
+                                     prefix: desig.prefix,
+                                     usage_info: desig.usage_info,
+                                     field_of_application: desig.field_of_application,
+                                     acronym: desig.acronym,
+                                     initialism: desig.initialism,
+                                     truncation: desig.truncation,
+                                     grammar_info: build_gloss_grammar_infos(desig.grammar_info, concept_id, lang, index),
+                                   ))
+      end
+
+      def build_gloss_expression(desig, common_attrs, concept_id, lang, index)
+        Rdf::GlossExpression.new(common_attrs.merge(
+                                   prefix: desig.prefix,
+                                   usage_info: desig.usage_info,
+                                   field_of_application: desig.field_of_application,
+                                   grammar_info: build_gloss_grammar_infos(desig.grammar_info, concept_id, lang, index),
+                                 ))
+      end
+
+      def build_gloss_definitions(definitions)
+        Array(definitions).map do |dd|
+          Rdf::GlossDetailedDefinition.new(
+            content: dd.content,
+            sources: build_gloss_sources(dd.sources),
+          )
+        end
+      end
+
+      def build_gloss_sources(sources)
+        Array(sources).map do |src|
+          origin = src.origin ? build_gloss_citation(src.origin) : nil
+          Rdf::GlossConceptSource.new(
+            status: src.status ? "gloss:srcstatus/#{src.status}" : nil,
+            type: src.type ? "gloss:srctype/#{src.type}" : nil,
+            modification: src.modification,
+            origin: origin,
+          )
+        end
+      end
+
+      def build_gloss_citation(citation)
+        locality = citation.locality ? build_gloss_locality(citation.locality) : nil
+        ref = citation.ref
+
+        Rdf::GlossCitation.new(
+          source: ref&.source,
+          id: ref&.id,
+          version: ref&.version,
+          link: citation.link,
+          locality: locality,
+        )
+      end
+
+      def build_gloss_locality(loc)
+        Rdf::GlossLocality.new(
+          locality_type: loc.type,
+          reference_from: loc.reference_from,
+          reference_to: loc.reference_to,
+        )
+      end
+
+      def build_gloss_pronunciations(pronunciations, concept_id, lang, _desig_index)
+        Array(pronunciations).each_with_index.map do |pron, idx|
+          Rdf::GlossPronunciation.new(
+            content: pron.content,
+            language: pron.language,
+            script: pron.script,
+            country: pron.country,
+            system: pron.system,
+            concept_id: concept_id.to_s,
+            lang_code: lang.to_s,
+            index: idx.to_s,
+          )
+        end
+      end
+
+      def build_gloss_grammar_infos(grammar_infos, concept_id, lang, desig_index)
+        Array(grammar_infos).map do |gi|
+          Rdf::GlossGrammarInfo.new(
+            gender: Array(gi.gender).map { |g| "gloss:gender/#{g}" },
+            number: Array(gi.number).map { |n| "gloss:number/#{n}" },
+            part_of_speech: gi.part_of_speech,
+            concept_id: concept_id.to_s,
+            lang_code: lang.to_s,
+            index: desig_index.to_s,
+          )
+        end
+      end
+
+      def build_gloss_non_verbal_reps(non_verb_reps, concept_id, lang)
+        Array(non_verb_reps).each_with_index.map do |nvr, idx|
+          Rdf::GlossNonVerbalRep.new(
+            representation_type: nvr.type,
+            representation_ref: nvr.ref,
+            representation_text: nvr.text,
+            sources: build_gloss_sources(nvr.sources),
+            concept_id: concept_id.to_s,
+            lang_code: lang.to_s,
+            index: idx.to_s,
+          )
+        end
+      end
+
+      def build_gloss_domains(domains, concept_id)
+        Array(domains).map do |ref|
+          Rdf::GlossConceptReference.new(
+            concept_id: ref.concept_id,
+            source: ref.source,
+            ref_type: ref.ref_type,
+            urn: ref.urn,
+            parent_id: concept_id.to_s,
+          )
+        end
+      end
+
+      def build_gloss_dates(dates, concept_id)
+        Array(dates).map do |date|
+          Rdf::GlossConceptDate.new(
+            date_value: date.date&.to_s,
+            date_type: DATE_TYPE_MAP[date.type] || "gloss:status/#{date.type}",
+            concept_id: concept_id.to_s,
+          )
+        end
+      end
+
+      def build_relationship_triples(related_concepts)
+        Array(related_concepts).filter_map do |rc|
+          predicate_uri = REL_PROPERTY_MAP[rc.type]
+          next unless predicate_uri
+
+          target_id = rc.ref&.id
+          next unless target_id
+
+          [predicate_uri, "concept/#{target_id}"]
+        end
+      end
+
+      def status_uri(status)
+        status ? "gloss:status/#{status}" : nil
+      end
+    end
+  end
+end

data/lib/glossarist/transforms.rb

@@ -2,8 +2,8 @@
 
 module Glossarist
   module Transforms
-    autoload :ConceptToSkosTransform,
-             "glossarist/transforms/concept_to_skos_transform"
+    autoload :ConceptToGlossTransform,
+             "glossarist/transforms/concept_to_gloss_transform"
     autoload :ConceptToTbxTransform,
              "glossarist/transforms/concept_to_tbx_transform"
   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