glossarist 2.5.1 → 2.6.0

data/lib/glossarist/gcr_package.rb

@@ -5,6 +5,15 @@ require "fileutils"
 
 module Glossarist
   class GcrPackage
+    COMPILED_EXTENSIONS = {
+      "tbx" => "tbx.xml",
+      "jsonld" => "jsonld",
+      "turtle" => "ttl",
+      "jsonl" => "jsonl",
+    }.freeze
+
+    KNOWN_COMPILED_FORMATS = COMPILED_EXTENSIONS.keys.freeze
+
     attr_reader :zip_path, :metadata, :concepts
 
     def initialize(zip_path)
@@ -13,16 +22,18 @@ module Glossarist
       @concepts = []
     end
 
-    def self.create(concepts:, metadata:, output_path:, register_data: nil)
+    def self.create(concepts:, metadata:, output_path:, register_data: nil,
+                    compiled_formats: [], **opts)
       FileUtils.mkdir_p(File.dirname(output_path))
       package = new(output_path)
-      package.send(:write, concepts, metadata, register_data)
+      package.write(concepts, metadata, register_data,
+                    compiled_formats: compiled_formats, **opts)
       package
     end
 
     def self.load(zip_path)
       package = new(zip_path)
-      package.send(:read)
+      package.read
       package
     end
 
@@ -30,8 +41,14 @@ module Glossarist
                                   title: nil, description: nil, owner: nil,
                                   tags: [], register_yaml: nil,
                                   uri_prefix: nil, concept_uri_template: nil,
-                                  streaming: false)
+                                  streaming: false, compiled_formats: [])
       dir = File.expand_path(dir)
+      formats = Array(compiled_formats).map(&:to_s)
+
+      if streaming && formats.any?
+        raise ArgumentError,
+              "Compiled formats require batch mode (streaming: true is incompatible)"
+      end
 
       if streaming
         create_streaming(dir, output: output, shortname: shortname, version: version,
@@ -44,7 +61,8 @@ module Glossarist
                           title: title, description: description, owner: owner,
                           tags: tags, register_yaml: register_yaml,
                           uri_prefix: uri_prefix,
-                          concept_uri_template: concept_uri_template)
+                          concept_uri_template: concept_uri_template,
+                          compiled_formats: formats)
       end
     end
 
@@ -52,9 +70,8 @@ module Glossarist
       GcrValidator.new.validate(@zip_path)
     end
 
-    private
-
-    def write(concepts, metadata, register_data)
+    def write(concepts, metadata, register_data, compiled_formats: [],
+              shortname: nil, **opts)
       Zip::File.open(@zip_path, create: true) do |zf|
         zf.get_output_stream("metadata.yaml") do |f|
           f.write(metadata.to_yaml)
@@ -69,6 +86,11 @@ module Glossarist
         concepts.each do |mc|
           write_concept(zf, mc)
         end
+
+        if compiled_formats.any?
+          write_compiled(zf, concepts, compiled_formats, shortname: shortname,
+                                                         **opts)
+        end
       end
     end
 
@@ -98,10 +120,67 @@ module Glossarist
       end
     end
 
+    def write_compiled(zip_file, concepts, formats, shortname: nil, **opts)
+      name = shortname || "glossary"
+      transform_opts = { shortname: name }.merge(opts.slice(:site_url,
+                                                            :uri_prefix, :title))
+
+      if formats.include?("tbx")
+        write_compiled_tbx(zip_file, concepts, transform_opts, name)
+      end
+
+      skos_formats = formats & %w[jsonld turtle jsonl]
+      if skos_formats.any?
+        write_compiled_skos(zip_file, concepts, skos_formats, transform_opts,
+                            name)
+      end
+
+      (formats - KNOWN_COMPILED_FORMATS).each do |fmt|
+        warn "Warning: Unknown compiled format '#{fmt}', skipping"
+      end
+    end
+
+    def write_compiled_tbx(zip_file, concepts, opts, name)
+      require "glossarist/transforms/concept_to_tbx_transform"
+      doc = Transforms::ConceptToTbxTransform.transform_document(concepts, opts)
+      zip_file.get_output_stream("compiled/#{name}.tbx.xml") do |f|
+        f.write(doc.to_xml)
+      end
+    end
+
+    def write_compiled_skos(zip_file, concepts, formats, opts, name) # rubocop:disable Metrics/MethodLength
+      require "glossarist/transforms/concept_to_skos_transform"
+      vocab = Transforms::ConceptToSkosTransform.transform_document(concepts,
+                                                                    opts)
+
+      if formats.include?("jsonld")
+        zip_file.get_output_stream("compiled/#{name}.jsonld") do |f|
+          f.write(vocab.to_jsonld)
+        end
+      end
+
+      if formats.include?("turtle")
+        zip_file.get_output_stream("compiled/#{name}.ttl") do |f|
+          f.write(vocab.to_turtle)
+        end
+      end
+
+      return unless formats.include?("jsonl")
+
+      zip_file.get_output_stream("compiled/#{name}.jsonl") do |f|
+        concepts.each do |concept|
+          skos = Transforms::ConceptToSkosTransform.transform(concept, opts)
+          f.write(skos.to_jsonld)
+          f.write("\n")
+        end
+      end
+    end
+
     class << self
       private
 
