glossarist 2.6.5 → 2.6.7

data/lib/glossarist/rdf/gloss_concept_reference.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossConceptReference < Lutaml::Model::Serializable
+      attribute :term, :string
+      attribute :concept_id, :string
+      attribute :source, :string
+      attribute :ref_type, :string
+      attribute :urn, :string
+      attribute :parent_id, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |r| "concept/#{r.parent_id}/ref/#{r.concept_id || r.urn}" }
+
+        types "gloss:ConceptReference"
+
+        predicate :refType, namespace: Namespaces::GlossaristNamespace, to: :ref_type
+        predicate :conceptId, namespace: Namespaces::GlossaristNamespace, to: :concept_id
+        predicate :sourceUri, namespace: Namespaces::GlossaristNamespace, to: :source
+        predicate :urn, namespace: Namespaces::GlossaristNamespace, to: :urn
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_concept_source.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossConceptSource < Lutaml::Model::Serializable
+      attribute :status, :string
+      attribute :type, :string
+      attribute :modification, :string
+      attribute :origin, GlossCitation
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |s| "source/#{GlossConceptSource.deterministic_id(s)}" }
+
+        types "gloss:ConceptSource"
+
+        predicate :sourceStatus, namespace: Namespaces::GlossaristNamespace, to: :status, as: :uri
+        predicate :sourceType, namespace: Namespaces::GlossaristNamespace, to: :type, as: :uri
+        predicate :modification, namespace: Namespaces::GlossaristNamespace, to: :modification
+
+        members :origin, link: "gloss:sourceOrigin"
+      end
+
+      def self.deterministic_id(source)
+        parts = [source.status, source.type, source.modification]
+        origin = source.origin
+        if origin
+          parts << origin.source << origin.id << origin.version << origin.link
+        end
+        Digest::MD5.hexdigest(parts.compact.join("|"))[0..11]
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_designation.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    COMMON_DESIGNATION_PREDICATES = lambda { |dsl|
+      dsl.predicate :literalForm, namespace: Namespaces::SkosxlNamespace, to: :designation
+      dsl.predicate :normativeStatus, namespace: Namespaces::GlossaristNamespace, to: :normative_status, as: :uri
+      dsl.predicate :hasTermType, namespace: Namespaces::GlossaristNamespace, to: :term_type, as: :uri
+      dsl.predicate :isInternational, namespace: Namespaces::GlossaristNamespace, to: :international
+      dsl.predicate :isAbsent, namespace: Namespaces::GlossaristNamespace, to: :absent
+      dsl.predicate :geographicalArea, namespace: Namespaces::GlossaristNamespace, to: :language
+      dsl.predicate :language, namespace: Namespaces::DctermsNamespace, to: :lang_code
+      dsl.predicate :script, namespace: Namespaces::GlossaristNamespace, to: :script
+      dsl.predicate :conversionSystem, namespace: Namespaces::GlossaristNamespace, to: :system
+      dsl.members :pronunciations, link: "gloss:hasPronunciation"
+      dsl.members :sources
+    }.freeze
+
+    DESIGNATION_NAMESPACES = [
+      Namespaces::GlossaristNamespace,
+      Namespaces::SkosxlNamespace,
+      Namespaces::SkosNamespace,
+      Namespaces::DctermsNamespace,
+      Namespaces::IsoThesNamespace,
+    ].freeze
+
+    class GlossDesignation < Lutaml::Model::Serializable
+      include Relationships
+
+      attribute :designation, :string
+      attribute :normative_status, :string
+      attribute :type, :string
+      attribute :language, :string
+      attribute :script, :string
+      attribute :system, :string
+      attribute :international, :boolean
+      attribute :absent, :boolean
+      attribute :term_type, :string
+      attribute :concept_id, :string
+      attribute :lang_code, :string
+      attribute :index, :string
+      attribute :pronunciations, GlossPronunciation, collection: true
+      attribute :sources, GlossConceptSource, collection: true
+
+      rdf do
+        namespace(*DESIGNATION_NAMESPACES)
+
+        subject { |d| "concept/#{d.concept_id}/#{d.lang_code}/designation/#{d.index}" }
+
+        types "gloss:Designation", "skosxl:Label"
+
+        COMMON_DESIGNATION_PREDICATES.call(self)
+      end
+    end
+
+    class GlossExpression < GlossDesignation
+      attribute :prefix, :string
+      attribute :usage_info, :string
+      attribute :field_of_application, :string
+      attribute :grammar_info, GlossGrammarInfo, collection: true
+
+      rdf do
+        namespace(*DESIGNATION_NAMESPACES)
+
+        subject { |d| "concept/#{d.concept_id}/#{d.lang_code}/designation/#{d.index}" }
+
+        types "gloss:Expression", "skosxl:Label"
+
+        COMMON_DESIGNATION_PREDICATES.call(self)
+        predicate :prefix, namespace: Namespaces::GlossaristNamespace, to: :prefix
+        predicate :usageInfo, namespace: Namespaces::GlossaristNamespace, to: :usage_info
+        predicate :fieldOfApplication, namespace: Namespaces::GlossaristNamespace, to: :field_of_application
+        members :grammar_info, link: "gloss:hasGrammarInfo"
+      end
+    end
+
+    class GlossAbbreviation < GlossExpression
+      attribute :acronym, :boolean
+      attribute :initialism, :boolean
+      attribute :truncation, :boolean
+
+      rdf do
+        namespace(*DESIGNATION_NAMESPACES)
+
+        subject { |d| "concept/#{d.concept_id}/#{d.lang_code}/designation/#{d.index}" }
+
+        types "gloss:Abbreviation", "skosxl:Label"
+
+        COMMON_DESIGNATION_PREDICATES.call(self)
+        predicate :prefix, namespace: Namespaces::GlossaristNamespace, to: :prefix
+        predicate :usageInfo, namespace: Namespaces::GlossaristNamespace, to: :usage_info
+        predicate :fieldOfApplication, namespace: Namespaces::GlossaristNamespace, to: :field_of_application
+        members :grammar_info, link: "gloss:hasGrammarInfo"
+        predicate :isAcronym, namespace: Namespaces::GlossaristNamespace, to: :acronym
+        predicate :isInitialism, namespace: Namespaces::GlossaristNamespace, to: :initialism
+        predicate :isTruncation, namespace: Namespaces::GlossaristNamespace, to: :truncation
+      end
+    end
+
+    class GlossSymbol < GlossDesignation
+      rdf do
+        namespace(*DESIGNATION_NAMESPACES)
+
+        subject { |d| "concept/#{d.concept_id}/#{d.lang_code}/designation/#{d.index}" }
+
+        types "gloss:Symbol", "skosxl:Label"
+
+        COMMON_DESIGNATION_PREDICATES.call(self)
+      end
+    end
+
+    class GlossLetterSymbol < GlossSymbol
+      attribute :text, :string
+
+      rdf do
+        namespace(*DESIGNATION_NAMESPACES)
+
+        subject { |d| "concept/#{d.concept_id}/#{d.lang_code}/designation/#{d.index}" }
+
+        types "gloss:LetterSymbol", "skosxl:Label"
+
+        COMMON_DESIGNATION_PREDICATES.call(self)
+        predicate :text, namespace: Namespaces::GlossaristNamespace, to: :text
+      end
+    end
+
+    class GlossGraphicalSymbol < GlossSymbol
+      attribute :text, :string
+      attribute :image, :string
+
+      rdf do
+        namespace(*DESIGNATION_NAMESPACES)
+
+        subject { |d| "concept/#{d.concept_id}/#{d.lang_code}/designation/#{d.index}" }
+
+        types "gloss:GraphicalSymbol", "skosxl:Label"
+
+        COMMON_DESIGNATION_PREDICATES.call(self)
+        predicate :text, namespace: Namespaces::GlossaristNamespace, to: :text
+        predicate :image, namespace: Namespaces::GlossaristNamespace, to: :image
+      end
+    end
+  end
+end

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