metanorma-plugin-glossarist 0.3.2 → 0.3.6

data/lib/metanorma/plugin/glossarist/concept_path_resolver.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      class ConceptPathResolver
+        DELEGATED_TO_DATA = %w[localizations tags].freeze
+        DATA_ALIASES = { "identifier" => :id }.freeze
+
+        def resolve(concept, path)
+          parts = parse_path(path)
+          value = navigate(concept, parts)
+          value.is_a?(String) ? value : value.to_s
+        end
+
+        private
+
+        def parse_path(path)
+          path.split(".").flat_map do |segment|
+            if segment.include?("[")
+              parse_indexed_segment(segment)
+            else
+              [segment]
+            end
+          end
+        end
+
+        def parse_indexed_segment(segment)
+          field, index_part = segment.split("[", 2)
+          index = index_part&.delete("]'\"")
+          if index.match?(/\A\d+\z/)
+            [field, index.to_i]
+          else
+            [field, index]
+          end
+        end
+
+        def navigate(obj, parts)
+          parts.reduce(obj) do |current, key|
+            return nil if current.nil?
+
+            access(current, key)
+          end
+        end
+
+        def access(obj, key)
+          case key
+          when String then access_string_key(obj, key)
+          when Integer then access_index(obj, key)
+          end
+        end
+
+        def access_string_key(obj, key)
+          case obj
+          when ::Glossarist::ManagedConcept
+            resolve_managed_concept(obj, key)
+          when ::Glossarist::ManagedConceptData
+            resolve_data_attribute(obj, key)
+          when ::Glossarist::Collections::LocalizationCollection
+            obj.find_by(:language_code, key)
+          when Array
+            nil
+          when ::Lutaml::Model::Serializable
+            resolve_attribute(obj, key)
+          when Hash
+            obj[key] || obj[key.to_s]
+          end
+        end
+
+        def resolve_managed_concept(concept, key)
+          return concept.data.public_send(key) if DELEGATED_TO_DATA.include?(key)
+
+          resolve_attribute(concept, key) { concept.public_send(key.to_sym) }
+        rescue NoMethodError
+          nil
+        end
+
+        def resolve_data_attribute(data, key)
+          aliased = DATA_ALIASES[key]
+          return data.public_send(aliased) if aliased && data.class.attributes.key?(aliased)
+
+          resolve_attribute(data, key)
+        end
+
+        def resolve_attribute(obj, key)
+          sym = key.to_sym
+          return obj.public_send(sym) if obj.class.attributes.key?(sym)
+
+          yield if block_given?
+        end
+
+        def access_index(obj, index)
+          obj[index]
+        rescue NoMethodError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/glossarist/dataset_preprocessor.rb

@@ -4,14 +4,6 @@ require "asciidoctor"
 require "asciidoctor/reader"
 require "glossarist"
 
-require_relative "sanitize"
-require_relative "concept_renderer"
-require_relative "bibliography_renderer"
-require_relative "concept_serializer"
-require_relative "document"
-require_relative "liquid/custom_filters/filters"
-require_relative "liquid/custom_blocks/with_glossarist_context"
-
 module Metanorma
   module Plugin
     module Glossarist
@@ -23,19 +15,22 @@ module Metanorma
         BIBLIOGRAPHY_REGEX = /^glossarist::render_bibliography\[(.*?)\]$/m
         BIBLIOGRAPHY_ENTRY_REGEX = /^glossarist::render_bibliography_entry\[(.*?)\]$/m
 
