metanorma-plugin-glossarist 0.3.3 → 0.3.7

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

@@ -4,11 +4,12 @@ module Metanorma
   module Plugin
     module Glossarist
       class ConceptFilter
-        COLLECTION_FILTERS = %w[lang domain group sort_by].freeze
+        COLLECTION_FILTERS = %w[lang domain group section tag sort_by].freeze
         SORT_LAST = ["￿"].freeze
 
         def initialize(filters)
           @filters = filters || {}
+          @resolver = ConceptPathResolver.new
         end
 
         def apply(collection)
@@ -17,6 +18,8 @@ module Metanorma
           if @filters.key?("domain") || @filters.key?("group")
             result = filter_by_domain(result)
           end
+          result = filter_by_section(result) if @filters.key?("section")
+          result = filter_by_tag(result) if @filters.key?("tag")
           result = filter_by_field(result) if field_filter?
           result = sort(result) if @filters.key?("sort_by")
           result
@@ -44,6 +47,20 @@ module Metanorma
           end
         end
 
+        def filter_by_tag(collection)
+          tag = @filters["tag"]
+          collection.select do |c|
+            c.data.tags&.include?(tag)
+          end
+        end
+
+        def filter_by_section(collection)
+          section_id = @filters["section"]
+          collection.select do |c|
+            c.data.domains&.any? { |d| d.concept_id == "section-#{section_id}" }
+          end
+        end
+
         def sort(collection)
           field = @filters["sort_by"]
           return collection unless field
@@ -52,14 +69,12 @@ module Metanorma
           when "term", "default_designation"
             collection.sort_by { |c| c.default_designation.to_s.downcase }
           else
-            parts = parse_path(field)
-            collection.sort_by { |c| sort_key(c, parts) }
+            collection.sort_by { |c| sort_key(c, field) }
           end
         end
 
-        def sort_key(concept, parts)
-          hash = ConceptSerializer.new(concept).to_h
-          value = dig_path(hash, parts)
+        def sort_key(concept, field)
+          value = @resolver.resolve(concept, field)
           value.nil? ? SORT_LAST : natural_sort_key(value.to_s)
         end
 
@@ -75,10 +90,8 @@ module Metanorma
           start_with = path.include?(".start_with(")
           path, match_value = extract_start_with(path, value, start_with)
 
-          parts = parse_path(path)
           collection.select do |concept|
-            hash = ConceptSerializer.new(concept).to_h
-            actual = dig_path(hash, parts)
+            actual = @resolver.resolve(concept, path)
             if start_with
               actual&.start_with?(match_value)
             else
@@ -95,37 +108,6 @@ module Metanorma
 
           [match[1], match[2]]
         end
-
-        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 dig_path(hash, parts)
-          parts.reduce(hash) do |current, key|
-            case current
-            when Hash
-              current[key] || current[key.to_s]
-            when Array
-              key.is_a?(Integer) ? current[key] : nil
-            end
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,117 @@
+# 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
+            read_attribute(obj, key)
+          when Hash
+            obj[key] || obj[key.to_s]
+          end
+        end
+
+        def resolve_managed_concept(concept, key)
+          if DELEGATED_TO_DATA.include?(key)
+            return read_attribute(concept.data,
+                                  key)
+          end
+
+          read_attribute(concept, key) { read_method(concept, key) }
+        rescue NoMethodError
+          nil
+        end
+
+        def resolve_data_attribute(data, key)
+          aliased = DATA_ALIASES[key]
+          if aliased && data.class.attributes.key?(aliased)
+            return read_attribute(data, aliased)
+          end
+
+          read_attribute(data, key)
+        end
+
+        # Reads a validated public attribute from a Lutaml::Model::Serializable
+        # object. Uses public_send because the attribute name is determined at
+        # runtime from path strings. Falls back to the block for non-attribute
+        # public methods (e.g., ManagedConcept#default_designation).
+        def read_attribute(obj, key)
+          sym = key.to_sym
+          if obj.class.respond_to?(:attributes) && obj.class.attributes.key?(sym)
+            obj.public_send(sym)
+          elsif block_given?
+            yield
+          end
+        end
+
+        # Calls a public method by name on the object. Used as a fallback for
+        # methods that aren't lutaml-model attributes (e.g., computed accessors).
+        def read_method(obj, key)
+          obj.public_send(key.to_sym)
+        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,38 +4,35 @@ 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
       class DatasetPreprocessor < Asciidoctor::Extensions::Preprocessor
         DATASET_ATTR_REGEX = /^:glossarist-dataset:\s*(.*?)$/m
         IMPORT_REGEX = /^glossarist::import\[(.*?)\]$/m
