glossarist 2.6.6 → 2.6.7

data/lib/glossarist/v2/managed_concept_data.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V2
+    class ManagedConceptData < Glossarist::ManagedConceptData
+      attribute :sources, V2::ConceptSource, collection: true
+      attribute :localizations, V2::LocalizedConcept,
+                collection: Collections::LocalizationCollection,
+                initialize_empty: true
+      attribute :related, V2::RelatedConcept, collection: true
+
+      key_value do
+        map %i[id identifier], to: :id,
+                               with: { to: :id_to_yaml, from: :id_from_yaml }
+        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 }
+        map :sources, to: :sources
+        map :localizations, to: :localizations,
+                            with: { from: :localizations_from_yaml, to: :localizations_to_yaml }
+        map :related, to: :related,
+                      with: { from: :related_from_yaml, to: :related_to_yaml }
+      end
+
+      def localizations_from_yaml(model, value)
+        value.each do |localized_concept_hash|
+          localized_concept = V2::LocalizedConcept.of_yaml(localized_concept_hash)
+          model.localizations.store(localized_concept.language_code,
+                                    localized_concept)
+        end
+      end
+
+      def localizations_to_yaml(model, doc); end
+
+      def related_from_yaml(model, value)
+        return unless value.is_a?(Array)
+
+        model.related = value.map { |r| V2::RelatedConcept.of_yaml(r) }
+      end
+
+      def related_to_yaml(model, doc)
+        return unless model.related&.any?
+
+        doc["related"] = model.related.map(&:to_hash)
+      end
+    end
+  end
+end

data/lib/glossarist/v2/related_concept.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V2
+    class RelatedConcept < Glossarist::RelatedConcept
+      attribute :ref, V2::ConceptRef
+
+      key_value do
+        map :content, to: :content
+        map :type, to: :type
+        map :ref, to: :ref
+      end
+    end
+  end
+end

data/lib/glossarist/v2.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "v2/configuration"
+require_relative "v2/citation"
+require_relative "v2/concept_source"
+require_relative "v2/detailed_definition"
+require_relative "v2/concept_ref"
+require_relative "v2/related_concept"
+require_relative "v2/concept_data"
+require_relative "v2/localized_concept"
+require_relative "v2/managed_concept_data"
+require_relative "v2/managed_concept"
+require_relative "v2/concept_document"
+
+module Glossarist
+  module V2
+    Configuration.register_model(Citation, id: :citation)
+    Configuration.register_model(ConceptSource, id: :concept_source)
+    Configuration.register_model(DetailedDefinition, id: :detailed_definition)
+    Configuration.register_model(ConceptData, id: :concept_data)
+    Configuration.register_model(LocalizedConcept, id: :localized_concept)
+    Configuration.register_model(ConceptRef, id: :concept_ref)
+    Configuration.register_model(RelatedConcept, id: :related_concept)
+    Configuration.register_model(ManagedConceptData, id: :managed_concept_data)
+    Configuration.register_model(ManagedConcept, id: :managed_concept)
+    Configuration.register_model(ConceptDocument, id: :concept_document)
+  end
+end

data/lib/glossarist/v3/bibliography_entry.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class BibliographyEntry < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :reference, :string
+      attribute :title, :string
+      attribute :link, :string
+
+      key_value do
+        map :id, to: :id
+        map :reference, to: :reference
+        map :title, to: :title
+        map :link, to: :link
+      end
+    end
+  end
+end

data/lib/glossarist/v3/bibliography_file.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class BibliographyFile < Lutaml::Model::Collection
+      instances :entries, BibliographyEntry
+
+      key_value do
+        map_instances to: :entries
+      end
+
+      def self.from_file(path)
+        return nil unless File.exist?(path)
+
+        from_yaml(File.read(path))
+      end
+
+      def resolve?(anchor)
+        entries.any? { |e| e.id == anchor.to_s }
+      end
+
+      def [](key)
+        entries.find { |e| e.id == key.to_s }
+      end
+    end
+  end
+end

data/lib/glossarist/v3/citation.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class Citation < Glossarist::Citation
+      key_value do
+        map :ref, to: :ref, with: { from: :ref_from_yaml, to: :ref_to_yaml }
+      end
+
+      def ref_from_yaml(model, value)
+        case value
+        when Hash
+          model.ref = Ref.new(value.transform_keys(&:to_sym))
+        when String
+          model.ref = Ref.new(source: value)
+        end
+      end
+
+      def ref_to_yaml(model, doc)
+        return unless model.ref
+
+        attrs = {}
+        attrs["source"] = model.ref.source if model.ref.source
+        attrs["id"] = model.ref.id if model.ref.id
+        attrs["version"] = model.ref.version if model.ref.version
+        doc["ref"] = attrs.empty? ? nil : attrs
+      end
+    end
+  end
+end

