glossarist 2.6.6 → 2.6.7

data/lib/glossarist/rdf/gloss_detailed_definition.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossDetailedDefinition < Lutaml::Model::Serializable
+      attribute :content, :string
+      attribute :sources, GlossConceptSource, collection: true
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace, Namespaces::RdfNamespace
+
+        subject { |d| "definition/#{d.content.hash.abs}" }
+
+        types "gloss:DetailedDefinition"
+
+        predicate :value, namespace: Namespaces::RdfNamespace, to: :content
+
+        members :sources
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_grammar_info.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossGrammarInfo < Lutaml::Model::Serializable
+      attribute :gender, :string, collection: true
+      attribute :number, :string, collection: true
+      attribute :part_of_speech, :string
+      attribute :concept_id, :string
+      attribute :lang_code, :string
+      attribute :index, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |g| "concept/#{g.concept_id}/#{g.lang_code}/designation/#{g.index}/grammar" }
+
+        types "gloss:GrammarInfo"
+
+        predicate :gender, namespace: Namespaces::GlossaristNamespace, to: :gender, as: :uri
+        predicate :number, namespace: Namespaces::GlossaristNamespace, to: :number, as: :uri
+        predicate :isNoun, namespace: Namespaces::GlossaristNamespace, to: :noun?
+        predicate :isVerb, namespace: Namespaces::GlossaristNamespace, to: :verb?
+        predicate :isAdjective, namespace: Namespaces::GlossaristNamespace, to: :adjective?
+        predicate :isAdverb, namespace: Namespaces::GlossaristNamespace, to: :adverb?
+        predicate :isPreposition, namespace: Namespaces::GlossaristNamespace, to: :preposition?
+        predicate :isParticiple, namespace: Namespaces::GlossaristNamespace, to: :participle?
+      end
+
+      def noun?
+        part_of_speech == "noun"
+      end
+
+      def verb?
+        part_of_speech == "verb"
+      end
+
+      def adjective?
+        part_of_speech == "adjective"
+      end
+
+      def adverb?
+        part_of_speech == "adverb"
+      end
+
+      def preposition?
+        part_of_speech == "preposition"
+      end
+
+      def participle?
+        part_of_speech == "participle"
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_locality.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossLocality < Lutaml::Model::Serializable
+      attribute :locality_type, :string
+      attribute :reference_from, :string
+      attribute :reference_to, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |l| "locality/#{l.locality_type}/#{l.reference_from}" }
+
+        types "gloss:Locality"
+
+        predicate :localityType, namespace: Namespaces::GlossaristNamespace, to: :locality_type
+        predicate :referenceFrom, namespace: Namespaces::GlossaristNamespace, to: :reference_from
+        predicate :referenceTo, namespace: Namespaces::GlossaristNamespace, to: :reference_to
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_localized_concept.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossLocalizedConcept < Lutaml::Model::Serializable
+      attribute :concept_id, :string
+      attribute :language_code, :string
+      attribute :domain, :string
+      attribute :entry_status, :string
+      attribute :release, :string
+      attribute :lineage_similarity, :integer
+      attribute :script, :string
+      attribute :system, :string
+      attribute :designations, GlossDesignation, collection: true
+      attribute :definitions, GlossDetailedDefinition, collection: true
+      attribute :notes, GlossDetailedDefinition, collection: true
+      attribute :examples, GlossDetailedDefinition, collection: true
+      attribute :sources, GlossConceptSource, collection: true
+      attribute :non_verb_reps, GlossNonVerbalRep, collection: true
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace,
+                  Namespaces::SkosNamespace,
+                  Namespaces::SkosxlNamespace,
+                  Namespaces::DctermsNamespace,
+                  Namespaces::IsoThesNamespace,
+                  Namespaces::RdfNamespace
+
+        subject { |l| "concept/#{l.concept_id}/#{l.language_code}" }
+
+        types "gloss:LocalizedConcept", "skos:Concept"
+
+        predicate :language, namespace: Namespaces::DctermsNamespace, to: :language_code
+        predicate :hasEntryStatus, namespace: Namespaces::GlossaristNamespace, to: :entry_status, as: :uri
+        predicate :domain, namespace: Namespaces::GlossaristNamespace, to: :domain
+        predicate :release, namespace: Namespaces::GlossaristNamespace, to: :release
+        predicate :lineageSimilarity, namespace: Namespaces::GlossaristNamespace, to: :lineage_similarity
+        predicate :script, namespace: Namespaces::GlossaristNamespace, to: :script
+        predicate :conversionSystem, namespace: Namespaces::GlossaristNamespace, to: :system
+
+        members :designations,
+                link: ->(d) { GlossLocalizedConcept.skosxl_label_for(d) }
+        members :definitions,
+                link: "gloss:hasDefinition"
+        members :notes,
+                link: "gloss:hasNote"
+        members :examples,
+                link: "gloss:hasExample"
+        members :sources,
+                link: "gloss:hasSource"
+        members :non_verb_reps,
+                link: "gloss:hasNonVerbalRep"
+      end
+
+      def self.skosxl_label_for(designation)
+        status = designation.normative_status.to_s.split("/").last
+        case status
+        when "preferred" then "skosxl:prefLabel"
+        when "deprecated" then "skosxl:hiddenLabel"
+        else "skosxl:altLabel"
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_non_verbal_rep.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossNonVerbalRep < Lutaml::Model::Serializable
+      attribute :representation_type, :string
+      attribute :representation_ref, :string
+      attribute :representation_text, :string
+      attribute :sources, GlossConceptSource, collection: true
+      attribute :concept_id, :string
+      attribute :lang_code, :string
+      attribute :index, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |n| "concept/#{n.concept_id}/#{n.lang_code}/nonverbal/#{n.index}" }
+
+        types "gloss:NonVerbalRepresentation"
+
+        predicate :representationType, namespace: Namespaces::GlossaristNamespace, to: :representation_type
+        predicate :representationRef, namespace: Namespaces::GlossaristNamespace, to: :representation_ref
+        predicate :representationText, namespace: Namespaces::GlossaristNamespace, to: :representation_text
+
+        members :sources
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_pronunciation.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossPronunciation < Lutaml::Model::Serializable
+      attribute :content, :string
+      attribute :language, :string
+      attribute :script, :string
+      attribute :country, :string
+      attribute :system, :string
+      attribute :concept_id, :string
+      attribute :lang_code, :string
+      attribute :index, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |p| "concept/#{p.concept_id}/#{p.lang_code}/pronunciation/#{p.index}" }
+
+        types "gloss:Pronunciation"
+
+        predicate :pronunciationContent, namespace: Namespaces::GlossaristNamespace, to: :content
+        predicate :pronunciationLanguage, namespace: Namespaces::GlossaristNamespace, to: :language
+        predicate :pronunciationScript, namespace: Namespaces::GlossaristNamespace, to: :script
+        predicate :pronunciationCountry, namespace: Namespaces::GlossaristNamespace, to: :country
+        predicate :pronunciationSystem, namespace: Namespaces::GlossaristNamespace, to: :system
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_reference.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require "digest"
+
+module Glossarist
+  module Rdf
+    # Unified RDF view for bibliographic citations and concept references.
+    #
+    # Replaces the former GlossCitation and GlossConceptReference classes.
+    # Both model "a reference to an item within a collection":
+    #   - Citation: collection=document series, item=document, position=clause
+    #   - ConceptReference: collection=termbase, item=concept
+    class GlossReference < Lutaml::Model::Serializable
+      attribute :text, :string
+      attribute :source, :string
+      attribute :id, :string
+      attribute :version, :string
+      attribute :link, :string
+      attribute :locality, GlossLocality
+      attribute :ref_type, :string
+      attribute :urn, :string
+      attribute :term, :string
+      attribute :parent_id, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |r| GlossReference.slug(r) }
+
+        types "gloss:Reference"
+
+        predicate :citationText, namespace: Namespaces::GlossaristNamespace, to: :text
+        predicate :source, namespace: Namespaces::GlossaristNamespace, to: :source
+        predicate :refId, namespace: Namespaces::GlossaristNamespace, to: :id
+        predicate :version, namespace: Namespaces::GlossaristNamespace, to: :version
+        predicate :link, namespace: Namespaces::GlossaristNamespace, to: :link
+        predicate :refType, namespace: Namespaces::GlossaristNamespace, to: :ref_type
+        predicate :urn, namespace: Namespaces::GlossaristNamespace, to: :urn
+        predicate :term, namespace: Namespaces::GlossaristNamespace, to: :term
+        members :locality, link: "gloss:hasLocality"
+      end
+
+      def self.slug(ref)
+        slug = [ref.source, ref.id].compact.join("/")
+        slug = Digest::MD5.hexdigest(ref.text || "")[0..11] if slug.empty?
+        slug
+      end
+    end
+
+    # Backward-compatible aliases
+    GlossCitation = GlossReference
+    GlossConceptReference = GlossReference
+  end
+end

