glossarist 2.6.5 → 2.6.7

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/asset_index.rb

@@ -94,10 +94,11 @@ module Glossarist
         end
 
         def register_non_verb_rep(index, l10n)
-          nvr = l10n.non_verb_rep
-          return unless nvr.is_a?(String) && !nvr.strip.empty?
+          Array(l10n.non_verb_rep).each do |nvr|
+            next unless nvr.is_a?(NonVerbRep) && nvr.ref && !nvr.ref.strip.empty?
 
-          nvr.strip.split.each { |p| index.register(p) }
+            index.register(nvr.ref.strip)
+          end
         end
 
         def register_graphical_symbols(index, l10n)

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
-

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

@@ -4,6 +4,11 @@ module Glossarist
   module Validation
     module Rules
       class Base
+        def self.inherited(subclass)
+          super
+          Registry.register(subclass)
+        end
+
         def code
           nil
         end

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

@@ -18,9 +18,8 @@ module Glossarist
           return [] unless bib_content
 
           begin
-            data = YAML.safe_load(bib_content)
-            return [] if data.nil? || data.is_a?(Hash) || data.is_a?(Array)
-          rescue Psych::SyntaxError => e
+            V3::BibliographyFile.from_yaml(bib_content)
+          rescue StandardError => e
             return [issue(
               "bibliography.yaml is invalid YAML: #{e.message}",
               code: code, severity: severity,

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

@@ -18,46 +18,24 @@ module Glossarist
           fname = context.file_name
           issues = []
 
-          gather_all_sources(concept).each_with_index do |source, idx|
+          concept.localizations.flat_map(&:all_sources).each_with_index do |source, idx|
             origin = source.origin
             next unless origin
 
-            if origin.text.nil? && origin.source.nil? && origin.id.nil?
+            ref = origin.ref
+            if ref.nil? || (ref.source.nil? && ref.id.nil?)
               issues << issue(
-                "source #{idx + 1} has empty origin (no text, source, or id)",
+                "source #{idx + 1} has empty origin (no ref source or id)",
                 code: "GLS-304", severity: severity,
                 location: fname,
-                suggestion: "Add at minimum an origin.text or origin.source + origin.id",
+                suggestion: "Add at minimum an origin.ref with source or id",
               )
             end
-
-            next unless origin.structured? && origin.source.nil?
-
-            issues << issue(
-              "source #{idx + 1} is structured but missing source field",
-              code: "GLS-304", severity: severity,
-              location: fname,
-              suggestion: "Add origin.source to the citation",
-            )
           end
 
           issues
         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
-

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

@@ -8,14 +8,19 @@ module Glossarist
 
         def initialize(path)
           @path = File.expand_path(path)
-          @concepts = nil
+          @accumulated_concepts = []
           @bibliography_index = nil
           @asset_index = nil
           @declared_languages = nil
         end
 
+        def add_concept(concept)
+          @accumulated_concepts << concept
+          @concept_ids = nil
+        end
+
         def concepts
-          @concepts ||= ConceptCollector.collect(@path)
+          @accumulated_concepts
         end
 
         def concept_ids
@@ -77,7 +82,7 @@ module Glossarist
           reg_path = File.join(@path, "register.yaml")
           return nil unless File.exist?(reg_path)
 
-          YAML.safe_load_file(reg_path)
+          RegisterData.from_file(reg_path)
         end
 
         def build_localization_index

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

@@ -48,7 +48,7 @@ module Glossarist
 
           return if date_value.nil?
 
-          str = date_value.respond_to?(:iso8601) ? date_value.iso8601 : date_value.to_s
+          str = date_value.is_a?(Date) || date_value.is_a?(Time) ? date_value.iso8601 : date_value.to_s
 
           begin
             DateTime.parse(str)

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

@@ -24,7 +24,6 @@ module Glossarist
             lang = l10n.language_code || "unknown"
             terms = l10n.data&.terms || []
             terms.each_with_index do |term, idx|
-              next unless term.respond_to?(:normative_status)
               next if term.normative_status.nil? || term.normative_status.to_s.strip.empty?
 
               unless VALID_STATUSES.include?(term.normative_status.to_s)

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

@@ -43,11 +43,7 @@ module Glossarist
         private
 
         def designation_type(term)
-          if term.is_a?(Hash)
-            term["type"]
-          elsif term.respond_to?(:type)
-            term.type
-          end
+          term.type if term.is_a?(Designation::Base)
         end
       end
     end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class DomainRefRule < Base
+        def code = "GLS-309"
+        def category = :quality
+        def severity = "warning"
+        def scope = :concept
+
+        def applicable?(context)
+          context.concept.data&.domains&.any?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          (concept.data.domains || []).each_with_index do |domain, idx|
+            has_ref = domain.concept_id || domain.urn
+            unless has_ref
+              issues << issue(
+                "domain #{idx + 1} has neither concept_id nor urn",
+                location: fname,
+                suggestion: "Provide at least concept_id or urn for the domain reference",
+              )
+            end
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      # Validates that domain references point to concepts that exist in the
+      # dataset (for local refs with concept_id) or have a valid URN.
+      class DomainTargetRule < Base
+        URN_RE = %r{\Aurn:[a-z0-9][a-z0-9-]{0,31}:[a-z0-9()+,\-.:=@;$_!*'%/?#]+\z}i.freeze
+
+        def code = "GLS-111"
+        def category = :references
+        def severity = "warning"
+        def scope = :concept
+
+        def applicable?(context)
+          context.concept.data&.domains&.any?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          (concept.data.domains || []).each_with_index do |domain, idx|
+            if domain.concept_id && local_domain?(domain)
+              unless context.concept_ids.include?(domain.concept_id)
+                issues << issue(
+                  "domain #{idx + 1} references '#{domain.concept_id}' not in dataset",
+                  location: fname,
+                  suggestion: "Add concept '#{domain.concept_id}' or fix the domain ref",
+                )
+              end
+            elsif domain.urn
+              if domain.urn.start_with?("urn:") && !URN_RE.match?(domain.urn)
+                issues << issue(
+                  "domain #{idx + 1} has invalid URN '#{domain.urn}'",
+                  location: fname,
+                  suggestion: "Fix the URN format",
+                )
+              end
+            end
+          end
+
+          issues
+        end
+
+        private
+
+        def local_domain?(domain)
+          domain.source.nil? || domain.source.strip.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -10,21 +10,20 @@ module Glossarist
 
         def initialize(zip_path)
           @zip_path = zip_path
+          @accumulated_concepts = []
           @metadata = nil
-          @concepts = nil
           @bibliography_index = nil
           @asset_index = nil
           @zip_entries = nil
-          @localization_index = nil
+        end
+
+        def add_concept(concept)
+          @accumulated_concepts << concept
+          @concept_ids = nil
         end
 
         def concepts
-          @concepts ||= begin
-            pkg = GcrPackage.load(@zip_path)
-            pkg.concepts
-          rescue StandardError
-            []
-          end
+          @accumulated_concepts
         end
 
         def concept_ids
@@ -41,11 +40,11 @@ module Glossarist
         end
 
         def bibliography_index
-          @bibliography_index ||= begin
-            bib_yaml = read_zip_file("bibliography.yaml")
-            BibliographyIndex.build_from_concepts(concepts,
-                                                  bibliography_yaml: bib_yaml)
-          end
+          @bibliography_index ||= BibliographyIndex.build_from_yaml(
+            concepts,
+            bibliography_yaml: read_zip_file("bibliography.yaml"),
+            images_yaml: read_zip_file("images.yaml"),
+          )
         end
 
         def asset_index

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

@@ -19,15 +19,12 @@ module Glossarist
           extractor = ReferenceExtractor.new
           issues = []
 
-          # Text-embedded image references (image::path[])
           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?(AssetReference)
                 next if context.asset_index.resolve?(ref.path)
 
@@ -41,7 +38,6 @@ module Glossarist
             end
           end
 
-          # Model-level asset references (NonVerbRep, GraphicalSymbol)
           asset_refs = extractor.extract_asset_refs_from_concept(concept)
           asset_refs.each do |ref|
             next if context.asset_index.resolve?(ref.path)
@@ -56,18 +52,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/locality_completeness_rule.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class LocalityCompletenessRule < Base
+        def code = "GLS-308"
+        def category = :quality
+        def severity = "warning"
+        def scope = :concept
+
+        def applicable?(context)
+          context.concept.localizations&.any?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          all_origins(concept).each_with_index do |origin, idx|
+            next unless origin
+            next unless origin.locality
+
+            loc = origin.locality
+            if loc.type.nil? || loc.type.to_s.strip.empty?
+              issues << issue(
+                "source #{idx + 1} locality has no type",
+                location: fname,
+                suggestion: "Add locality type (e.g. 'clause')",
+              )
+            end
+
+            if loc.reference_from.nil? || loc.reference_from.to_s.strip.empty?
+              issues << issue(
+                "source #{idx + 1} locality has no reference_from",
+                location: fname,
+                suggestion: "Add locality.reference_from (e.g. '3.1.3.10')",
+              )
+            end
+          end
+
+          issues
+        end
+
+        private
+
+        def all_origins(concept)
+          origins = []
+          concept.localizations.each do |l10n|
+            (l10n.data&.sources || []).each { |s| origins << s.origin if s.origin }
+          end
+          origins
+        end
+      end
+    end
+  end
+end