glossarist 2.6.6 → 2.6.7

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

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      # Verifies that every entry in localized_concepts map points to a loaded
+      # localization, and that every loaded localization has a corresponding
+      # entry in the map.
+      class LocalizationConsistencyRule < Base
+        def code = "GLS-017"
+        def category = :integrity
+        def severity = "error"
+        def scope = :concept
+
+        def applicable?(context)
+          context.concept.localizations&.any? ||
+            context.concept.data&.localized_concepts&.any?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          lc_map = concept.data&.localized_concepts || {}
+          loaded_langs = concept.localizations&.map(&:language_code)&.compact || []
+
+          # Map has entry but no loaded localization
+          lc_map.each_key do |lang|
+            next if loaded_langs.include?(lang)
+
+            issues << issue(
+              "localized_concepts map has '#{lang}' but no localization loaded",
+              location: fname,
+              suggestion: "Add a localization for '#{lang}' or remove it from the map",
+            )
+          end
+
+          # Loaded localization not in map
+          loaded_langs.each do |lang|
+            next if lc_map.key?(lang)
+
+            issues << issue(
+              "localization '#{lang}' is loaded but not in localized_concepts map",
+              location: fname,
+              suggestion: "Add '#{lang}' to the localized_concepts map",
+            )
+          end
+
+          # UUID mismatch between map and loaded localization
+          concept.localizations.each do |l10n|
+            lang = l10n.language_code
+            next unless lang
+
+            expected_uuid = lc_map[lang]
+            actual_uuid = l10n.uuid
+            next unless expected_uuid && actual_uuid
+            next if expected_uuid == actual_uuid
+
+            issues << issue(
+              "UUID mismatch for '#{lang}': map says '#{expected_uuid}', localization is '#{actual_uuid}'",
+              location: fname,
+              suggestion: "Ensure the UUID in the map matches the localization file",
+            )
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end

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

@@ -16,7 +16,7 @@ module Glossarist
           return [] if l10ns.any?
 
           [issue("#{fname}: no localizations found",
-                 code: code, severity: "error")]
+                 code: code, severity: "warning")]
         end
       end
     end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class ModelValidityRule < Base
+        def code = "GLS-050"
+        def category = :structure
+        def severity = "error"
+        def scope = :concept
+
+        def applicable?(context)
+          context.concept.is_a?(Lutaml::Model::Serializable)
+        end
+
+        def check(context)
+          validate_recursive(context.concept, context.file_name)
+        end
+
+        private
+
+        def validate_recursive(model, location, path = "")
+          return [] unless model.is_a?(Lutaml::Model::Serializable)
+
+          issues = collect_model_errors(model, location, path)
+          issues.concat(recurse_attributes(model, location, path))
+          issues
+        end
+
+        def collect_model_errors(model, location, path)
+          errors = model.validate
+          return [] if errors.empty?
+
+          prefix = path.empty? ? "" : "#{path}: "
+          errors.map { |e| issue("#{prefix}#{e}", location: location) }
+        end
+
+        def recurse_attributes(model, location, path)
+          issues = []
+
+          model.class.attributes.each do |name, _|
+            value = model.public_send(name)
+            next if value.nil?
+
+            child_path = build_path(path, name)
+            issues.concat(validate_collection(value, location, child_path))
+          end
+
+          issues
+        end
+
+        def validate_collection(value, location, path)
+          case value
+          when Array
+            value.each_with_index.flat_map do |item, idx|
+              validate_recursive(item, location, "#{path}[#{idx}]")
+            end
+          when Lutaml::Model::Serializable
+            validate_recursive(value, location, path)
+          else
+            []
+          end
+        end
+
+        def build_path(parent, name)
+          parent.empty? ? name.to_s : "#{parent}.#{name}"
+        end
+      end
+    end
+  end
+end

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

@@ -20,8 +20,7 @@ module Glossarist
 
           context.concepts.each do |concept|
             concept.localizations.each do |l10n|
-              texts = extract_texts(l10n)
-              texts.each do |text|
+              l10n.text_content.each do |text|
                 next unless text
                 extractor.extract_from_text(text).each do |ref|
                   if ref.is_a?(BibliographicReference)
@@ -47,18 +46,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/orphaned_images_rule.rb

@@ -18,10 +18,8 @@ module Glossarist
           referenced_paths = Set.new
 
           context.concepts.each do |concept|
-            # Text-embedded image refs
             concept.localizations.each do |l10n|
-              texts = extract_texts(l10n)
-              texts.each do |text|
+              l10n.text_content.each do |text|
                 next unless text
                 extractor.extract_from_text(text).each do |ref|
                   if ref.is_a?(AssetReference)
@@ -31,12 +29,20 @@ module Glossarist
               end
             end
 
-            # Model-level asset refs
             extractor.extract_asset_refs_from_concept(concept).each do |ref|
               referenced_paths.add(ref.path)
             end
           end
 
+          images_file = load_images_file(context)
+          if images_file
+            context.bibliography_index.entries.each_value do |entry|
+              next unless entry[:source].is_a?(V3::ImageEntry)
+              path = entry[:source].path
+              referenced_paths.add(path) if path
+            end
+          end
+
           issues = []
           context.asset_index.each_path do |path|
             next if referenced_paths.include?(path)
@@ -54,15 +60,14 @@ module Glossarist
 
         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
+        def load_images_file(context)
+          return @images_file if defined?(@images_file)
+
+          @images_file = V3::ImageFile.from_file(
+            File.join(context.path, "images.yaml")
+          )
         end
       end
     end
   end
 end
-