+        IMPORT_SECTIONS_REGEX = /^glossarist::import_sections\[(.*?)\]$/m
         RENDER_REGEX = /^glossarist::render\[(.*?)\]$/m
         BLOCK_REGEX = /^\[glossarist,(.+?),(.+?)\]$/m
         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
+          @renderer = TemplateRenderer.new(file_system: @config[:file_system])
+          @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 +54,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
@@ -75,6 +73,8 @@ module Metanorma
             process_dataset_tag(document, input_lines, liquid_doc, match)
           elsif (match = current_line.match(RENDER_REGEX))
             process_render_tag(liquid_doc, match)
+          elsif (match = current_line.match(IMPORT_SECTIONS_REGEX))
+            process_import_sections_tag(document, liquid_doc, match)
           elsif (match = current_line.match(IMPORT_REGEX))
             process_import_tag(liquid_doc, match)
           elsif (match = current_line.match(BIBLIOGRAPHY_REGEX))
@@ -88,14 +88,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 +140,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 +150,115 @@ 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 = @renderer
+          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
+          filter_options = options.except(*RENDER_OPTIONS)
+          concepts = ConceptFilter.new(filter_options).apply(dataset)
+          concepts = concepts.select(&:default_designation)
+          @rendered_concepts.concat(concepts)
+          renderer = @renderer
+          rendered = renderer.render_concepts(concepts,
+                                              depth: @title_depth,
+                                              anchor_prefix: options["anchor-prefix"])
+          liquid_doc.add_content("\n#{rendered}")
+        end
 
-            renderer = ConceptRenderer.new(concept,
-                                           depth: @title_depth,
-                                           anchor_prefix: options["anchor-prefix"])
-            renderer.render
-          end.join("\n\n")
+        def process_import_sections_tag(_document, liquid_doc, match)
+          @seen_glossarist = true
+          matches = match[1].split(",").map(&:strip)
+          context_name = matches[0]
+          options = parse_options(matches[1..])
 
-          liquid_doc.add_content(rendered)
+          sections = @registry.register_sections(context_name)
+          return unless sections && !sections.empty?
+
+          dataset = @registry.resolve_dataset(nil, context_name)
+          return unless dataset
+
+          renderer = @renderer
+          sort_by = options["sort_by"] || "term"
+          section_filter = SectionFilter.new(
+            exclude: (options["section_exclude"] || "").split("|"),
+            include: (options["section_include"] || "").split("|"),
+          )
+          filtered = section_filter.apply(sections)
+          parts = render_section_concepts(filtered, dataset, renderer,
+                                          sort_by, options)
+          liquid_doc.add_content("\n#{parts.join("\n\n")}")
+        end
+
+        def render_section_concepts(sections, dataset, renderer, sort_by,
+                                    options)
+          sections.filter_map do |section|
+            filter_options = { "section" => section.id, "sort_by" => sort_by }
+            concepts = ConceptFilter.new(filter_options).apply(dataset)
+            concepts = concepts.select(&:default_designation)
+            next if concepts.empty?
+
+            @rendered_concepts.concat(concepts)
+            heading = "#{'=' * (@title_depth + 1)} #{section.name || section.id}"
+            rendered = renderer.render_concepts(concepts,
+                                                depth: @title_depth + 1,
+                                                anchor_prefix: options["anchor-prefix"])
+            "#{heading}\n\n#{rendered}"
+          end
         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,108 @@
+# 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 register_sections(context_name)
+          dataset_path = context_path(context_name)
+          return nil unless dataset_path
+
+          @register_cache ||= {}
+          @register_cache[dataset_path] ||=
+            ::Glossarist::DatasetRegister.from_directory(dataset_path)
+          @register_cache[dataset_path]&.sections
+        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,14 @@ module Metanorma
 
         def add_content(content, options = {})
           @content << if options[:render]
-                        render_liquid(content, options)
+                        LiquidRendering.render(
+                          content,
+                          include_paths: [file_system,
+                                          TEMPLATES_DIR,
+                                          options[:template]].compact,
+                          patterns: LiquidRendering::DOCUMENT_PATTERNS,
+                          registry: registry,
+                        )
                       else
                         content
                       end
@@ -24,21 +28,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