+        BIB_ANCHOR_REGEX = /^\*\s*\[\[\[([^,]+)/
+
         def initialize(config = {})
           super
           @config = config
-          @datasets = {}
-          @title_depth = 2
-          @bibliography_renderer = BibliographyRenderer.new
-          @seen_glossarist = false
-          @context_names = []
         end
 
         def process(document, reader)
           input_lines = reader.lines.to_enum
           @config[:file_system] = relative_file_path(document, "")
+          @registry = DatasetRegistry.new
+          @rendered_concepts = []
+          @title_depth = 2
+          @existing_bib_anchors = []
+          @seen_glossarist = false
+
           processed_doc = prepare_document(document, input_lines)
           log(document, processed_doc.to_s) if @seen_glossarist
           Asciidoctor::PreprocessorReader.new(document,
@@ -57,6 +52,7 @@ module Metanorma
                              skip_dataset: false)
           liquid_doc = Document.new
           liquid_doc.file_system = @config[:file_system]
+          liquid_doc.registry = @registry
 
           loop do
             current_line = input_lines.next
@@ -88,14 +84,16 @@ module Metanorma
               @title_depth = current_line.sub(/ .*$/,
                                               "").size
             end
+            if (match = current_line.match(BIB_ANCHOR_REGEX))
+              @existing_bib_anchors << match[1]
+            end
             liquid_doc.add_content(current_line)
           end
         end
 
         def process_dataset_tag(document, input_lines, liquid_doc, match)
           @seen_glossarist = true
-          @context_names << prepare_dataset_contexts(document, match[1])
-          @context_names.flatten!
+          @registry.register(document, match[1])
           liquid_doc.add_content(prepare_document(document, input_lines).to_s,
                                  render: false)
         end
@@ -138,16 +136,7 @@ module Metanorma
         end
 
         def get_context_path(document, key)
-          if @context_names && !@context_names.empty?
-            context_names = @context_names.map(&:strip)
-            found = context_names.find do |context|
-              context_name, = context.split("=")
-              context_name == key
-            end
-            return found.split("=").last.strip if found
-          end
-
-          relative_file_path(document, key)
+          @registry.context_path(key) || relative_file_path(document, key)
         end
 
         def process_render_tag(liquid_doc, match)
@@ -157,92 +146,74 @@ module Metanorma
           concept_name = matches[1]
           options = parse_options(matches[2..])
 
-          concept = find_concept(context_name, concept_name)
+          concept = @registry.find_concept(context_name, concept_name)
           return unless concept
 
-          renderer = ConceptRenderer.new(concept,
-                                         depth: @title_depth,
-                                         anchor_prefix: options["anchor-prefix"])
-          liquid_doc.add_content(renderer.render)
+          @rendered_concepts << concept
+          renderer = TemplateRenderer.new(file_system: @config[:file_system])
+          rendered = renderer.render_concept(concept,
+                                             depth: @title_depth,
+                                             anchor_prefix: options["anchor-prefix"])
+          liquid_doc.add_content("\n#{rendered}")
         end
 
+        RENDER_OPTIONS = %w[anchor-prefix].freeze
+
         def process_import_tag(liquid_doc, match)
           @seen_glossarist = true
           matches = match[1].split(",").map(&:strip)
           context_name = matches[0]
           options = parse_options(matches[1..])
-          dataset = @datasets[context_name.strip]
+          dataset = @registry.resolve_dataset(nil, context_name)
           return unless dataset
 
-          rendered = dataset.filter_map do |concept|
-            designation = concept.default_designation
-            next unless designation
-
-            renderer = ConceptRenderer.new(concept,
-                                           depth: @title_depth,
-                                           anchor_prefix: options["anchor-prefix"])
-            renderer.render
-          end.join("\n\n")
-
-          liquid_doc.add_content(rendered)
+          filter_options = options.except(*RENDER_OPTIONS)
+          concepts = ConceptFilter.new(filter_options).apply(dataset)
+          concepts = concepts.select(&:default_designation)
+          @rendered_concepts.concat(concepts)
+          renderer = TemplateRenderer.new(file_system: @config[:file_system])
+          rendered = renderer.render_concepts(concepts,
+                                              depth: @title_depth,
+                                              anchor_prefix: options["anchor-prefix"])
+          liquid_doc.add_content("\n#{rendered}")
         end
 
         def process_bibliography(document, liquid_doc, match)
           @seen_glossarist = true
           dataset_name = match[1].strip
-          dataset = resolve_dataset(document, dataset_name)
-          return unless dataset
-
-          liquid_doc.add_content(@bibliography_renderer.render_all(dataset))
+          concepts = if @rendered_concepts.empty?
+                       @registry.resolve_dataset(
+                         document, dataset_name
+                       )
+                     else
+                       @rendered_concepts
+                     end
+          return unless concepts && !concepts.empty?
+
+          renderer = BibliographyRenderer.new(
+            existing_anchors: @existing_bib_anchors,
+            bibliography_data: @registry.bibliography_data,
+          )
+          liquid_doc.add_content(renderer.render_all(concepts))
         end
 
         def process_bibliography_entry(document, liquid_doc, match)
           @seen_glossarist = true
           dataset_name, concept_name = match[1].split(",").map(&:strip)
-          concept = find_concept(dataset_name, concept_name, document)
+          concept = @registry.find_concept(dataset_name, concept_name, document)
           return unless concept
 
-          entry = @bibliography_renderer.render_entry(concept)
+          renderer = BibliographyRenderer.new(
+            existing_anchors: @existing_bib_anchors,
+            bibliography_data: @registry.bibliography_data,
+          )
+          entry = renderer.render_entry(concept)
           liquid_doc.add_content(entry) if entry
         end
 
-        def prepare_dataset_contexts(document, contexts)
-          contexts.split(";").map do |context|
-            context_name, file_path = context.split(":").map(&:strip)
-            path = relative_file_path(document, file_path)
-            dataset = load_dataset(path)
-            @datasets[context_name] = dataset.to_a
-            "#{context_name}=#{path}"
-          end
-        end
-
-        def load_dataset(path)
-          collection = ::Glossarist::ManagedConceptCollection.new
-          collection.load_from_files(path)
-          collection
-        end
-
-        def find_concept(dataset_name, concept_name, document = nil)
-          dataset = resolve_dataset(document, dataset_name)
-          return unless dataset
-
-          dataset.find do |concept|
-            concept.default_designation == concept_name
-          end
-        end
-
-        def resolve_dataset(document, dataset_name)
-          dataset = @datasets[dataset_name]
-          return dataset if dataset
-
-          return unless document
-
-          path = relative_file_path(document, dataset_name)
-          collection = load_dataset(path)
-          @datasets[dataset_name] = collection.to_a
-        end
-
         def relative_file_path(document, file_path)
+          return file_path if File.absolute_path?(file_path)
+
           docfile_directory = File.dirname(
             document.attributes["docfile"] || ".",
           )

data/lib/metanorma/plugin/glossarist/dataset_registry.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "glossarist"
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      class DatasetRegistry
+        def initialize
+          @datasets = {}
+          @path_cache = {}
+          @bibliography_data = {}
+          @context_names = []
+        end
+
+        def register(document, contexts)
+          paths = contexts.split(";").map do |context|
+            context_name, file_path = context.split(":", 2).map(&:strip)
+            path = relative_file_path(document, file_path)
+            @datasets[context_name] = load_dataset(path).to_a
+            "#{context_name}=#{path}"
+          end
+          @context_names.concat(paths)
+        end
+
+        def load_cached(path)
+          @path_cache[path] ||= load_dataset(path)
+        end
+
+        def resolve_dataset(document, dataset_name)
+          dataset = @datasets[dataset_name]
+          return dataset if dataset
+
+          return unless document
+
+          path = relative_file_path(document, dataset_name)
+          @datasets[dataset_name] = load_dataset(path).to_a
+        end
+
+        def find_concept(dataset_name, concept_name, document = nil)
+          dataset = resolve_dataset(document, dataset_name)
+          return unless dataset
+
+          dataset.find do |concept|
+            concept.default_designation == concept_name
+          end
+        end
+
+        def context_path(key)
+          return nil if @context_names.empty?
+
+          found = @context_names.find do |context|
+            context_name, = context.split("=")
+            context_name.strip == key
+          end
+          found&.split("=")&.last&.strip
+        end
+
+        def bibliography_data
+          @bibliography_data
+        end
+
+        private
+
+        def load_dataset(path)
+          @path_cache[path] ||= begin
+            collection = ::Glossarist::ManagedConceptCollection.new
+            collection.load_from_files(path)
+            load_bibliography_data(path)
+            collection
+          end
+        end
+
+        def load_bibliography_data(dataset_path)
+          bib_path = File.join(dataset_path, "bibliography.yaml")
+          return unless File.exist?(bib_path)
+
+          entries = YAML.safe_load_file(bib_path,
+                                        permitted_classes: [Symbol, Date])
+          return unless entries.is_a?(Array)
+
+          @bibliography_data = entries.each_with_object({}) do |entry, hash|
+            hash[entry["id"]] = entry if entry["id"]
+          end
+        end
+
+        def relative_file_path(document, file_path)
+          return file_path if File.absolute_path?(file_path)
+
+          docfile_directory = File.dirname(
+            document.attributes["docfile"] || ".",
+          )
+          document.path_resolver.system_path(file_path, docfile_directory)
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/glossarist/document.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
 
-require "liquid"
-require_relative "liquid/multiply_local_file_system"
-
 module Metanorma
   module Plugin
     module Glossarist
       class Document
-        attr_accessor :content, :file_system
+        attr_accessor :file_system, :registry
 
         def initialize
           @content = []
@@ -15,7 +12,13 @@ module Metanorma
 
         def add_content(content, options = {})
           @content << if options[:render]
-                        render_liquid(content, options)
+                        LiquidRendering.render(
+                          content,
+                          include_paths: [file_system,
+                                          options[:template]].compact,
+                          patterns: LiquidRendering::DOCUMENT_PATTERNS,
+                          registry: registry,
+                        )
                       else
                         content
                       end
@@ -24,21 +27,6 @@ module Metanorma
         def to_s
           @content.compact.join("\n")
         end
-
-        private
-
-        def render_liquid(file_content, options = {})
-          include_paths = [file_system, options[:template]].compact
-          template = ::Liquid::Template.parse(file_content)
-          template.registers[:file_system] = ::Metanorma::Plugin::Glossarist::Liquid::LocalFileSystem.new(
-            include_paths, ["%s.liquid", "_%s.liquid", "_%s.adoc"]
-          )
-          rendered = template.render
-
-          return rendered unless template.errors.any?
-
-          raise template.errors.first.cause
-        end
       end
     end
   end

data/lib/metanorma/plugin/glossarist/liquid/custom_blocks/with_glossarist_context.rb

@@ -1,76 +1,62 @@
 # frozen_string_literal: true
-
-require "liquid"
-require_relative "../../concept_filter"
-require_relative "../../concept_serializer"
-
 module Metanorma
   module Plugin
     module Glossarist
       module Liquid
-        module CollectionCache
-          @cache = {}
-
-          def self.fetch(folder_path)
-            @cache[folder_path] ||= begin
-              collection = ::Glossarist::ManagedConceptCollection.new
-              collection.load_from_files(folder_path)
-              collection
-            end
+        class WithGlossaristContext < ::Liquid::Block
+          def self.register!
+            ::Liquid::Environment.default.register_tag(
+              "with_glossarist_context", self
+            )
           end
-        end
-      end
-    end
-  end
-end
 
-Liquid::Template.register_tag("with_glossarist_context",
-                              Class.new(Liquid::Block) do
-                                def initialize(tag_name, markup, tokens)
-                                  super
-                                  @contexts = []
-                                  @raw_filters = {}
+          def initialize(tag_name, markup, tokens)
+            super
+            @contexts = []
+            @raw_filters = {}
 
-                                  contexts_part, filters_part = markup.strip.split(
-                                    ";", 2
-                                  )
+            contexts_part, filters_part = markup.strip.split(";", 2)
 
-                                  parse_filters(filters_part.strip) if filters_part && !filters_part.strip.empty?
+            parse_filters(filters_part.strip) if filters_part && !filters_part.strip.empty?
+
+            contexts_part.split(",").each do |context|
+              context_name, file_path = context.split("=", 2).map(&:strip)
+              @contexts << { name: context_name, file_path: file_path }
+            end
+          end
 
-                                  contexts_part.split(",").each do |context|
-                                    context_name, file_path = context.split("=").map(&:strip)
-                                    @contexts << { name: context_name,
-                                                   file_path: file_path }
-                                  end
-                                end
+          def render(context)
+            registry = context.registers[:dataset_registry]
 
-                                def render(context)
-                                  @contexts.each do |local_context|
-                                    collection = load_collection(local_context[:file_path].strip)
-                                    filtered = Metanorma::Plugin::Glossarist::ConceptFilter.new(@raw_filters).apply(collection)
-                                    context[local_context[:name]] = filtered.map do |c|
-                                      Metanorma::Plugin::Glossarist::ConceptSerializer.new(c).to_h
-                                    end
-                                  end
+            @contexts.each do |local_context|
+              path = local_context[:file_path].strip
+              collection = registry ? registry.load_cached(path) : load_collection(path)
+              filtered = ConceptFilter.new(@raw_filters).apply(collection)
+              context[local_context[:name]] = filtered.map do |c|
+                ManagedConceptDrop.new(c)
+              end
+            end
 
-                                  super
-                                end
+            super
+          end
 
-                                private
+          private
 
-                                def parse_filters(filters_str)
-                                  stripped = filters_str.gsub(/\A['"]|['"]\z/,
-                                                              "")
-                                  stripped.split(";").each do |filter|
-                                    property, value = filter.split("=", 2)
-                                    if property
-                                      @raw_filters[property.strip] =
-                                        value&.strip
-                                    end
-                                  end
-                                end
+          def parse_filters(filters_str)
+            stripped = filters_str.gsub(/\A['"]|['"]\z/, "")
+            stripped.split(";").each do |filter|
+              property, value = filter.split("=", 2)
+              @raw_filters[property.strip] = value&.strip if property
+            end
+          end
 
-                                def load_collection(folder_path)
-                                  Metanorma::Plugin::Glossarist::Liquid::CollectionCache.fetch(folder_path)
-                                end
-                              end)
+          def load_collection(folder_path)
+            collection = ::Glossarist::ManagedConceptCollection.new
+            collection.load_from_files(folder_path)
+            collection
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/glossarist/liquid/custom_filters/filters.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
-require "liquid"
-
 module Metanorma
   module Plugin
     module Glossarist
       module Liquid
         module CustomFilters
           module Filters
+            def self.register!
+              ::Liquid::Environment.default.register_filter(self)
+            end
+
             def values(list)
               list.values
             end
@@ -15,11 +17,15 @@ module Metanorma
             def sanitize_references(str)
               Sanitize.references(str)
             end
+
+            def format_ref(label)
+              return "" if label.nil? || label.strip.empty?
+
+              label.gsub(%r{[ /:]}, "_")
+            end
           end
         end
       end
     end
   end
 end
-
-Liquid::Template.register_filter(Metanorma::Plugin::Glossarist::Liquid::CustomFilters::Filters)

data/lib/metanorma/plugin/glossarist/liquid/custom_filters.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      module Liquid
+        module CustomFilters
+          autoload :Filters,
+                   "metanorma/plugin/glossarist/liquid/custom_filters/filters"
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/glossarist/liquid/drop_bracket_access.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Includes Lutaml::Model::Liquid::IndexedAccess into Glossarist collection
+# classes so that their auto-generated Liquid drops support bracket access
+# (e.g., +localizations['eng']+, +definition[0]+).
+#
+# Glossarist collections support +self[key]+ but do not yet include
+# IndexedAccess in their published gem. Once they do, this file can be
+# removed entirely.
+#
+# @see Lutaml::Model::Liquid::IndexedAccess (lutaml-model >= 0.8.15)
+# @see https://github.com/lutaml/lutaml-model/pull/705
+module Metanorma
+  module Plugin
+    module Glossarist
+      module Liquid
+        module PolyfillIndexedAccess
+          COLLECTION_CLASSES = %w[
+            Glossarist::Collections::LocalizationCollection
+            Glossarist::Collections::DetailedDefinitionCollection
+            Glossarist::Collections::ConceptSourceCollection
+          ].freeze
+
+          def self.apply!
+            COLLECTION_CLASSES.each do |class_name|
+              klass = class_name.split("::").reduce(Object) do |mod, name|
+                mod.const_get(name)
+              end
+              klass.include(Lutaml::Model::Liquid::IndexedAccess) unless klass.include?(Lutaml::Model::Liquid::IndexedAccess)
+            end
+          end
+        end
+      end
+    end
+  end
+end