glossarist 2.6.6 → 2.6.7

data/lib/glossarist/dataset_validator.rb

@@ -2,6 +2,10 @@
 
 module Glossarist
   class DatasetValidator
+    def initialize(on_progress: nil)
+      @on_progress = on_progress
+    end
+
     def validate(path, strict: false, reference_path: nil)
       if File.extname(path).downcase == ".gcr"
         validate_gcr(path, reference_path: reference_path)
@@ -13,7 +17,7 @@ module Glossarist
     private
 
     def validate_gcr(path, reference_path: nil)
-      result = GcrValidator.new.validate(path)
+      result = GcrValidator.new(on_progress: @on_progress).validate(path)
 
       if reference_path
         ref_result = validate_gcr_cross_references(path, reference_path)
@@ -24,7 +28,7 @@ module Glossarist
     end
 
     def validate_directory(path, reference_path: nil)
-      result = ConceptValidator.new(path).validate_all
+      result = ConceptValidator.new(path, on_progress: @on_progress).validate_all
 
       if reference_path
         ref_result = validate_directory_cross_references(path, reference_path)
@@ -38,7 +42,7 @@ module Glossarist
       extractor = ReferenceExtractor.new
       resolver = build_resolver(reference_path)
       pkg = GcrPackage.load(path)
-      uri_prefix = pkg.metadata&.dig("uri_prefix") || pkg.metadata&.dig("shortname")
+      uri_prefix = pkg.metadata&.uri_prefix || pkg.metadata&.shortname
       resolver.register_self(pkg.concepts)
       resolver.register_package(pkg, uri_prefix: uri_prefix)
       resolver.validate_all(pkg, extractor: extractor)
@@ -56,7 +60,7 @@ module Glossarist
       resolver = ReferenceResolver.new
       Dir.glob(File.join(reference_path, "*.gcr")).each do |gcr_path|
         pkg = GcrPackage.load(gcr_path)
-        uri_prefix = pkg.metadata&.dig("uri_prefix") || pkg.metadata&.dig("shortname")
+        uri_prefix = pkg.metadata&.uri_prefix || pkg.metadata&.shortname
         resolver.register_package(pkg, uri_prefix: uri_prefix)
       end
       resolver

data/lib/glossarist/designation/prefix.rb

@@ -0,0 +1,17 @@
+module Glossarist
+  module Designation
+    class Prefix < Base
+      attribute :type, :string, default: -> { "prefix" }
+
+      key_value do
+        map :type, to: :type, render_default: true
+      end
+
+      def self.of_yaml(hash, options = {})
+        hash["type"] = "prefix" unless hash["type"]
+
+        super
+      end
+    end
+  end
+end

data/lib/glossarist/designation/suffix.rb

@@ -0,0 +1,17 @@
+module Glossarist
+  module Designation
+    class Suffix < Base
+      attribute :type, :string, default: -> { "suffix" }
+
+      key_value do
+        map :type, to: :type, render_default: true
+      end
+
+      def self.of_yaml(hash, options = {})
+        hash["type"] = "suffix" unless hash["type"]
+
+        super
+      end
+    end
+  end
+end

data/lib/glossarist/gcr_metadata.rb

@@ -12,7 +12,7 @@ module Glossarist
     attribute :languages, :string, collection: true
     attribute :created_at, :string
     attribute :glossarist_version, :string
-    attribute :schema_version, :string, default: -> { "1.0.0" }
+    attribute :schema_version, :string, default: -> { Glossarist::SCHEMA_VERSION }
     attribute :statistics, GcrStatistics
     attribute :homepage, :string
     attribute :repository, :string
@@ -46,18 +46,19 @@ module Glossarist
 
     def self.from_concepts(concepts, register_data: nil, options: {})
       stats = GcrStatistics.from_concepts(concepts)