-      def create_batch(dir, output:, shortname:, version:, **opts)
+      def create_batch(dir, output:, shortname:, version:,
+compiled_formats: [], **opts)
         concepts = ConceptCollector.collect(dir)
         if concepts.empty?
           raise ArgumentError,
@@ -117,13 +196,17 @@ module Glossarist
 
         register_data = load_register_data(opts[:register_yaml], dir)
         metadata = build_metadata(concepts, shortname: shortname, version: version,
-                                            register_data: register_data, **opts)
+                                            register_data: register_data,
+                                            compiled_formats: compiled_formats, **opts)
 
         create(
           concepts: concepts,
           metadata: metadata,
           register_data: register_data,
           output_path: File.expand_path(output),
+          compiled_formats: compiled_formats,
+          shortname: shortname,
+          **opts,
         )
       end
 
@@ -195,7 +278,7 @@ module Glossarist
       end
 
       def build_metadata(concepts, shortname:, version:, register_data: nil,
-**opts)
+                         compiled_formats: [], **opts)
         GcrMetadata.from_concepts(
           concepts,
           register_data: register_data,
@@ -208,6 +291,7 @@ module Glossarist
             tags: opts[:tags],
             uri_prefix: opts[:uri_prefix],
             concept_uri_template: opts[:concept_uri_template],
+            compiled_formats: compiled_formats,
           },
         )
       end

data/lib/glossarist/gcr_statistics.rb

@@ -29,7 +29,11 @@ module Glossarist
     end
 
     def self.count_with(l10ns, attr)
-      l10ns.count { |l| l.data.send(attr)&.any? }
+      case attr
+      when :definition then l10ns.count { |l| l.data.definition&.any? }
+      when :sources then l10ns.count { |l| l.data.sources&.any? }
+      else 0
+      end
     end
   end
 end

data/lib/glossarist/managed_concept.rb

@@ -126,6 +126,16 @@ module Glossarist
     # Returns concept localization.
     # @param lang [String] language code
     # @return [LocalizedConcept]
+    def to_jsonld
+      require "glossarist/transforms/concept_to_skos_transform"
+      Transforms::ConceptToSkosTransform.transform(self).to_jsonld
+    end
+
+    def to_turtle
+      require "glossarist/transforms/concept_to_skos_transform"
+      Transforms::ConceptToSkosTransform.transform(self).to_turtle
+    end
+
     def default_designation
       localized = localization("eng") || localizations.values.first
       terms = localized&.preferred_terms&.first || localized&.terms&.first

data/lib/glossarist/rdf/localized_literal.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Rdf
+    class LocalizedLiteral < Lutaml::Model::Serializable
+      include Lutaml::Rdf::LanguageTagged
+
+      attribute :value, :string
+      attribute :language_code, :string
+
+      key_value do
+        map :value, to: :value
+        map :language_code, to: :language_code
+      end
+
+      def language_tag
+        language_code
+      end
+
+      def to_s
+        value.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Rdf
+    module Namespaces
+      class DctermsNamespace < Lutaml::Rdf::Namespace
+        uri "http://purl.org/dc/terms/"
+        prefix "dcterms"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Rdf
+    module Namespaces
+      class SkosNamespace < Lutaml::Rdf::Namespace
+        uri "http://www.w3.org/2004/02/skos/core#"
+        prefix "skos"
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/namespaces.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Rdf
+    module Namespaces
+      autoload :SkosNamespace, "#{__dir__}/namespaces/skos_namespace"
+      autoload :DctermsNamespace, "#{__dir__}/namespaces/dcterms_namespace"
+    end
+  end
+end