data/lib/glossarist/v3/concept_data.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class ConceptData < Glossarist::ConceptData
+      attribute :sources, V3::ConceptSource,
+                collection: Collections::ConceptSourceCollection,
+                initialize_empty: true
+      attribute :definition, V3::DetailedDefinition,
+                collection: Collections::DetailedDefinitionCollection,
+                initialize_empty: true
+      attribute :examples, V3::DetailedDefinition,
+                collection: Collections::DetailedDefinitionCollection,
+                initialize_empty: true
+      attribute :notes, V3::DetailedDefinition,
+                collection: Collections::DetailedDefinitionCollection,
+                initialize_empty: true
+      attribute :related, V3::RelatedConcept, collection: true
+
+      key_value do
+        map :dates, to: :dates
+        map :definition, to: :definition
+        map :examples, to: :examples
+        map :id, to: :id
+        map %i[lineage_source_similarity lineageSourceSimilarity],
+            to: :lineage_source_similarity
+        map :notes, to: :notes
+        map :release, to: :release
+        map :sources, to: :sources
+        map :terms, to: :terms,
+                    with: { from: :terms_from_yaml, to: :terms_to_yaml }
+        map :related, to: :related
+        map :references, to: :references
+        map :domain, to: :domain
+        map %i[language_code languageCode], to: :language_code
+        map :script, to: :script
+        map :system, to: :system
+        map %i[entry_status entryStatus], to: :entry_status
+        map %i[review_date reviewDate], to: :review_date
+        map %i[review_decision_date reviewDecisionDate], to: :review_decision_date
+        map %i[review_decision_event reviewDecisionEvent],
+            to: :review_decision_event
+      end
+    end
+  end
+end

data/lib/glossarist/v3/concept_document.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class ConceptDocument < Glossarist::ConceptDocument
+      attribute :concept, V3::ManagedConcept
+      attribute :localizations, V3::LocalizedConcept, collection: true
+
+      yamls do
+        sequence do
+          map_document 0, to: :concept, type: V3::ManagedConcept
+          map_document 1.., to: :localizations, type: V3::LocalizedConcept,
+                                             collection: true
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/v3/concept_ref.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class ConceptRef < Glossarist::ConceptRef
+    end
+  end
+end

data/lib/glossarist/v3/concept_source.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class ConceptSource < Glossarist::ConceptSource
+      attribute :origin, V3::Citation
+
+      key_value do
+        map :origin, to: :origin
+        map :status, to: :status
+        map :type, to: :type
+        map :modification, to: :modification
+      end
+    end
+  end
+end

data/lib/glossarist/v3/configuration.rb

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

data/lib/glossarist/v3/detailed_definition.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class DetailedDefinition < Glossarist::DetailedDefinition
+      attribute :sources, V3::ConceptSource, collection: true
+
+      key_value do
+        map :content, to: :content
+        map :sources, to: :sources
+      end
+    end
+  end
+end

data/lib/glossarist/v3/image_entry.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class ImageEntry < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :path, :string
+      attribute :type, :string, default: -> { "image" }
+      attribute :title, :string
+      attribute :alt, :string
+
+      key_value do
+        map :id, to: :id
+        map :path, to: :path
+        map :type, to: :type
+        map :title, to: :title
+        map :alt, to: :alt
+      end
+    end
+  end
+end

data/lib/glossarist/v3/image_file.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class ImageFile < Lutaml::Model::Collection
+      instances :entries, ImageEntry
+
+      key_value do
+        map_instances to: :entries
+      end
+
+      def self.from_file(path)
+        return nil unless File.exist?(path)
+
+        from_yaml(File.read(path))
+      end
+
+      def path_for_anchor(anchor)
+        entries.find { |e| e.id == anchor.to_s }&.path
+      end
+
+      def anchor_for_path(path)
+        entries.find { |e| e.path == path }&.id
+      end
+
+      def path?(path)
+        entries.any? { |e| e.path == path }
+      end
+    end
+  end
+end

data/lib/glossarist/v3/localized_concept.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class LocalizedConcept < Glossarist::LocalizedConcept
+      attribute :data, V3::ConceptData, default: -> { V3::ConceptData.new }
+    end
+  end
+end

data/lib/glossarist/v3/managed_concept.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class ManagedConcept < Glossarist::ManagedConcept
+      attribute :data, V3::ManagedConceptData, default: -> { V3::ManagedConceptData.new }
+      attribute :related, V3::RelatedConcept, collection: true
+      attribute :sources, V3::ConceptSource, collection: true
+
+      key_value do
+        map :data, to: :data
+        map :id, with: { to: :identifier_to_yaml, from: :identifier_from_yaml }
+        map :identifier,
+            with: { to: :identifier_to_yaml, from: :identifier_from_yaml }
+        map :related, to: :related
+        map :dates, to: :dates
+        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
+        map :sources, to: :sources
+      end
+    end
+  end
+end

