glossarist 2.4.0 → 2.5.1

data/lib/glossarist/reference_resolver.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class ReferenceResolver
+    def initialize
+      @local_adapter = nil
+      @package_adapters = []
+      @route_adapter = ResolutionAdapter::Route.new
+      @remote_adapters = []
+    end
+
+    def register_self(concepts)
+      @local_adapter = ResolutionAdapter::Local.new(concepts)
+    end
+
+    def register_package(package_or_concepts, uri_prefix: nil)
+      concepts = extract_concepts(package_or_concepts)
+      prefix = uri_prefix || infer_uri_prefix(package_or_concepts)
+      raise ArgumentError, "uri_prefix required" unless prefix
+
+      @package_adapters << ResolutionAdapter::Package.new(concepts,
+                                                          uri_prefix: prefix)
+    end
+
+    def add_route(from:, to:)
+      @route_adapter.add(from: from, to: to)
+    end
+
+    def register_remote(uri_prefix:, endpoint:)
+      @remote_adapters << ResolutionAdapter::Remote.new(uri_prefix: uri_prefix,
+                                                        endpoint: endpoint)
+    end
+
+    def resolve(reference)
+      if reference.local?
+        return @local_adapter&.resolve(reference)
+      end
+
+      routed_ref = apply_routes(reference)
+
+      @package_adapters.each do |adapter|
+        result = adapter.resolve(routed_ref)
+        return result if result
+      end
+
+      @remote_adapters.each do |adapter|
+        result = adapter.resolve(routed_ref)
+        return result if result
+      end
+
+      nil
+    end
+
+    def resolve_all(concept, extractor: nil)
+      extractor ||= ReferenceExtractor.new
+      refs = extract_refs(concept, extractor)
+      refs.map { |ref| [ref, resolve(ref)] }
+    end
+
+    def validate_all(package_or_concepts, extractor: nil, mode: :multi)
+      concepts = extract_concepts(package_or_concepts)
+      extractor ||= ReferenceExtractor.new
+      result = ValidationResult.new
+
+      concepts.each do |concept|
+        refs = extract_refs(concept, extractor)
+        termid = extract_termid(concept)
+
+        refs.each do |ref|
+          resolved = resolve(ref)
+          if resolved.nil?
+            scope = ref.local? ? "intra-set" : "inter-set (#{ref.source})"
+            result.add_warning("#{termid}: Unresolvable #{scope} reference: #{ref.term} -> #{ref.concept_id}")
+          end
+        end
+
+        if mode == :single && !@local_adapter
+          external_refs = refs.select(&:external?)
+          if external_refs.any?
+            result.add_warning("#{termid}: #{external_refs.size} external reference(s) not checked in single mode")
+          end
+        end
+      end
+
+      result
+    end
+
+    def load_collection(collection_dir)
+      config_path = File.join(collection_dir, "collection.yaml")
+      if File.exist?(config_path)
+        load_collection_config(config_path, collection_dir)
+      else
+        load_gcr_directory(collection_dir)
+      end
+    end
+
+    def registered_datasets
+      @package_adapters.map(&:uri_prefix)
+    end
+
+    private
+
+    def apply_routes(reference)
+      routed = @route_adapter.resolve(reference)
+      routed || reference
+    end
+
+    def extract_concepts(package_or_concepts)
+      case package_or_concepts
+      when GcrPackage then package_or_concepts.concepts
+      when Array then package_or_concepts
+      when Hash then [package_or_concepts]
+      else raise ArgumentError, "Expected GcrPackage, Array, or Hash"
+      end
+    end
+
+    def infer_uri_prefix(package_or_concepts)
+      case package_or_concepts
+      when GcrPackage then package_or_concepts.metadata&.dig("uri_prefix")
+      end
+    end
+
+    def load_collection_config(config_path, collection_dir)
+      config = CollectionConfig.from_file(config_path)
+
+      config.packages.each do |pkg|
+        gcr_path = File.join(collection_dir, pkg["file"])
+        next unless File.exist?(gcr_path)
+
+        gcr = GcrPackage.load(gcr_path)
+        prefix = pkg["uri_prefix"] || gcr.metadata&.dig("uri_prefix")
+        register_package(gcr, uri_prefix: prefix)
+      end
+
+      config.routes.each do |route|
+        add_route(from: route["from"], to: route["to"])
+      end
+
+      config.remotes.each do |remote|
+        register_remote(uri_prefix: remote["uri_prefix"],
+                        endpoint: remote["endpoint"])
+      end
+    end
+
+    def load_gcr_directory(dir)
+      Dir.glob(File.join(dir, "*.gcr")).each do |gcr_path|
+        pkg = GcrPackage.load(gcr_path)
+        prefix = pkg.metadata&.dig("uri_prefix")
+        register_package(pkg, uri_prefix: prefix)
+      end
+    end
+
+    def extract_refs(concept, extractor)
+      if concept.is_a?(ManagedConcept)
+        extractor.extract_from_managed_concept(concept)
+      else
+        extractor.extract_from_concept_hash(concept)
+      end
+    end
+
+    def extract_termid(concept)
+      if concept.is_a?(ManagedConcept)
+        concept.data.id&.to_s
+      else
+        (concept["termid"] || concept["id"])&.to_s
+      end
+    end
+  end
+end

data/lib/glossarist/register_data.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class RegisterData < Lutaml::Model::Serializable
+    attribute :data, :hash, default: -> { {} }
+
+    key_value do
+      map nil, to: :data, with: { from: :data_from, to: :data_to }
+    end
+
+    def self.from_file(path)
+      from_yaml(File.read(path))
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def [](key)
+      data[key]
+    end
+
+    def dig(*keys)
+      data.dig(*keys)
+    end
+
+    def to_h
+      data
+    end
+
+    def data_from(model, value)
+      model.data = value
+    end
+
+    def data_to(model, doc)
+      model.data.each do |key, value|
+        doc[key] = value
+      end
+    end
+  end
+end

