glossarist 2.6.5 → 2.6.7

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
-

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class RefShapeRule < Base
+        def code = "GLS-305"
+        def category = :schema
+        def severity = "error"
+        def scope = :concept
+
+        def applicable?(context)
+          context.concept.localizations&.any?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          check_sources(concept, fname, issues)
+          check_related(concept, fname, issues)
+
+          issues
+        end
+
+        private
+
+        def check_sources(concept, fname, issues)
+          concept.localizations.flat_map(&:all_sources).each_with_index do |source, idx|
+            origin = source.origin
+            next unless origin
+
+            ref = origin.ref
+            if ref.nil?
+              issues << issue(
+                "source #{idx + 1} origin has nil ref (expected Citation::Ref hash)",
+                location: fname,
+                suggestion: "Set origin.ref to { source: ..., id: ... }",
+              )
+            elsif ref.source.nil? && ref.id.nil?
+              issues << issue(
+                "source #{idx + 1} origin.ref has neither source nor id",
+                location: fname,
+                suggestion: "Provide at least origin.ref.source or origin.ref.id",
+              )
+            end
+          end
+        end
+
+        def check_related(concept, fname, issues)
+          (concept.related || []).each_with_index do |rel, idx|
+            ref = rel.ref
+            next unless ref
+
+            if ref.source.nil? && ref.id.nil?
+              issues << issue(
+                "related concept #{idx + 1} has empty ref (no source or id)",
+                location: fname,
+                suggestion: "Provide at least ref.source or ref.id",
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -58,9 +58,7 @@ module Glossarist
           ref = rel.ref
           return nil unless ref
 
-          if ref.is_a?(Glossarist::Citation)
-            ref.id || ref.text
-          end
+          ref.id || ref.source
         end
 
         def detect_cycles(graph)

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

@@ -77,9 +77,7 @@ module Glossarist
           ref = rel.ref
           return nil unless ref
 
-          if ref.is_a?(Glossarist::Citation)
-            ref.id || ref.text
-          end
+          ref.id || ref.source
         end
       end
     end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      # Verifies that related concept refs point to concepts that exist
+      # in the dataset (for local refs) or have valid source/URN (for external).
+      class RelatedConceptTargetRule < Base
+        URN_RE = %r{\Aurn:[a-z0-9][a-z0-9-]{0,31}:[a-z0-9()+,\-.:=@;$_!*'%/?#]+\z}i.freeze
+
+        def code = "GLS-110"
+        def category = :references
+        def severity = "warning"
+        def scope = :concept
+
+        def applicable?(context)
+          context.concept.related&.any?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          (concept.related || []).each_with_index do |rel, idx|
+            ref = rel.ref
+            next unless ref
+
+            id = ref.id
+            source = ref.source
+
+            if id && local_ref?(source)
+              # Local ref — concept_id must exist in dataset
+              unless context.concept_ids.include?(id)
+                issues << issue(
+                  "related concept #{idx + 1} references '#{id}' which is not in the dataset",
+                  location: fname,
+                  suggestion: "Add concept '#{id}' to the dataset or fix the reference",
+                )
+              end
+            elsif source && !id
+              # Source-only ref — should be a valid URN or known format
+              if source.start_with?("urn:") && !URN_RE.match?(source)
+                issues << issue(
+                  "related concept #{idx + 1} has invalid URN '#{source}'",
+                  location: fname,
+                  suggestion: "Fix the URN format (e.g. urn:iso:std:iso:ts:14812)",
+                )
+              end
+            end
+          end
+
+          issues
+        end
+
+        private
+
+        def local_ref?(source)
+          source.nil? || source.strip.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class SchemaVersionRule < Base
+        def code = "GLS-010"
+        def category = :schema
+        def severity = "warning"
+        def scope = :concept
+
+        def applicable?(context)
+          context.concept.is_a?(ManagedConcept)
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          version = concept.schema_version
+          if version.nil? || version.to_s.strip.empty?
+            issues << issue(
+              "concept has no schema_version",
+              location: fname,
+              suggestion: "Add schema_version: \"3\" to the concept",
+            )
+          elsif version.to_s != "3"
+            issues << issue(
+              "concept has schema_version '#{version}', expected '3'",
+              location: fname,
+              suggestion: "Run schema migration to upgrade to version 3",
+            )
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ 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|
             unless VALID_TYPES.include?(source.type)
               issues << issue(
                 "source #{idx + 1} has invalid type '#{source.type}'",
@@ -43,21 +43,7 @@ module Glossarist
 
           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/source_urn_format_rule.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      # Validates that every URN-format source in citations and references
+      # follows a recognized scheme (iso, iec, itu, etc).
+      class SourceUrnFormatRule < Base
+        URN_RE = %r{\Aurn:([a-z0-9][a-z0-9-]{0,31}):(.+)\z}i.freeze
+
+        KNOWN_SCHEMES = %w[
+          iso iec itu iso:std:iso iso:std:iec
+        ].freeze
+
+        def code = "GLS-310"
+        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_refs(concept).each_with_index do |ref_str, idx|
+            next unless ref_str && ref_str.start_with?("urn:")
+
+            match = URN_RE.match(ref_str)
+            unless match
+              issues << issue(
+                "source #{idx + 1} has malformed URN '#{ref_str}'",
+                location: fname,
+                suggestion: "Fix the URN to follow RFC 8141 format",
+              )
+            end
+          end
+
+          issues
+        end
+
+        private
+
+        def all_refs(concept)
+          refs = []
+          concept.localizations.each do |l10n|
+            (l10n.data&.sources || []).each do |s|
+              refs << s.origin&.ref&.source if s.origin&.ref&.source&.start_with?("urn:")
+            end
+          end
+          (concept.data&.domains || []).each do |d|
+            refs << d.urn if d.urn
+          end
+          (concept.related || []).each do |r|
+            refs << r.ref&.source if r.ref&.source&.start_with?("urn:")
+          end
+          refs.compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class UuidFormatRule < Base
+        UUID_RE = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i.freeze
+
+        def code = "GLS-016"
+        def category = :integrity
+        def severity = "error"
+        def scope = :concept
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          uuid = concept.uuid
+          if uuid && !uuid.to_s.empty? && !UUID_RE.match?(uuid.to_s)
+            issues << issue(
+              "concept UUID '#{uuid}' is not valid UUID format",
+              location: fname,
+              suggestion: "Use a valid UUID (e.g. 0ce27901-02ce-531e-8ba5-fdb136139d1a)",
+            )
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/validation/rules.rb

@@ -40,46 +40,13 @@ require_relative "rules/date_type_rule"
 require_relative "rules/language_code_format_rule"
 require_relative "rules/designation_type_rule"
 require_relative "rules/date_validity_rule"
-
-# Register all built-in rules
-module Glossarist
-  module Validation
-    module Rules
-      R = Registry
-
-      R.register(ConceptIdRule)
-      R.register(ConceptIdUniquenessRule)
-      R.register(LocalizationPresenceRule)
-      R.register(EntryStatusRule)
-      R.register(AsciidocXrefRule)
-      R.register(ImageReferenceRule)
-      R.register(ConceptMentionRule)
-      R.register(ConceptCountRule)
-      R.register(LanguageListRule)
-      R.register(LanguageCoverageRule)
-      R.register(FilenameIdRule)
-      R.register(L10nUuidIntegrityRule)
-      R.register(OrphanedL10nFilesRule)
-      R.register(OrphanedBibliographyRule)
-      R.register(OrphanedImagesRule)
-      R.register(DefinitionContentRule)
-      R.register(PreferredTermRule)
-      R.register(DuplicateTermRule)
-      R.register(CitationCompletenessRule)
-      R.register(AuthoritativeSourceRule)
-      R.register(RelatedConceptRule)
-      R.register(ConceptStatusRule)
-      R.register(SourceEnumRule)
-      R.register(TermsPresenceRule)
-      R.register(BibliographyYamlRule)
-      R.register(ConceptUriRule)
-      R.register(RelatedConceptSymmetryRule)
-      R.register(RelatedConceptCycleRule)
-      R.register(DesignationStatusRule)
-      R.register(DateTypeRule)
-      R.register(LanguageCodeFormatRule)
-      R.register(DesignationTypeRule)
-      R.register(DateValidityRule)
-    end
-  end
-end
+require_relative "rules/schema_version_rule"
+require_relative "rules/ref_shape_rule"
+require_relative "rules/locality_completeness_rule"
+require_relative "rules/domain_ref_rule"
+require_relative "rules/uuid_format_rule"
+require_relative "rules/localization_consistency_rule"
+require_relative "rules/related_concept_target_rule"
+require_relative "rules/domain_target_rule"
+require_relative "rules/source_urn_format_rule"
+require_relative "rules/model_validity_rule"

data/lib/glossarist/validation/validation_issue.rb

@@ -2,16 +2,19 @@
 
 module Glossarist
   module Validation
-    class ValidationIssue
-      attr_reader :severity, :code, :message, :location, :suggestion
+    class ValidationIssue < Lutaml::Model::Serializable
+      attribute :severity, :string
+      attribute :code, :string
+      attribute :message, :string
+      attribute :location, :string
+      attribute :suggestion, :string
 
-      def initialize(severity:, message:, code: nil, location: nil,
-suggestion: nil)
-        @severity = severity
-        @code = code
-        @message = message
-        @location = location
-        @suggestion = suggestion
+      key_value do
+        map :severity, to: :severity
+        map :code, to: :code
+        map :message, to: :message
+        map :location, to: :location
+        map :suggestion, to: :suggestion
       end
 
       def error?
@@ -29,9 +32,9 @@ suggestion: nil)
       def to_s
         parts = ["[#{severity.upcase}]"]
         parts << "[#{code}]" if code
-        parts << (location ? "#{location}: " : "")
+        parts << "#{location}: " if location
         parts << message
-        parts << " (#{suggestion})" if suggestion
+        parts << "(#{suggestion})" if suggestion
         parts.join(" ")
       end
     end