+      rd = register_data
       new(
-        shortname: options[:shortname] || register_data&.dig("shortname") || register_data&.dig("id"),
-        version: options[:version] || register_data&.dig("version"),
-        title: options[:title] || register_data&.dig("name"),
-        description: options[:description] || register_data&.dig("description"),
+        shortname: options[:shortname] || rd&.[]("shortname") || rd&.[]("id"),
+        version: options[:version] || rd&.[]("version"),
+        title: options[:title] || rd&.[]("name"),
+        description: options[:description] || rd&.[]("description"),
         owner: options[:owner],
         tags: options[:tags] || [],
         concept_count: concepts.length,
         languages: stats.languages,
         created_at: Time.now.utc.iso8601,
         glossarist_version: Glossarist::VERSION,
-        schema_version: register_data&.dig("schema_version") || SchemaMigration::CURRENT_SCHEMA_VERSION,
+        schema_version: rd&.[]("schema_version") || SchemaMigration::CURRENT_SCHEMA_VERSION,
         statistics: stats,
         uri_prefix: options[:uri_prefix],
         concept_uri_template: options[:concept_uri_template],
@@ -78,13 +79,5 @@ module Glossarist
       end
       sources.map { |uri| { "uri" => uri } }
     end
-
-    def [](key)
-      to_yaml_hash[key]
-    end
-
-    def dig(*keys)
-      to_yaml_hash.dig(*keys)
-    end
   end
 end

data/lib/glossarist/gcr_package.rb

@@ -156,31 +156,41 @@ module Glossarist
     end
 
     def read_file_assets(zip_file)
-      DATASET_ASSETS.each do |asset|
-        next unless asset[:type] == :file && asset[:attr]
-
-        entry = zip_file.find_entry(asset[:path])
-        next unless entry
-
-        instance_variable_set("@#{asset[:attr]}", entry.get_input_stream.read)
-      end
+      entry = zip_file.find_entry("bibliography.yaml")
+      @bibliography = entry.get_input_stream.read if entry
     end
 
     def read_concepts(zip_file)
+      doc_class = concept_document_class_for_read
       zip_file.entries.each do |entry|
         next unless entry.name.start_with?("concepts/") && entry.name.end_with?(".yaml")
 
         raw = entry.get_input_stream.read
-        doc = ConceptDocument.from_yamls(raw)
+        doc = doc_class.from_yamls(raw)
         @concepts << doc.to_managed_concept
       end
     end
 
     private
 
+    def concept_document_class_for_read
+      version = @metadata&.schema_version.to_s
+      ConceptDocument.for_version(version)
+    end
+
+    def concept_document_class_for_write(concept)
+      version = if concept.schema_version.to_s == "2"
+                  "2"
+                else
+                  "3"
+                end
+      ConceptDocument.for_version(version)
+    end
+
     def write_concept(zip_file, concept)
       termid = concept.data.id.to_s
-      doc = ConceptDocument.from_managed_concept(concept)
+      doc_class = concept_document_class_for_write(concept)
+      doc = doc_class.from_managed_concept(concept)
       zip_file.get_output_stream("concepts/#{termid}.yaml") do |f|
         f.write(doc.to_yamls)
       end
@@ -215,19 +225,21 @@ module Glossarist
     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)
+      require "glossarist/transforms/concept_to_gloss_transform"
+
+      if formats.include?("jsonld") || formats.include?("turtle")
+        transform = Transforms::ConceptToGlossTransform.new(nil, opts)
 
-      if formats.include?("jsonld")
-        zip_file.get_output_stream("compiled/#{name}.jsonld") do |f|
-          f.write(vocab.to_jsonld)
+        if formats.include?("jsonld")
+          zip_file.get_output_stream("compiled/#{name}.jsonld") do |f|
+            f.write(transform.to_jsonld(concepts))
+          end
         end
-      end
 
-      if formats.include?("turtle")
-        zip_file.get_output_stream("compiled/#{name}.ttl") do |f|
-          f.write(vocab.to_turtle)
+        if formats.include?("turtle")
+          zip_file.get_output_stream("compiled/#{name}.ttl") do |f|
+            f.write(transform.to_turtle(concepts))
+          end
         end
       end
 
@@ -235,8 +247,8 @@ module Glossarist
 
       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)
+          transform = Transforms::ConceptToGlossTransform.new(concept, opts)
+          f.write(transform.to_jsonl_line)
           f.write("\n")
         end
       end
@@ -343,7 +355,7 @@ compiled_formats: [], **opts)
           languages: languages.sort,
           created_at: Time.now.utc.iso8601,
           glossarist_version: Glossarist::VERSION,
-          schema_version: register_data&.dig("schema_version") || SchemaMigration::CURRENT_SCHEMA_VERSION,
+          schema_version: register_data&.[]("schema_version") || SchemaMigration::CURRENT_SCHEMA_VERSION,
           uri_prefix: opts[:uri_prefix],
           concept_uri_template: opts[:concept_uri_template],
         )

data/lib/glossarist/gcr_validator.rb