data/lib/glossarist/v3/managed_concept_data.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class ManagedConceptData < Glossarist::ManagedConceptData
+      attribute :sources, V3::ConceptSource, collection: true
+      attribute :localizations, V3::LocalizedConcept,
+                collection: Collections::LocalizationCollection,
+                initialize_empty: true
+
+      key_value do
+        map %i[id identifier], to: :id,
+                               with: { to: :id_to_yaml, from: :id_from_yaml }
+        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 }
+        map :sources, to: :sources
+        map :localizations, to: :localizations,
+                            with: { from: :localizations_from_yaml, to: :localizations_to_yaml }
+      end
+
+      def localizations_from_yaml(model, value)
+        value.each do |localized_concept_hash|
+          localized_concept = V3::LocalizedConcept.of_yaml(localized_concept_hash)
+          model.localizations.store(localized_concept.language_code,
+                                    localized_concept)
+        end
+      end
+
+      def localizations_to_yaml(model, doc); end
+    end
+  end
+end

data/lib/glossarist/v3/related_concept.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    class RelatedConcept < Glossarist::RelatedConcept
+      attribute :ref, V3::ConceptRef
+
+      key_value do
+        map :content, to: :content
+        map :type, to: :type
+        map :ref, to: :ref
+      end
+    end
+  end
+end

data/lib/glossarist/v3.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "v3/configuration"
+require_relative "v3/citation"
+require_relative "v3/concept_source"
+require_relative "v3/detailed_definition"
+require_relative "v3/concept_ref"
+require_relative "v3/related_concept"
+require_relative "v3/concept_data"
+require_relative "v3/localized_concept"
+require_relative "v3/managed_concept_data"
+require_relative "v3/managed_concept"
+require_relative "v3/concept_document"
+require_relative "v3/bibliography_entry"
+require_relative "v3/bibliography_file"
+require_relative "v3/image_entry"
+require_relative "v3/image_file"
+
+module Glossarist
+  module V3
+    Configuration.register_model(Citation, id: :citation)
+    Configuration.register_model(ConceptSource, id: :concept_source)
+    Configuration.register_model(DetailedDefinition, id: :detailed_definition)
+    Configuration.register_model(ConceptData, id: :concept_data)
+    Configuration.register_model(LocalizedConcept, id: :localized_concept)
+    Configuration.register_model(ConceptRef, id: :concept_ref)
+    Configuration.register_model(RelatedConcept, id: :related_concept)
+    Configuration.register_model(ManagedConceptData, id: :managed_concept_data)
+    Configuration.register_model(ManagedConcept, id: :managed_concept)
+    Configuration.register_model(ConceptDocument, id: :concept_document)
+    Configuration.register_model(BibliographyEntry, id: :bibliography_entry)
+    Configuration.register_model(BibliographyFile, id: :bibliography_file)
+    Configuration.register_model(ImageEntry, id: :image_entry)
+    Configuration.register_model(ImageFile, id: :image_file)
+  end
+end

data/lib/glossarist/validation/bibliography_index.rb

@@ -3,9 +3,6 @@
 module Glossarist
   module Validation
     class BibliographyIndex
-      BIB_ENTRY_KEYS = %w[id ref text anchor].freeze
-      private_constant :BIB_ENTRY_KEYS
-
       attr_reader :entries
 
       def initialize
@@ -28,14 +25,22 @@ module Glossarist
         @entries.each_value(&block)
       end
 
-      def self.build_from_concepts(concepts, dataset_path: nil,
-bibliography_yaml: nil)
+      def self.build_from_concepts(concepts, dataset_path: nil)
         index = new
 
         concepts.each { |concept| index_concept_sources(index, concept) }
+        index_bibliography_file(index, dataset_path)
+        index_images_file(index, dataset_path)
+
+        index
+      end
+
+      def self.build_from_yaml(concepts, bibliography_yaml: nil, images_yaml: nil)
+        index = new
 
-        yaml = bibliography_yaml || read_bibliography_file(dataset_path)
-        index_bibliography_yaml(index, yaml) if yaml
+        concepts.each { |concept| index_concept_sources(index, concept) }
+        index_bib_from_yaml_string(index, bibliography_yaml)
+        index_images_from_yaml_string(index, images_yaml)
 
         index
       end
@@ -49,13 +54,6 @@ bibliography_yaml: nil)
       class << self
         private
 