data/lib/glossarist/rdf/namespaces/glossarist_namespace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Rdf
+    module Namespaces
+      class GlossaristNamespace < Lutaml::Rdf::Namespace
+        uri "https://www.glossarist.org/ontologies/"
+        prefix "gloss"
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/namespaces/iso_thes_namespace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Rdf
+    module Namespaces
+      class IsoThesNamespace < Lutaml::Rdf::Namespace
+        uri "http://purl.org/iso25964/skos-thes#"
+        prefix "iso-thes"
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/namespaces/owl_namespace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Rdf
+    module Namespaces
+      class OwlNamespace < Lutaml::Rdf::Namespace
+        uri "http://www.w3.org/2002/07/owl#"
+        prefix "owl"
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/namespaces/prov_namespace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Rdf
+    module Namespaces
+      class ProvNamespace < Lutaml::Rdf::Namespace
+        uri "http://www.w3.org/ns/prov#"
+        prefix "prov"
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/namespaces/rdf_namespace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Rdf
+    module Namespaces
+      class RdfNamespace < Lutaml::Rdf::Namespace
+        uri "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+        prefix "rdf"
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/namespaces/skosxl_namespace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Rdf
+    module Namespaces
+      class SkosxlNamespace < Lutaml::Rdf::Namespace
+        uri "http://www.w3.org/2008/05/skos-xl#"
+        prefix "skosxl"
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/namespaces.rb

