glossarist 2.6.4 → 2.6.5

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class DefinitionContentRule < Base
+        def code = "GLS-300"
+        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"
+            (l10n.data&.definition || []).each_with_index do |d, idx|
+              if d.content.nil? || d.content.strip.empty?
+                issues << issue(
+                  "definition #{idx + 1} has empty content",
+                  code: code, severity: severity,
+                  location: "#{fname}/#{lang}",
+                  suggestion: "Add definition text or remove the empty entry",
+                )
+              end
+            end
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class DesignationStatusRule < Base
+        def code = "GLS-204"
+        def category = :schema
+        def severity = "error"
+        def scope = :concept
+
+        VALID_STATUSES = Glossarist::GlossaryDefinition::DESIGNATION_BASE_NORMATIVE_STATUSES
+
+        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 || []
+            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)
+                issues << issue(
+                  "#{lang}: term #{idx + 1} has invalid normative_status '#{term.normative_status}'",
+                  location: fname,
+                  suggestion: "Use one of: #{VALID_STATUSES.join(', ')}",
+                )
+              end
+            end
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class DesignationTypeRule < Base
+        def code = "GLS-207"
+        def category = :schema
+        def severity = "error"
+        def scope = :concept
+
+        VALID_TYPES = Designation::SERIALIZED_TYPES.values.grep(String).uniq.freeze
+
+        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 || []
+            terms.each_with_index do |term, idx|
+              type = designation_type(term)
+              next unless type
+
+              unless VALID_TYPES.include?(type)
+                issues << issue(
+                  "#{lang}: term #{idx + 1} has unknown designation type '#{type}'",
+                  location: fname,
+                  suggestion: "Use one of: #{VALID_TYPES.join(', ')}",
+                )
+              end
+            end
+          end
+
+          issues
+        end
+
+        private
+
+        def designation_type(term)
+          if term.is_a?(Hash)
+            term["type"]
+          elsif term.respond_to?(:type)
+            term.type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class DuplicateTermRule < Base
+        def code = "GLS-302"
+        def category = :quality
+        def severity = "warning"
+        def scope = :collection
+
+        def applicable?(context)
+          context.concepts.any?
+        end
+
+        def check(context)
+          term_index = build_term_index(context.concepts)
+          issues = []
+
+          term_index.each do |(lang, term), ids|
+            next if ids.size <= 1
+
+            issues << issue(
+              "Duplicate preferred term '#{term}' in #{lang}: " \
+              "concepts #{ids.join(', ')}",
+              code: code, severity: severity,
+              location: lang,
+              suggestion: "Differentiate the terms or consolidate the concepts",
+            )
+          end
+
+          issues
+        end
+
+        private
+
+        def build_term_index(concepts)
+          index = Hash.new { |h, k| h[k] = [] }
+
+          concepts.each do |concept|
+            id = concept.data&.id&.to_s
+            next unless id
+
+            concept.localizations.each do |l10n|
+              lang = l10n.language_code
+              next unless lang
+
+              (l10n.data&.terms || []).each do |term|
+                next unless term.normative_status == "preferred"
+                next unless term.designation
+
+                index[[lang, term.designation.downcase]] << id
+              end
+            end
+          end
+
+          index
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class EntryStatusRule < Base
+        def code = "GLS-003"
+        def category = :schema
+        def severity = "error"
+        def scope = :concept
+
+        VALID_STATUSES = %w[valid superseded withdrawn draft].freeze
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          (concept.localizations&.values || []).each do |l10n|
+            lang = l10n.language_code || "unknown"
+            status = l10n.data&.entry_status
+            next unless status
+            next if VALID_STATUSES.include?(status)
+
+            issues << issue(
+              "#{fname}/#{lang}: invalid entry_status '#{status}' " \
+              "(expected one of: #{VALID_STATUSES.join(', ')})",
+              code: code, severity: "error",
+              location: "#{fname}/#{lang}",
+            )
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class FilenameIdRule < Base
+        def code = "GLS-015"
+        def category = :integrity
+        def severity = "error"
+        def scope = :concept
+
+        def applicable?(context)
+          context.gcr?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          expected_id = concept.data&.id&.to_s
+          actual_name = fname.sub(/\.yaml\z/, "").sub(%r{\Aconcepts/}, "")
+
+          return [] unless expected_id && expected_id != actual_name
+
+          [issue(
+            "filename '#{actual_name}' does not match concept id '#{expected_id}'",
+            code: code, severity: severity,
+            location: "concepts/#{fname}",
+            suggestion: "Rename the entry or fix the concept id",
+          )]
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "zip"
+
+module Glossarist
+  module Validation
+    module Rules
+      class GcrContext
+        attr_reader :zip_path
+
+        def initialize(zip_path)
+          @zip_path = zip_path
+          @metadata = nil
+          @concepts = nil
+          @bibliography_index = nil
+          @asset_index = nil
+          @zip_entries = nil
+          @localization_index = nil
+        end
+
+        def concepts
+          @concepts ||= begin
+            pkg = GcrPackage.load(@zip_path)
+            pkg.concepts
+          rescue StandardError
+            []
+          end
+        end
+
+        def concept_ids
+          @concept_ids ||= concepts.filter_map { |c| c.data&.id&.to_s }.to_set
+        end
+
+        def metadata
+          @metadata ||= Zip::File.open(@zip_path) do |zf|
+            entry = zf.find_entry("metadata.yaml")
+            return nil unless entry
+
+            GcrMetadata.from_yaml(entry.get_input_stream.read)
+          end
+        end
+
+        def bibliography_index
+          @bibliography_index ||= begin
+            bib_yaml = read_zip_file("bibliography.yaml")
+            BibliographyIndex.build_from_concepts(concepts,
+                                                  bibliography_yaml: bib_yaml)
+          end
+        end
+
+        def asset_index
+          @asset_index ||= AssetIndex.build_from_zip(@zip_path)
+        end
+
+        def declared_languages
+          metadata&.languages || []
+        end
+
+        def actual_languages
+          @actual_languages ||= concepts.flat_map do |c|
+            c.localizations.map(&:language_code)
+          end.compact.uniq.sort
+        end
+
+        def zip_entries
+          @zip_entries ||= Zip::File.open(@zip_path) do |zf|
+            zf.entries.to_set(&:name)
+          end
+        end
+
+        def localization_index
+          {}
+        end
+
+        def referenced_l10n_uuids
+          Set.new
+        end
+
+        def gcr?
+          true
+        end
+
+        def read_zip_file(name)
+          Zip::File.open(@zip_path) do |zf|
+            entry = zf.find_entry(name)
+            entry&.get_input_stream&.read
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class ImageReferenceRule < Base
+        def code = "GLS-103"
+        def category = :references
+        def severity = "warning"
+        def scope = :concept
+
+        def applicable?(context)
+          context.concept.localizations&.any?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          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|
+              next unless text
+              refs = extractor.extract_from_text(text)
+              refs.each do |ref|
+                next unless ref.is_a?(AssetReference)
+                next if context.asset_index.resolve?(ref.path)
+
+                issues << issue(
+                  "unresolved image reference #{ref.path}",
+                  code: "GLS-103", severity: severity,
+                  location: "#{fname}/#{lang}",
+                  suggestion: "add '#{ref.path}' to the dataset's images/ directory",
+                )
+              end
+            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)
+
+            issues << issue(
+              "unresolved asset reference #{ref.path}",
+              code: "GLS-104", severity: "error",
+              location: fname,
+              suggestion: "add '#{ref.path}' to the dataset's images/ directory",
+            )
+          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/l10n_uuid_integrity_rule.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class L10nUuidIntegrityRule < Base
+        def code = "GLS-018"
+        def category = :integrity
+        def severity = "error"
+        def scope = :concept
+
+        def applicable?(context)
+          context.collection_context.localization_index.any?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          lc_map = concept.data.localized_concepts || {}
+          lc_index = context.collection_context.localization_index
+          issues = []
+
+          lc_map.each do |lang, uuid|
+            next if lc_index.key?(uuid)
+
+            issues << issue(
+              "localized_concepts '#{lang}' => '#{uuid}' has no matching file",
+              code: code, severity: severity,
+              location: fname,
+              suggestion: "Add the missing localization file or remove the UUID",
+            )
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class LanguageCodeFormatRule < Base
+        def code = "GLS-206"
+        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 = []
+
+          concept.localizations.each do |l10n|
+            lang = l10n.language_code
+            next if lang.nil?
+
+            unless lang.to_s.match?(/\A[a-z]{3}\z/)
+              issues << issue(
+                "language_code '#{lang}' is not a valid ISO 639-3 code (expected 3 lowercase letters)",
+                location: fname,
+                suggestion: "Use a 3-letter ISO 639-3 code (e.g. eng, fra, deu)",
+              )
+            end
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class LanguageCoverageRule < Base
+        def code = "GLS-013"
+        def category = :localization
+        def severity = "warning"
+        def scope = :concept
+
+        def applicable?(context)
+          declared = context.declared_languages
+          declared.is_a?(Array) && declared.any?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          declared = context.declared_languages
+          present = concept.localizations&.values&.map(&:language_code) || []
+          missing = declared - present
+
+          return [] if missing.empty?
+
+          [issue(
+            "missing localizations for declared languages: #{missing.join(', ')}",
+            code: code, severity: severity,
+            location: fname,
+            suggestion: "Add localizations for: #{missing.join(', ')}",
+          )]
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class LanguageListRule < Base
+        def code = "GLS-012"
+        def category = :integrity
+        def severity = "warning"
+        def scope = :collection
+
+        def applicable?(context)
+          declared = context.declared_languages
+          declared.is_a?(Array) && declared.any?
+        end
+
+        def check(context)
+          declared = Set.new(context.declared_languages)
+          actual = Set.new(context.actual_languages)
+          issues = []
+
+          missing = declared - actual
+          if missing.any?
+            issues << issue(
+              "declared languages not found in concepts: #{missing.sort.join(', ')}",
+              code: code, severity: severity,
+              suggestion: "Update the languages list or add missing localizations",
+            )
+          end
+
+          extra = actual - declared
+          if extra.any?
+            issues << issue(
+              "concepts use languages not declared: #{extra.sort.join(', ')}",
+              code: code, severity: severity,
+              suggestion: "Add these languages to the languages list in metadata",
+            )
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class LocalizationPresenceRule < Base
+        def code = "GLS-002"
+        def category = :structure
+        def scope = :concept
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          l10ns = concept.localizations&.values || []
+
+          return [] if l10ns.any?
+
+          [issue("#{fname}: no localizations found",
+                 code: code, severity: "error")]
+        end
+      end
+    end
+  end
+end
+