data/lib/glossarist/related_concept.rb

@@ -7,7 +7,7 @@ module Glossarist
               values: Glossarist::GlossaryDefinition::RELATED_CONCEPT_TYPES
     attribute :ref, Citation
 
-    yaml do
+    key_value do
       map :content, to: :content
       map :type, to: :type
       map :ref, with: { from: :ref_from_yaml, to: :ref_to_yaml }

data/lib/glossarist/resolution_adapter/local.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class ResolutionAdapter
+    class Local < ResolutionAdapter
+      attr_reader :index, :concepts
+
+      def initialize(concepts)
+        super()
+        @concepts = concepts
+        @index = {}
+        build_index
+      end
+
+      def resolve(reference)
+        case reference.ref_type
+        when "local"
+          resolve_by_id(reference.concept_id)
+        when "designation"
+          resolve_by_designation(reference.term)
+        else
+          resolve_by_id(reference.concept_id) if reference.concept_id
+        end
+      end
+
+      def resolve_by_id(concept_id)
+        @index[concept_id]
+      end
+
+      def resolve_by_designation(term)
+        return nil unless term
+
+        downcased = term.downcase
+        concepts.find do |concept|
+          designations_for(concept).any? { |d| d&.downcase == downcased }
+        end
+      end
+
+      private
+
+      def designations_for(concept)
+        if concept.is_a?(ManagedConcept)
+          concept.localizations.flat_map do |l10n|
+            l10n.data.terms.filter_map do |t|
+              t.respond_to?(:designation) ? t.designation : nil
+            end
+          end
+        else
+          concept.each_value.flat_map do |lang_block|
+            next [] unless lang_block.is_a?(Hash) && lang_block.key?("terms")
+
+            Array(lang_block["terms"]).filter_map { |t| t["designation"] }
+          end
+        end
+      end
+
+      def build_index
+        concepts.each do |concept|
+          termid = extract_termid(concept)
+          @index[termid] = concept if termid
+        end
+      end
+
+      def extract_termid(concept)
+        if concept.is_a?(ManagedConcept)
+          concept.data.id&.to_s
+        else
+          (concept["termid"] || concept["id"])&.to_s
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/resolution_adapter/package.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class ResolutionAdapter
+    class Package < ResolutionAdapter
+      attr_reader :uri_prefix, :local_adapter
+
+      def initialize(concepts, uri_prefix:)
+        super()
+        @uri_prefix = uri_prefix
+        @local_adapter = Local.new(concepts)
+      end
+
+      def resolve(reference)
+        return nil unless reference.ref_type == "urn"
+        return nil unless reference.source == uri_prefix
+
+        @local_adapter.resolve_by_id(reference.concept_id)
+      end
+    end
+  end
+end

data/lib/glossarist/resolution_adapter/remote.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module Glossarist
+  class ResolutionAdapter
+    class Remote < ResolutionAdapter
+      attr_reader :uri_prefix, :endpoint, :cache
+
+      def initialize(uri_prefix:, endpoint:)
+        super()
+        @uri_prefix = uri_prefix
+        @endpoint = endpoint.chomp("/")
+        @cache = {}
+      end
+
+      def resolve(reference)
+        return nil unless reference.ref_type == "urn"
+        return nil unless reference.source == uri_prefix
+
+        key = cache_key(reference)
+        return @cache[key] if @cache.key?(key)
+
+        @cache[key] = fetch(reference)
+      end
+
+      private
+
+      def build_uri(reference)
+        URI.parse("#{endpoint}/#{URI.encode_www_form_component(reference.source)}/#{URI.encode_www_form_component(reference.concept_id)}")
+      end
+
+      def parse_response(response)
+        content_type = response["content-type"].to_s
+        if content_type.include?("json")
+          JSON.parse(response.body)
+        elsif content_type.include?("yaml")
+          ConceptDocument.from_yamls(response.body).to_managed_concept
+        else
+          ManagedConcept.from_yaml(response.body)
+        end
+      end
+
+      def cache_key(reference)
+        "#{reference.source}/#{reference.concept_id}"
+      end
+
+      def fetch(reference)
+        uri = build_uri(reference)
+        response = Net::HTTP.get_response(uri)
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        parse_response(response)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/glossarist/resolution_adapter/route.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class ResolutionAdapter
+    class Route < ResolutionAdapter
+      attr_reader :routes
+
+      def initialize(routes = {})
+        super()
+        @routes = routes
+      end
+
+      def add(from:, to:)
+        @routes[from] = to
+      end
+
+      def resolve(reference)
+        return nil unless reference.ref_type == "urn"
+        return nil unless routes.key?(reference.source)
+
+        ConceptReference.new(
+          term: reference.term,
+          concept_id: reference.concept_id,
+          source: routes[reference.source],
+          ref_type: reference.ref_type,
+        )
+      end
+
+      def remap(source)
+        routes[source] || source
+      end
+    end
+  end
+end

data/lib/glossarist/resolution_adapter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class ResolutionAdapter
+    autoload :Local, "glossarist/resolution_adapter/local"
+    autoload :Package, "glossarist/resolution_adapter/package"
+    autoload :Route, "glossarist/resolution_adapter/route"
+    autoload :Remote, "glossarist/resolution_adapter/remote"
+
+    def resolve(_reference)
+      raise NotImplementedError, "#{self.class}#resolve must be implemented"
+    end
+  end
+end