@@ -3,8 +3,14 @@
 module Glossarist
   module Rdf
     module Namespaces
-      autoload :SkosNamespace, "#{__dir__}/namespaces/skos_namespace"
-      autoload :DctermsNamespace, "#{__dir__}/namespaces/dcterms_namespace"
+      autoload :DctermsNamespace,    "#{__dir__}/namespaces/dcterms_namespace"
+      autoload :GlossaristNamespace, "#{__dir__}/namespaces/glossarist_namespace"
+      autoload :IsoThesNamespace,    "#{__dir__}/namespaces/iso_thes_namespace"
+      autoload :OwlNamespace,        "#{__dir__}/namespaces/owl_namespace"
+      autoload :RdfNamespace,        "#{__dir__}/namespaces/rdf_namespace"
+      autoload :ProvNamespace,       "#{__dir__}/namespaces/prov_namespace"
+      autoload :SkosNamespace,       "#{__dir__}/namespaces/skos_namespace"
+      autoload :SkosxlNamespace,     "#{__dir__}/namespaces/skosxl_namespace"
     end
   end
 end

data/lib/glossarist/rdf/relationships.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Rdf
+    # Included by RDF view classes that carry variable-predicate relationships.
+    #
+    # Standard SKOS/iso-thes relationships (broader, exactMatch, etc.) and
+    # glossarist-specific relationships (deprecates, compares, etc.) are
+    # emitted as direct triples with the predicate determined at runtime
+    # from REL_PROPERTY_MAP.
+    module Relationships
+      attr_reader :relationship_triples
+
+      def relationship_triples=(pairs)
+        @relationship_triples = Array(pairs)
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/v3/configuration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../../context_configuration"
+
+module Glossarist
+  module Rdf
+    module V3
+      module Configuration
+        extend Glossarist::ContextConfiguration
+
+        CONTEXT_ID = :glossarist_rdf_v3
+      end
+    end
+  end
+end

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.
@@ -159,6 +155,7 @@ module Glossarist
       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
 
@@ -176,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
@@ -283,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