@@ -4,6 +4,10 @@ require "zip"
 
 module Glossarist
   class GcrValidator
+    def initialize(on_progress: nil)
+      @on_progress = on_progress
+    end
+
     def validate(zip_path)
       result = ValidationResult.new
 
@@ -24,27 +28,36 @@ module Glossarist
         return result
       end
 
-      begin
-        context = Validation::Rules::GcrContext.new(zip_path)
-      rescue StandardError => e
-        result.add_error("Failed to load GCR: #{e.message}")
-        return result
-      end
+      context, all_concepts = load_gcr_context(zip_path, result)
+      return result if all_concepts.nil?
 
-      # Collection-level rules (metadata, structure, integrity)
-      collection_rules = Validation::Rules::Registry.for_scope(:collection)
-      collection_rules.each do |rule|
-        next unless rule.applicable?(context)
+      validate_concepts(context, all_concepts, result)
+      validate_collection(context, result)
 
-        rule.check(context).each { |i| result.add_issue(i) }
-      end
+      result
+    end
 
-      # Per-concept rules
+    private
+
+    def load_gcr_context(zip_path, result)
+      context = Validation::Rules::GcrContext.new(zip_path)
+      pkg = GcrPackage.load(zip_path)
+      [context, pkg.concepts]
+    rescue StandardError => e
+      result.add_error("Failed to load GCR: #{e.message}")
+      [nil, nil]
+    end
+
+    def validate_concepts(context, all_concepts, result)
       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"
+      total = all_concepts.length
+
+      all_concepts.each_with_index do |concept, idx|
+        context.add_concept(concept)
         concept_context = Validation::Rules::ConceptContext.new(
-          concept, file_name: fname, collection_context: context
+          concept,
+          file_name: concept.data&.id ? "concepts/#{concept.data.id}.yaml" : "concepts/concept-#{idx}.yaml",
+          collection_context: context,
         )
 
         concept_rules.each do |rule|
@@ -52,9 +65,17 @@ module Glossarist
 
           rule.check(concept_context).each { |i| result.add_issue(i) }
         end
+
+        @on_progress&.call(idx + 1, total)
       end
+    end
 
-      result
+    def validate_collection(context, result)
+      Validation::Rules::Registry.for_scope(:collection).each do |rule|
+        next unless rule.applicable?(context)
+
+        rule.check(context).each { |i| result.add_issue(i) }
+      end
     end
   end
 end

data/lib/glossarist/localized_concept.rb

@@ -37,5 +37,13 @@ module Glossarist
     def entry_status=(value)
       data.entry_status = value
     end
+
+    def all_sources
+      data.all_sources
+    end
+
+    def text_content
+      data.text_content
+    end
   end
 end

data/lib/glossarist/managed_concept.rb

@@ -8,7 +8,7 @@ module Glossarist
 
     attribute :related, RelatedConcept, collection: true
     attribute :dates, ConceptDate, collection: true
-    attribute :sources, ConceptSource
+    attribute :sources, ConceptSource, collection: true
     attribute :date_accepted, ConceptDate
     attribute :status, :string,
               values: Glossarist::GlossaryDefinition::CONCEPT_STATUSES
@@ -19,6 +19,8 @@ module Glossarist
 
     attribute :uuid, :string
 
+    attribute :schema_version, :string
+
     key_value do
       map :data, to: :data
       map :id, with: { to: :identifier_to_yaml, from: :identifier_from_yaml }
@@ -26,11 +28,13 @@ module Glossarist
           with: { to: :identifier_to_yaml, from: :identifier_from_yaml }
       map :related, to: :related
       map :dates, to: :dates
+      map :sources, to: :sources
       map %i[date_accepted dateAccepted],
           with: { from: :date_accepted_from_yaml, to: :date_accepted_to_yaml }
       map :status, to: :status
 
       map :uuid, to: :uuid, with: { from: :uuid_from_yaml, to: :uuid_to_yaml }
+      map :schema_version, to: :schema_version
     end
 
     def localizations
@@ -65,7 +69,7 @@ module Glossarist
     def uuid
       @uuid ||= Glossarist::Utilities::UUID.uuid_v5(
         Glossarist::Utilities::UUID::OID_NAMESPACE,
-        to_yaml(except: [:uuid]),
+        to_yaml(except: %i[uuid schema_version]),
       )
     end
 