data/lib/glossarist/rdf/skos_concept.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "lutaml/turtle"
+require "lutaml/jsonld"
+require_relative "../rdf"
+
+module Glossarist
+  module Rdf
+    class SkosConcept < Lutaml::Model::Serializable
+      attribute :code, :string
+      attribute :labels, LocalizedLiteral, collection: true
+      attribute :definitions, LocalizedLiteral, collection: true
+      attribute :alt_labels, LocalizedLiteral, collection: true
+      attribute :scope_notes, LocalizedLiteral, collection: true
+      attribute :sources, :string, collection: true
+      attribute :domain, :string
+      attribute :date_accepted, :string
+
+      rdf do
+        namespace Namespaces::SkosNamespace, Namespaces::DctermsNamespace
+
+        subject { |c| "https://glossarist.org/concept/#{c.code}" }
+        type "skos:Concept"
+
+        predicate :notation,     namespace: Namespaces::SkosNamespace,
+                                 to: :code
+        predicate :prefLabel,    namespace: Namespaces::SkosNamespace,
+                                 to: :labels,       lang_tagged: true
+        predicate :definition,   namespace: Namespaces::SkosNamespace,
+                                 to: :definitions,  lang_tagged: true
+        predicate :altLabel,     namespace: Namespaces::SkosNamespace,
+                                 to: :alt_labels,   lang_tagged: true
+        predicate :scopeNote,    namespace: Namespaces::SkosNamespace,
+                                 to: :scope_notes,  lang_tagged: true
+        predicate :subject,      namespace: Namespaces::DctermsNamespace,
+                                 to: :domain
+        predicate :source,       namespace: Namespaces::DctermsNamespace,
+                                 to: :sources
+        predicate :dateAccepted, namespace: Namespaces::DctermsNamespace,
+                                 to: :date_accepted
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/skos_vocabulary.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "lutaml/turtle"
+require "lutaml/jsonld"
+require_relative "../rdf"
+
+module Glossarist
+  module Rdf
+    class SkosVocabulary < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :title, :string
+      attribute :concepts, SkosConcept, collection: true
+
+      rdf do
+        namespace Namespaces::SkosNamespace, Namespaces::DctermsNamespace
+
+        subject { |v| "https://glossarist.org/vocab/#{v.id}" }
+        type "skos:ConceptScheme"
+
+        predicate :prefLabel, namespace: Namespaces::SkosNamespace, to: :title
+
+        members :concepts
+      end
+    end
+  end
+end

data/lib/glossarist/rdf.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+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"
+  end
+end

data/lib/glossarist/resolution_adapter/local.rb

@@ -41,9 +41,7 @@ module Glossarist
       def designations_for(concept)
         if concept.is_a?(ManagedConcept)
           concept.localizations.flat_map do |l10n|
-            l10n.data.terms.filter_map do |t|
-              t.respond_to?(:designation) ? t.designation : nil
-            end
+            l10n.data.terms.filter_map(&:designation)
           end
         else
           concept.each_value.flat_map do |lang_block|

