glossarist 2.6.4 → 2.6.5

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class AuthoritativeSourceRule < Base
+        def code = "GLS-306"
+        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
+          all_sources = gather_all_sources(concept)
+
+          return [] if all_sources.any? { |s| s.type == "authoritative" }
+
+          [issue(
+            "no authoritative source defined",
+            code: code, severity: severity,
+            location: fname,
+            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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class Base
+        def code
+          nil
+        end
+
+        def category
+          :general
+        end
+
+        def severity
+          "error"
+        end
+
+        def scope
+          :concept
+        end
+
+        def applicable?(_context)
+          true
+        end
+
+        def check(_context)
+          []
+        end
+
+        private
+
+        def issue(message, location: nil, suggestion: nil, severity: nil,
+code: nil)
+          ValidationIssue.new(
+            severity: severity || self.severity,
+            code: code || self.code,
+            message: message,
+            location: location,
+            suggestion: suggestion,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class BibliographyYamlRule < Base
+        def code = "GLS-020-YAML"
+        def category = :structure
+        def severity = "error"
+        def scope = :collection
+
+        def applicable?(context)
+          context.gcr?
+        end
+
+        def check(context)
+          bib_content = context.read_zip_file("bibliography.yaml")
+          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
+            return [issue(
+              "bibliography.yaml is invalid YAML: #{e.message}",
+              code: code, severity: severity,
+              location: "bibliography.yaml",
+              suggestion: "Fix YAML syntax errors in bibliography.yaml",
+            )]
+          end
+
+          []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class CitationCompletenessRule < Base
+        def code = "GLS-304"
+        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 = []
+
+          gather_all_sources(concept).each_with_index do |source, idx|
+            origin = source.origin
+            next unless origin
+
+            if origin.text.nil? && origin.source.nil? && origin.id.nil?
+              issues << issue(
+                "source #{idx + 1} has empty origin (no text, source, or id)",
+                code: "GLS-304", severity: severity,
+                location: fname,
+                suggestion: "Add at minimum an origin.text or origin.source + origin.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/concept_context.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class ConceptContext
+        attr_reader :concept, :file_name, :collection_context
+
+        def initialize(concept, file_name:, collection_context:)
+          @concept = concept
+          @file_name = file_name
+          @collection_context = collection_context
+        end
+
+        def concept_id
+          @concept.data&.id&.to_s
+        end
+
+        def bibliography_index
+          @collection_context.bibliography_index
+        end
+
+        def asset_index
+          @collection_context.asset_index
+        end
+
+        def concept_ids
+          @collection_context.concept_ids
+        end
+
+        def declared_languages
+          @collection_context.declared_languages
+        end
+
+        def metadata
+          @collection_context.metadata
+        end
+
+        def gcr?
+          @collection_context.gcr?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class ConceptCountRule < Base
+        def code = "GLS-011"
+        def category = :integrity
+        def severity = "error"
+        def scope = :collection
+
+        def applicable?(context)
+          context.metadata && context.metadata.concept_count
+        end
+
+        def check(context)
+          expected = context.metadata.concept_count
+          actual = context.concepts.size
+
+          return [] if expected == actual
+
+          [issue(
+            "metadata.yaml concept_count is #{expected} " \
+            "but found #{actual} concept files",
+            code: code, severity: severity,
+            location: "metadata.yaml",
+            suggestion: "Update concept_count or add/remove concept files",
+          )]
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class ConceptIdRule < Base
+        def code = "GLS-001"
+        def category = :structure
+        def scope = :concept
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          id = concept.data&.id
+          unless id
+            issues << issue("#{fname}: missing concept id",
+                            code: code, severity: "error")
+            return issues
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class ConceptIdUniquenessRule < Base
+        def code = "GLS-001-uniq"
+        def category = :structure
+        def severity = "error"
+        def scope = :collection
+
+        def applicable?(context)
+          context.concepts.any?
+        end
+
+        def check(context)
+          issues = []
+          seen_ids = {}
+
+          context.concepts.each_with_index do |concept, idx|
+            id = concept.data&.id&.to_s
+            fname = id ? "concept-#{id}.yaml" : "concept-#{idx}.yaml"
+
+            next unless id
+
+            if seen_ids[id]
+              issues << issue(
+                "#{fname}: duplicate id '#{id}' (first seen in #{seen_ids[id]})",
+                code: code, severity: "error",
+              )
+            else
+              seen_ids[id] = fname
+            end
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class ConceptMentionRule < Base
+        def code = "GLS-100"
+        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 = []
+
+          refs = extractor.extract_from_managed_concept(concept)
+            .select { |r| r.is_a?(ConceptReference) && r.local? }
+
+          refs.each do |ref|
+            next if ref.ref_type == "designation"
+            next if context.concept_ids.include?(ref.concept_id)
+
+            issues << issue(
+              "unresolved intra-set reference: #{ref.term} -> #{ref.concept_id}",
+              code: "GLS-100", severity: severity,
+              location: fname,
+              suggestion: "add concept '#{ref.concept_id}' to the dataset " \
+                          "or verify the reference",
+            )
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class ConceptStatusRule < Base
+        def code = "GLS-201"
+        def category = :schema
+        def severity = "error"
+        def scope = :concept
+
+        VALID_STATUSES = Glossarist::GlossaryDefinition::CONCEPT_STATUSES
+
+        def applicable?(context)
+          !context.concept.status.nil?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          status = concept.status
+
+          return [] if VALID_STATUSES.include?(status)
+
+          [issue(
+            "invalid concept status '#{status}'",
+            code: code, severity: severity,
+            location: fname,
+            suggestion: "Use one of: #{VALID_STATUSES.join(', ')}",
+          )]
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class ConceptUriRule < Base
+        def code = "GLS-014"
+        def category = :structure
+        def severity = "warning"
+        def scope = :collection
+
+        def applicable?(context)
+          context.gcr? && context.metadata
+        end
+
+        def check(context)
+          meta = context.metadata
+          return [] if meta.uri_prefix && !meta.uri_prefix.strip.empty?
+
+          [issue(
+            "no concept URI prefix or template defined in metadata",
+            code: code, severity: severity,
+            location: "metadata.yaml",
+            suggestion: "Add uri_prefix or concept_uri_template to metadata.yaml",
+          )]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class DatasetContext
+        attr_reader :path
+
+        def initialize(path)
+          @path = File.expand_path(path)
+          @concepts = nil
+          @bibliography_index = nil
+          @asset_index = nil
+          @declared_languages = nil
+        end
+
+        def concepts
+          @concepts ||= ConceptCollector.collect(@path)
+        end
+
+        def concept_ids
+          @concept_ids ||= concepts.filter_map { |c| c.data&.id&.to_s }.to_set
+        end
+
+        def metadata
+          nil
+        end
+
+        def bibliography_index
+          @bibliography_index ||= BibliographyIndex.build_from_concepts(
+            concepts, dataset_path: @path
+          )
+        end
+
+        def asset_index
+          @asset_index ||= AssetIndex.build_from_directory(@path)
+        end
+
+        def declared_languages
+          @declared_languages ||= begin
+            reg = load_register_data
+            if reg && reg["languages"].is_a?(Array)
+              reg["languages"]
+            else
+              actual_languages
+            end
+          end
+        end
+
+        def actual_languages
+          @actual_languages ||= concepts.flat_map do |c|
+            c.localizations.map(&:language_code)
+          end.compact.uniq.sort
+        end
+
+        def localization_index
+          @localization_index ||= build_localization_index
+        end
+
+        def referenced_l10n_uuids
+          @referenced_l10n_uuids ||= concepts.flat_map do |c|
+            (c.data.localized_concepts || {}).values
+          end.to_set
+        end
+
+        def gcr?
+          false
+        end
+
+        def read_zip_file(_name)
+          nil
+        end
+
+        private
+
+        def load_register_data
+          reg_path = File.join(@path, "register.yaml")
+          return nil unless File.exist?(reg_path)
+
+          YAML.safe_load_file(reg_path)
+        end
+
+        def build_localization_index
+          index = {}
+          %w[localized_concept localized-concept].each do |name|
+            dir = File.join(@path, "concepts", name)
+            next unless File.directory?(dir)
+
+            Dir.glob(File.join(dir, "*.{yaml,yml}")).each do |f|
+              uuid = File.basename(f, ".*")
+              index[uuid] = f
+            end
+          end
+          index
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      class DateTypeRule < Base
+        def code = "GLS-205"
+        def category = :schema
+        def severity = "warning"
+        def scope = :concept
+
+        VALID_TYPES = Glossarist::GlossaryDefinition::CONCEPT_DATE_TYPES
+
+        def applicable?(context)
+          concept = context.concept
+          (concept.dates&.any?) || concept.date_accepted
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          check_date_collection(concept.dates, fname, issues)
+
+          if concept.date_accepted && concept.date_accepted.type
+            validate_date_type(concept.date_accepted, "date_accepted", fname, issues)
+          end
+
+          issues
+        end
+
+        private
+
+        def check_date_collection(dates, fname, issues)
+          (dates || []).each_with_index do |date, idx|
+            next unless date.type
+            validate_date_type(date, "date #{idx + 1}", fname, issues)
+          end
+        end
+
+        def validate_date_type(date, label, fname, issues)
+          return if VALID_TYPES.include?(date.type.to_s)
+
+          issues << issue(
+            "#{label} has invalid type '#{date.type}'",
+            location: fname,
+            suggestion: "Use one of: #{VALID_TYPES.join(', ')}",
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Glossarist
+  module Validation
+    module Rules
+      class DateValidityRule < Base
+        def code = "GLS-307"
+        def category = :quality
+        def severity = "warning"
+        def scope = :concept
+
+        def applicable?(context)
+          concept = context.concept
+          (concept.dates&.any?) || concept.date_accepted
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          (concept.dates || []).each_with_index do |date, idx|
+            validate_date(date, "date #{idx + 1}", fname, issues)
+          end
+
+          if concept.date_accepted
+            validate_date(concept.date_accepted, "date_accepted", fname, issues)
+          end
+
+          issues
+        end
+
+        private
+
+        def validate_date(concept_date, label, fname, issues)
+          date_value = concept_date.date
+
+          if date_value.nil? && concept_date.type
+            issues << issue(
+              "#{label} has no date value (type: #{concept_date.type})",
+              location: fname,
+              suggestion: "Provide a valid ISO 8601 date (e.g. 2024-01-15)",
+            )
+            return
+          end
+
+          return if date_value.nil?
+
+          str = date_value.respond_to?(:iso8601) ? date_value.iso8601 : date_value.to_s
+
+          begin
+            DateTime.parse(str)
+          rescue ArgumentError, TypeError
+            issues << issue(
+              "#{label} has unparseable date value '#{str}'",
+              location: fname,
+              suggestion: "Use an ISO 8601 date format (e.g. 2024-01-15)",
+            )
+          end
+        end
+      end
+    end
+  end
+end