@@ -109,18 +113,19 @@ module Glossarist
       data.localized_concepts ||= {}
       data.localized_concepts[lang] =
         data.localized_concepts[lang] || localized_concept.uuid
+      localized_concept.uuid = data.localized_concepts[lang]
       localizations.store(lang, localized_concept)
     end
     alias :add_l10n :add_localization
 
     def to_jsonld
-      require "glossarist/transforms/concept_to_skos_transform"
-      Transforms::ConceptToSkosTransform.transform(self).to_jsonld
+      require "glossarist/transforms/concept_to_gloss_transform"
+      Transforms::ConceptToGlossTransform.transform(self).to_jsonld
     end
 
     def to_turtle
-      require "glossarist/transforms/concept_to_skos_transform"
-      Transforms::ConceptToSkosTransform.transform(self).to_turtle
+      require "glossarist/transforms/concept_to_gloss_transform"
+      Transforms::ConceptToGlossTransform.transform(self).to_turtle
     end
 
     def default_designation
@@ -138,6 +143,34 @@ module Glossarist
       localization("eng") || localizations.values.first
     end
 
+    def schema_version
+      @schema_version
+    end
+
+    def assign_uuid(new_uuid)
+      @uuid = new_uuid
+    end
+
+    def self.detect_schema_version(concept) # rubocop:disable Metrics/PerceivedComplexity
+      raw = concept.schema_version
+      if raw && !%w[legacy nil].include?(raw.to_s)
+        return raw.to_s
+      end
+
+      return "3" if concept.related&.any?
+      return "3" if concept.sources&.any?
+      return "3" if concept.data&.domains&.any?
+      return "3" if localization_has_references?(concept)
+
+      "2"
+    end
+
+    def self.localization_has_references?(concept)
+      concept.localizations&.any? do |l10n|
+        l10n.is_a?(LocalizedConcept) && l10n.data&.references&.any?
+      end
+    end
+
     Glossarist::GlossaryDefinition::RELATED_CONCEPT_TYPES.each do |type|
       # List of related concepts of the specified type.
       # @return [Array<RelatedConcept>]

data/lib/glossarist/managed_concept_data.rb

@@ -10,6 +10,7 @@ module Glossarist
     attribute :localizations, LocalizedConcept,
               collection: Collections::LocalizationCollection,
               initialize_empty: true
+    attribute :related, RelatedConcept, collection: true
 
     key_value do
       map %i[id identifier], to: :id,
@@ -17,7 +18,7 @@ module Glossarist
       map :uri, to: :uri
       map %i[localized_concepts localizedConcepts], to: :localized_concepts
       map %i[domains groups], to: :domains,
-                             with: { from: :domains_from_yaml, to: :domains_to_yaml }
+                              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 }

