glossarist 2.6.4 → 2.6.5

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class OrphanedBibliographyRule < Base
+        def code = "GLS-020"
+        def category = :references
+        def severity = "warning"
+        def scope = :collection
+
+        def applicable?(context)
+          context.bibliography_index.entries.any?
+        end
+
+        def check(context)
+          extractor = ReferenceExtractor.new
+          bib_index = context.bibliography_index
+          referenced_anchors = Set.new
+
+          context.concepts.each do |concept|
+            concept.localizations.each do |l10n|
+              texts = extract_texts(l10n)
+              texts.each do |text|
+                next unless text
+                extractor.extract_from_text(text).each do |ref|
+                  if ref.is_a?(BibliographicReference)
+                    referenced_anchors.add(ref.anchor)
+                  end
+                end
+              end
+            end
+          end
+
+          issues = []
+          bib_index.each_entry do |entry|
+            next if referenced_anchors.any? { |a| bib_index.resolve?(a) }
+
+            anchor = entry[:anchor]
+            issues << issue(
+              "Orphaned bibliography entry: '#{anchor}'",
+              code: code, severity: severity,
+              location: "bibliography.yaml",
+              suggestion: "Remove the entry or reference it from a concept",
+            )
+          end
+
+          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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class OrphanedImagesRule < Base
+        def code = "GLS-021"
+        def category = :references
+        def severity = "warning"
+        def scope = :collection
+
+        def applicable?(context)
+          context.asset_index.paths.any?
+        end
+
+        def check(context)
+          extractor = ReferenceExtractor.new
+          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|
+                next unless text
+                extractor.extract_from_text(text).each do |ref|
+                  if ref.is_a?(AssetReference)
+                    referenced_paths.add(ref.path)
+                  end
+                end
+              end
+            end
+
+            # Model-level asset refs
+            extractor.extract_asset_refs_from_concept(concept).each do |ref|
+              referenced_paths.add(ref.path)
+            end
+          end
+
+          issues = []
+          context.asset_index.each_path do |path|
+            next if referenced_paths.include?(path)
+
+            issues << issue(
+              "Orphaned image: #{path} (not referenced by any concept)",
+              code: code, severity: severity,
+              location: path,
+              suggestion: "Remove the image or reference it from a concept",
+            )
+          end
+
+          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_l10n_files_rule.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class OrphanedL10nFilesRule < Base
+        def code = "GLS-019"
+        def category = :integrity
+        def severity = "warning"
+        def scope = :collection
+
+        def applicable?(context)
+          context.localization_index.any?
+        end
+
+        def check(context)
+          lc_index = context.localization_index
+          referenced = context.referenced_l10n_uuids
+          issues = []
+
+          lc_index.each do |uuid, path|
+            next if referenced.include?(uuid)
+
+            issues << issue(
+              "Orphaned localization file: #{File.basename(path)} " \
+              "(not referenced by any concept)",
+              code: code, severity: severity,
+              location: File.basename(path),
+              suggestion: "Delete the file or add a reference from a managed concept",
+            )
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class PreferredTermRule < Base
+        def code = "GLS-301"
+        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 = []
+
+          concept.localizations.each do |l10n|
+            lang = l10n.language_code || "unknown"
+            terms = l10n.data&.terms || []
+            next if terms.empty?
+            next if terms.any? { |t| t.normative_status == "preferred" }
+
+            issues << issue(
+              "has #{terms.size} term(s) but none are preferred",
+              code: code, severity: severity,
+              location: "#{fname}/#{lang}",
+              suggestion: "Set normative_status: preferred on the primary term",
+            )
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      module Registry
+        @rules = []
+        @mutex = Mutex.new
+
+        def self.register(rule_class)
+          @mutex.synchronize do
+            @rules << rule_class unless @rules.include?(rule_class)
+          end
+        end
+
+        def self.all
+          @rules.map(&:new)
+        end
+
+        def self.for_category(category)
+          all.select { |r| r.category == category }
+        end
+
+        def self.for_scope(scope)
+          all.select { |r| r.scope == scope }
+        end
+
+        def self.find(code)
+          all.find { |r| r.code == code }
+        end
+
+        def self.reset!
+          @mutex.synchronize { @rules.clear }
+        end
+
+        def self.rule_classes
+          @rules.dup
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class RelatedConceptCycleRule < Base
+        def code = "GLS-113"
+        def category = :references
+        def severity = "error"
+        def scope = :collection
+
+        DIRECTIONAL = %w[supersedes deprecates narrower].freeze
+
+        def applicable?(context)
+          context.concepts.any? { |c| c.related&.any? }
+        end
+
+        def check(context)
+          graph = build_directed_graph(context.concepts)
+          issues = []
+
+          cycles = detect_cycles(graph)
+          cycles.each do |cycle|
+            path = cycle.join(" -> ")
+            issues << issue(
+              "Circular relation chain detected: #{path}",
+              location: cycle.first,
+              suggestion: "Break the cycle by removing or redirecting one of the relations",
+            )
+          end
+
+          issues
+        end
+
+        private
+
+        def build_directed_graph(concepts)
+          graph = {}
+          concepts.each do |c|
+            next unless c.related&.any?
+
+            src_id = c.data&.id&.to_s
+            next unless src_id
+
+            c.related.each do |rel|
+              next unless DIRECTIONAL.include?(rel.type)
+
+              target_id = resolve_target_id(rel)
+              next unless target_id
+
+              (graph[src_id] ||= []) << target_id
+            end
+          end
+          graph
+        end
+
+        def resolve_target_id(rel)
+          ref = rel.ref
+          return nil unless ref
+
+          if ref.is_a?(Glossarist::Citation)
+            ref.id || ref.text
+          end
+        end
+
+        def detect_cycles(graph)
+          visited = Set.new
+          stack = Set.new
+          cycles = []
+
+          graph.keys.each do |node|
+            next if visited.include?(node)
+
+            dfs(node, graph, visited, stack, [], cycles)
+          end
+
+          cycles
+        end
+
+        def dfs(node, graph, visited, stack, path, cycles)
+          return if visited.include?(node) && !stack.include?(node)
+
+          if stack.include?(node)
+            cycle_start = path.index(node)
+            cycles << path[cycle_start..] + [node] if cycle_start
+            return
+          end
+
+          visited.add(node)
+          stack.add(node)
+          path = path + [node]
+
+          (graph[node] || []).each do |neighbor|
+            dfs(neighbor, graph, visited, stack, path, cycles)
+          end
+
+          stack.delete(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class RelatedConceptRule < Base
+        def code = "GLS-200"
+        def category = :schema
+        def severity = "error"
+        def scope = :concept
+
+        VALID_TYPES = Glossarist::GlossaryDefinition::RELATED_CONCEPT_TYPES
+
+        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|
+            unless VALID_TYPES.include?(rel.type)
+              issues << issue(
+                "related concept #{idx + 1} has invalid type '#{rel.type}'",
+                code: code, severity: severity,
+                location: fname,
+                suggestion: "Use one of: #{VALID_TYPES.join(', ')}",
+              )
+            end
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class RelatedConceptSymmetryRule < Base
+        def code = "GLS-112"
+        def category = :references
+        def severity = "warning"
+        def scope = :collection
+
+        INVERSE = {
+          "supersedes" => "superseded_by",
+          "superseded_by" => "supersedes",
+          "narrower" => "broader",
+          "broader" => "narrower",
+          "deprecates" => "deprecated_by",
+          "deprecated_by" => "deprecates",
+        }.freeze
+
+        DIRECTIONAL = %w[supersedes deprecates narrower].freeze
+
+        def applicable?(context)
+          context.concepts.any? { |c| c.related&.any? }
+        end
+
+        def check(context)
+          index = build_relation_index(context.concepts)
+          issues = []
+
+          context.concepts.each do |concept|
+            next unless concept.related&.any?
+
+            concept_id = concept.data&.id&.to_s || "unknown"
+            (concept.related || []).each do |rel|
+              inverse = INVERSE[rel.type]
+              next unless inverse
+
+              target_id = resolve_target_id(rel)
+              next unless target_id
+
+              targets = index[target_id]
+              next if targets && targets.any? { |r| r.type == inverse }
+
+              issues << issue(
+                "#{concept_id}: #{rel.type} #{target_id} but #{target_id} has no #{inverse} back-link",
+                location: concept_id,
+                suggestion: "Add a #{inverse} relation on #{target_id} pointing back to #{concept_id}",
+              )
+            end
+          end
+
+          issues
+        end
+
+        private
+
+        def build_relation_index(concepts)
+          index = {}
+          concepts.each do |c|
+            next unless c.related&.any?
+
+            src_id = c.data&.id&.to_s
+            next unless src_id
+
+            c.related.each do |rel|
+              target_id = resolve_target_id(rel)
+              next unless target_id
+
+              (index[src_id] ||= []) << rel
+            end
+          end
+          index
+        end
+
+        def resolve_target_id(rel)
+          ref = rel.ref
+          return nil unless ref
+
+          if ref.is_a?(Glossarist::Citation)
+            ref.id || ref.text
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class SourceEnumRule < Base
+        def code = "GLS-202"
+        def category = :schema
+        def severity = "error"
+        def scope = :concept
+
+        VALID_TYPES = Glossarist::GlossaryDefinition::CONCEPT_SOURCE_TYPES
+        VALID_STATUSES = Glossarist::GlossaryDefinition::CONCEPT_SOURCE_STATUSES
+
+        def applicable?(context)
+          context.concept.localizations&.any?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          gather_all_sources(concept).each_with_index do |source, idx|
+            unless VALID_TYPES.include?(source.type)
+              issues << issue(
+                "source #{idx + 1} has invalid type '#{source.type}'",
+                code: "GLS-202", severity: severity,
+                location: fname,
+                suggestion: "Use one of: #{VALID_TYPES.join(', ')}",
+              )
+            end
+
+            next unless source.status && !VALID_STATUSES.include?(source.status)
+
+            issues << issue(
+              "source #{idx + 1} has invalid status '#{source.status}'",
+              code: "GLS-203", severity: severity,
+              location: fname,
+              suggestion: "Use one of: #{VALID_STATUSES.join(', ')}",
+            )
+          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/terms_presence_rule.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class TermsPresenceRule < Base
+        def code = "GLS-005"
+        def category = :structure
+        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 = []
+
+          concept.localizations.each do |l10n|
+            lang = l10n.language_code || "unknown"
+            terms = l10n.data&.terms || []
+            next unless terms.empty?
+
+            issues << issue(
+              "#{fname}/#{lang}: must have at least 1 term",
+              code: code, severity: severity,
+              location: "#{fname}/#{lang}",
+              suggestion: "Add at least one term/designation to this localization",
+            )
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/validation/rules.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "rules/base"
+require_relative "rules/registry"
+require_relative "rules/dataset_context"
+require_relative "rules/gcr_context"
+require_relative "rules/concept_context"
+
+# Load all rule definitions
+require_relative "rules/concept_id_rule"
+require_relative "rules/concept_id_uniqueness_rule"
+require_relative "rules/localization_presence_rule"
+require_relative "rules/entry_status_rule"
+require_relative "rules/asciidoc_xref_rule"
+require_relative "rules/image_reference_rule"
+require_relative "rules/concept_mention_rule"
+require_relative "rules/concept_count_rule"
+require_relative "rules/language_list_rule"
+require_relative "rules/language_coverage_rule"
+require_relative "rules/filename_id_rule"
+require_relative "rules/l10n_uuid_integrity_rule"
+require_relative "rules/orphaned_l10n_files_rule"
+require_relative "rules/orphaned_bibliography_rule"
+require_relative "rules/orphaned_images_rule"
+require_relative "rules/definition_content_rule"
+require_relative "rules/preferred_term_rule"
+require_relative "rules/duplicate_term_rule"
+require_relative "rules/citation_completeness_rule"
+require_relative "rules/authoritative_source_rule"
+require_relative "rules/related_concept_rule"
+require_relative "rules/concept_status_rule"
+require_relative "rules/source_type_rule"
+require_relative "rules/terms_presence_rule"
+require_relative "rules/bibliography_yaml_rule"
+require_relative "rules/concept_uri_rule"
+require_relative "rules/related_concept_symmetry_rule"
+require_relative "rules/related_concept_cycle_rule"
+require_relative "rules/designation_status_rule"
+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