-        def read_bibliography_file(dataset_path)
-          return nil unless dataset_path
-
-          bib_path = File.join(dataset_path, "bibliography.yaml")
-          File.exist?(bib_path) ? File.read(bib_path) : nil
-        end
-
         def index_concept_sources(index, concept)
           concept.localizations.each do |l10n|
             index_l10n_sources(index, l10n)
@@ -86,33 +84,66 @@ bibliography_yaml: nil)
         end
 
         def register_origin_text(index, origin)
-          return unless origin.text && !origin.text.strip.empty?
+          ref = origin.ref
+          return unless ref && ref.source && !ref.source.strip.empty?
 
-          index.register(origin.text, origin)
+          index.register(ref.source, origin)
         end
 
         def register_origin_ref(index, origin)
-          return unless origin.source && origin.id
+          ref = origin.ref
+          return unless ref && ref.source && ref.id
 
-          key = "#{origin.source} #{origin.id}"
+          key = "#{ref.source} #{ref.id}"
           index.register(key, origin)
-          index.register(origin.id.to_s, origin)
+          index.register(ref.id.to_s, origin)
         end
 
-        def index_bibliography_yaml(index, yaml_content)
-          data = YAML.safe_load(yaml_content)
-          return unless data.is_a?(Hash) || data.is_a?(Array)
+        def index_bibliography_file(index, dataset_path)
+          return unless dataset_path
 
-          entries = data.is_a?(Hash) ? data.values : data
-          entries.each do |entry|
-            next unless entry.is_a?(Hash)
+          bib = V3::BibliographyFile.from_file(
+            File.join(dataset_path, "bibliography.yaml"),
+          )
+          return unless bib
 
-            BIB_ENTRY_KEYS.each do |key|
-              val = entry[key]
-              index.register(val.to_s, entry) if val && !val.to_s.strip.empty?
-            end
+          bib.entries.each do |entry|
+            index.register(entry.id, entry)
+            index.register(entry.reference, entry) if entry.reference
           end
-        rescue Psych::SyntaxError, Psych::DisallowedClass
+        end
+
+        def index_images_file(index, dataset_path)
+          return unless dataset_path
+
+          images = V3::ImageFile.from_file(
+            File.join(dataset_path, "images.yaml"),
+          )
+          return unless images
+
+          images.entries.each do |entry|
+            index.register(entry.id, entry)
+          end
+        end
+
+        def index_bib_from_yaml_string(index, yaml_content)
+          return unless yaml_content
+
+          bib = V3::BibliographyFile.from_yaml(yaml_content)
+          bib.entries.each do |entry|
+            index.register(entry.id, entry)
+            index.register(entry.reference, entry) if entry.reference
+          end
+        rescue StandardError
+          nil
+        end
+
+        def index_images_from_yaml_string(index, yaml_content)
+          return unless yaml_content
+
+          images = V3::ImageFile.from_yaml(yaml_content)
+          images.entries.each { |entry| index.register(entry.id, entry) }
+        rescue StandardError
           nil
         end
       end

data/lib/glossarist/validation/rules/asciidoc_xref_rule.rb

@@ -21,12 +21,10 @@ module Glossarist
 
           concept.localizations.each do |l10n|
             lang = l10n.language_code || "unknown"
-            texts = extract_texts(l10n)
 
-            texts.each do |text|
+            l10n.text_content.each do |text|
               next unless text
-              refs = extractor.extract_from_text(text)
-              refs.each do |ref|
+              extractor.extract_from_text(text).each do |ref|
                 next unless ref.is_a?(BibliographicReference)
                 next if context.bibliography_index.resolve?(ref.anchor)
 
@@ -43,18 +41,7 @@ module Glossarist
 
           issues
         end
-
-        private
-
-        def extract_texts(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
-        end
       end
     end
   end
 end
-

data/lib/glossarist/validation/rules/authoritative_source_rule.rb

@@ -16,7 +16,8 @@ module Glossarist
         def check(context)
           concept = context.concept
           fname = context.file_name
-          all_sources = gather_all_sources(concept)
+
+          all_sources = concept.localizations.flat_map(&:all_sources)
 
           return [] if all_sources.any? { |s| s.type == "authoritative" }
 
@@ -27,21 +28,7 @@ module Glossarist
             suggestion: "Add at least one source with type: authoritative",
           )]
         end
-
-        private
-
-        def gather_all_sources(concept)
-          sources = []
-          concept.localizations.each do |l10n|
-            (l10n.data&.sources || []).each { |s| sources << s }
-            (l10n.data&.definition || []).each { |d| (d.sources || []).each { |s| sources << s } }
-            (l10n.data&.notes || []).each { |n| (n.sources || []).each { |s| sources << s } }
-            (l10n.data&.examples || []).each { |e| (e.sources || []).each { |s| sources << s } }
-          end
-          sources
-        end
       end
     end
   end
 end
-