data/lib/glossarist/rdf/ext/jsonld_transform_ext.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "json"
+
+# Extends Lutaml::JsonLd::Transform to handle:
+# - Multiple rdf:type values
+# - URI-valued predicates (as: :uri)
+# - Linking predicates for members (link option)
+# - Recursive context/namespace collection
+# - Recursive graph document building
+module Lutaml
+  module JsonLd
+    class Transform < Lutaml::Rdf::Transform
+      def model_to_data(instance, _format, options = {})
+        mapping = extract_mapping(options)
+        return {} unless mapping
+
+        if mapping.rdf_members.any?
+          build_graph_document(mapping, instance)
+        else
+          build_resource_object(mapping, instance)
+        end
+      end
+
+      def data_to_model(data, _format, options = {})
+        mapping = extract_mapping(options)
+        return model_class.new unless mapping
+
+        hash = data.is_a?(String) ? JSON.parse(data) : data
+
+        if hash.key?("@graph") && hash["@graph"].is_a?(Array) && !hash["@graph"].empty?
+          graph_data = hash["@graph"]
+          first = graph_data.first
+          hash = first.is_a?(Hash) ? first : {}
+        end
+
+        hash = strip_jsonld_keywords(hash)
+
+        attrs = {}
+        mapping.rdf_predicates.each do |rule|
+          value = hash[rule.predicate_name]
+          next if value.nil?
+
+          attrs[rule.to] = if rule.lang_tagged && value.is_a?(Hash)
+                             flatten_language_map(value)
+                           else
+                             value
+                           end
+        end
+
+        build_instance(attrs, options)
+      end
+
+      private
+
+      def extract_mapping(options)
+        options[:mappings] || mappings_for(:jsonld, lutaml_register)
+      end
+
+      def build_graph_document(mapping, instance)
+        context = build_merged_context_recursive(mapping, instance)
+        graph = collect_resources(mapping, instance)
+
+        { "@context" => context, "@graph" => graph }
+      end
+
+      def collect_resources(mapping, instance)
+        graph = []
+
+        if mapping.rdf_subject
+          resource = build_resource_data(mapping, instance)
+          graph << resource unless resource.empty?
+        end
+
+        mapping.rdf_members.each do |member_rule|
+          collection = Array(instance.public_send(member_rule.attr_name))
+          collection.each do |member|
+            member_mapping = member.class.mappings[:jsonld]
+            next unless member_mapping
+
+            resource = build_resource_data(member_mapping, member)
+            graph << resource unless resource.empty?
+
+            # Recurse into child members
+            child_resources = collect_resources(member_mapping, member)
+            # Skip the first entry (already added above) and any empty resources
+            child_resources[1..-1].each { |r| graph << r }
+          end
+        end
+
+        graph
+      end
+
+      def build_merged_context_recursive(mapping, instance)
+        context_hash = build_context_from_mapping(mapping).to_hash
+
+        mapping.rdf_members.each do |member_rule|
+          collection = Array(instance.public_send(member_rule.attr_name))
+          next if collection.empty?
+
+          collection.map(&:class).uniq.each do |klass|
+            member_mapping = klass.mappings[:jsonld]
+            next unless member_mapping
+
+            context_hash.merge!(build_context_from_mapping(member_mapping).to_hash)
+
+            # Recurse into child members
+            child_ctx = build_merged_context_recursive(member_mapping, collection.first)
+            context_hash.merge!(child_ctx)
+          end
+        end
+
+        context_hash
+      end
+
+      def build_context_from_mapping(mapping)
+        context = Context.new
+        mapping.namespace_set.each { |ns| context.prefix(ns) }
+        mapping.rdf_predicates.each do |pred|
+          if pred.lang_tagged
+            context.term(pred.predicate_name,
+                         id: pred.uri,
+                         container: :language)
+          else
+            context.term(pred.predicate_name, id: pred.uri)
+          end
+        end
+        context
+      end
+
+      def build_resource_object(mapping, instance)
+        context = build_context_from_mapping(mapping).to_hash
+        data = build_resource_data(mapping, instance)
+        { "@context" => context }.merge(data)
+      end
+
+      def build_resource_data(mapping, instance)
+        result = {}
+
+        if mapping.rdf_types.any?
+          types = mapping.rdf_types.map do |t|
+            mapping.namespace_set.resolve_compact_iri(t)
+          end
+          result["@type"] = types.length == 1 ? types.first : types
+        end
+
+        if mapping.rdf_subject
+          result["@id"] = resolve_subject_uri(mapping, instance)
+        end
+
+        mapping.rdf_predicates.each do |rule|
+          value = instance.public_send(rule.to)
+          next if value.nil?
+          next if value.is_a?(String) && value.empty?
+
+          result[rule.predicate_name] = if rule.lang_tagged
+                                          build_language_map(value)
+                                        else
+                                          serialize_rdf_value(value, rule, mapping)
+                                        end
+        end
+
+        # Emit variable-predicate relationship triples
+        if instance.is_a?(Glossarist::Rdf::Relationships)
+          Array(instance.relationship_triples).each do |pred_uri, obj_uri|
+            key = pred_uri.split("#").last.split("/").last
+            result[key] = { "@id" => obj_uri }
+          end
+        end
+
+        result
+      end
+
+      def build_language_map(values)
+        case values
+        when Array
+          map = {}
+          values.each do |v|
+            lang = extract_language(v)
+            map[lang] = v.to_s if lang
+          end
+          map.empty? ? nil : map
+        else
+          lang = extract_language(values)
+          lang ? { lang => values.to_s } : values.to_s
+        end
+      end
+
+      def flatten_language_map(lang_map)
+        lang_map.values
+      end
+
+      def serialize_rdf_value(value, rule = nil, mapping = nil)
+        case value
+        when Array then value.map { |v| serialize_rdf_value(v, rule, mapping) }
+        when Integer, Float, TrueClass, FalseClass then value
+        else value.to_s
+        end
+      end
+
+      def strip_jsonld_keywords(data)
+        return data unless data.is_a?(Hash)
+
+        data.reject { |key, _| key.start_with?("@") }
+      end
+    end
+  end
+end