data/lib/glossarist/transforms/concept_to_skos_transform.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "../rdf"
+
+module Glossarist
+  module Transforms
+    class ConceptToSkosTransform
+      def self.transform(managed_concept, options = {})
+        new(managed_concept, options).build
+      end
+
+      def self.transform_document(concepts, options = {})
+        Rdf::SkosVocabulary.new(
+          id: options[:shortname] || "glossary",
+          title: options[:title],
+          concepts: concepts.map { |c| transform(c, options) },
+        )
+      end
+
+      def initialize(managed_concept, options = {})
+        @concept = managed_concept
+        @options = options
+      end
+
+      def build
+        Rdf::SkosConcept.new(
+          code: concept_code,
+          labels: build_labels,
+          definitions: build_definitions,
+          alt_labels: build_alt_labels,
+          scope_notes: build_scope_notes,
+          domain: build_domain,
+          sources: build_sources,
+          date_accepted: build_date_accepted,
+        )
+      end
+
+      private
+
+      attr_reader :concept, :options
+
+      def concept_code
+        concept.data&.id || concept.identifier
+      end
+
+      def build_labels
+        each_localization.filter_map do |lang, l10n|
+          term = l10n.preferred_terms&.first || l10n.terms&.first
+          next unless term
+
+          Rdf::LocalizedLiteral.new(
+            value: term.designation.to_s,
+            language_code: lang,
+          )
+        end
+      end
+
+      def build_alt_labels
+        each_localization.flat_map do |lang, l10n|
+          preferred_term = l10n.preferred_terms&.first || l10n.terms&.first
+          (l10n.terms || []).reject do |t|
+            t == preferred_term
+          end.filter_map do |term|
+            next unless term.designation
+
+            Rdf::LocalizedLiteral.new(
+              value: term.designation.to_s,
+              language_code: lang,
+            )
+          end
+        end
+      end
+
+      def build_definitions
+        each_localization.filter_map do |lang, l10n|
+          content = l10n.data&.definition&.first&.content
+          next unless content
+
+          Rdf::LocalizedLiteral.new(
+            value: content.to_s,
+            language_code: lang,
+          )
+        end
+      end
+
+      def build_scope_notes
+        each_localization.filter_map do |lang, l10n|
+          note = l10n.data&.notes&.first&.content
+          next unless note
+
+          Rdf::LocalizedLiteral.new(
+            value: note.to_s,
+            language_code: lang,
+          )
+        end
+      end
+
+      def build_domain
+        l10n = concept.localizations.first
+        l10n&.data&.domain
+      end
+
+      def build_sources
+        each_localization.flat_map do |_lang, l10n|
+          Array(l10n.data&.sources).select(&:authoritative?).filter_map do |src|
+            origin = src.origin
+            next unless origin
+
+            origin.ref || origin.text
+          end
+        end.uniq
+      end
+
+      def build_date_accepted
+        date = concept.date_accepted
+        return unless date
+
+        date.date&.iso8601
+      end
+
+      def each_localization
+        return enum_for(:each_localization) unless block_given?
+
+        concept.localizations.each do |l10n|
+          lang = l10n.language_code || l10n.data&.language_code
+          next unless lang
+
+          yield lang, l10n
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/transforms/concept_to_tbx_transform.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "tbx"
+
+module Glossarist
+  module Transforms
+    class ConceptToTbxTransform
+      def self.transform(managed_concept, options = {})
+        new(managed_concept, options).build_entry
+      end
+
+      def self.transform_document(concepts, options = {})
+        doc = Tbx::Document.new
+        body = Tbx::Body.new
+        body.concept_entry = concepts.map { |c| transform(c, options) }
+        text = Tbx::TextElement.new
+        text.body = body
+        doc.text = text
+
+        if options[:title]
+          header = doc.tbx_header || Tbx::TbxHeader.new
+          file_desc = Tbx::FileDesc.new
+          title_stmt = Tbx::TitleStmt.new
+          title = Tbx::Title.new
+          title.content = options[:title]
+          title_stmt.title = title
+          file_desc.title_stmt = title_stmt
+          header.file_desc = file_desc
+          doc.tbx_header = header
+        end
+
+        doc
+      end
+
+      def initialize(managed_concept, options = {})
+        @concept = managed_concept
+        @options = options
+      end
+
+      def build_entry
+        entry = Tbx::ConceptEntry.new
+        entry.id = concept_id
+        entry.lang_sec = build_lang_sections
+        entry
+      end
+
+      private
+
+      attr_reader :concept, :options
+
+      def concept_id
+        prefix = options[:shortname]
+        id = concept.data&.id || concept.identifier
+        prefix ? "#{prefix}_#{id}" : id.to_s
+      end
+
+      def build_lang_sections
+        concept.localizations.filter_map do |l10n|
+          lang = l10n.language_code
+          next unless lang
+
+          ls = Tbx::LangSec.new
+          ls.lang = lang
+
+          term = l10n.preferred_terms&.first || l10n.terms&.first
+          if term&.designation
+            ts = Tbx::TermSec.new
+            t = Tbx::Term.new
+            t.content = term.designation.to_s
+            ts.term = t
+            ls.term_sec = ts
+          end
+
+          definition = l10n.data&.definition&.first&.content
+          if definition
+            ds = Tbx::Descrip.new
+            ds.content = definition.to_s
+            ls.descrip = ds
+          end
+
+          ls
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/transforms.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Transforms
+    autoload :ConceptToSkosTransform,
+             "glossarist/transforms/concept_to_skos_transform"
+    autoload :ConceptToTbxTransform,
+             "glossarist/transforms/concept_to_tbx_transform"
+  end
+end

data/lib/glossarist/version.rb

@@ -4,5 +4,5 @@
 #
 
 module Glossarist
-  VERSION = "2.5.1"
+  VERSION = "2.6.0"
 end