metanorma-plugin-glossarist 0.3.2 → 0.3.6

data/lib/metanorma/plugin/glossarist/liquid/drops/localization_collection_drop.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      module Liquid
+        class LocalizationCollectionDrop < ::Liquid::Drop
+          include Enumerable
+
+          def initialize(collection)
+            super()
+            @collection = collection
+          end
+
+          def liquid_method_missing(method)
+            l10n = @collection.find_by(:language_code, method.to_s)
+            l10n ? l10n.to_liquid : super
+          end
+
+          def [](key)
+            liquid_method_missing(key.to_s)
+          end
+
+          def key?(key)
+            !@collection.find_by(:language_code, key.to_s).nil?
+          end
+
+          def size
+            @collection.size
+          end
+
+          def each(&block)
+            @collection.each(&block)
+          end
+
+          def first
+            @collection.first
+          end
+
+          def last
+            @collection.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/glossarist/liquid/drops/managed_concept_data_drop.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      module Liquid
+        class ManagedConceptDataDrop < ::Liquid::Drop
+          def initialize(concept_data)
+            super()
+            @concept_data = concept_data
+            @auto_drop = concept_data.to_liquid
+          end
+
+          def localizations
+            @localizations ||= LocalizationCollectionDrop.new(@concept_data.localizations)
+          end
+
+          def identifier
+            @concept_data.id
+          end
+
+          def liquid_method_missing(method)
+            @auto_drop.invoke_drop(method)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/glossarist/liquid/drops/managed_concept_drop.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      module Liquid
+        class ManagedConceptDrop < ::Liquid::Drop
+          def initialize(concept)
+            super()
+            @concept = concept
+          end
+
+          def data
+            @data ||= ManagedConceptDataDrop.new(@concept.data)
+          end
+
+          def schema_version
+            @concept.schema_version
+          end
+
+          def uuid
+            @concept.uuid
+          end
+
+          def identifier
+            @concept.identifier
+          end
+
+          def default_designation
+            @concept.default_designation
+          end
+
+          def tags
+            @concept.data.tags
+          end
+
+          def liquid_method_missing(method)
+            l10n = @concept.localization(method.to_s)
+            l10n ? l10n.to_liquid : super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,7 +16,7 @@ module Metanorma
             full_path = full_path(template_path)
 
             unless File.exist?(full_path)
-              raise FileSystemError,
+              raise ::Liquid::FileSystemError,
                     "No such template '#{template_path}'"
             end
 

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "liquid"
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      module Liquid
+        autoload :LocalFileSystem,
+                 "metanorma/plugin/glossarist/liquid/multiply_local_file_system"
+        autoload :ManagedConceptDataDrop,
+                 "metanorma/plugin/glossarist/liquid/drops/managed_concept_data_drop"
+        autoload :ManagedConceptDrop,
+                 "metanorma/plugin/glossarist/liquid/drops/managed_concept_drop"
+        autoload :LocalizationCollectionDrop,
+                 "metanorma/plugin/glossarist/liquid/drops/localization_collection_drop"
+        autoload :PolyfillIndexedAccess,
+                 "metanorma/plugin/glossarist/liquid/drop_bracket_access"
+        autoload :WithGlossaristContext,
+                 "metanorma/plugin/glossarist/liquid/custom_blocks/with_glossarist_context"
+        autoload :CustomFilters,
+                 "metanorma/plugin/glossarist/liquid/custom_filters"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "liquid"
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      module LiquidRendering
+        DEFAULT_PATTERNS = ["%s.liquid", "_%s.liquid"].freeze
+        DOCUMENT_PATTERNS = ["%s.liquid", "_%s.liquid", "_%s.adoc"].freeze
+
+        def self.render(content, include_paths:, patterns: DEFAULT_PATTERNS,
+                        assigns: {}, registry: nil)
+          template = ::Liquid::Template.parse(content)
+          template.registers[:file_system] =
+            Liquid::LocalFileSystem.new(include_paths, patterns)
+          template.registers[:dataset_registry] = registry if registry
+          rendered = template.render(assigns)
+          raise template.errors.first.cause if template.errors.any?
+
+          rendered
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/glossarist/liquid_templates/_concept.liquid

@@ -0,0 +1,51 @@
+{{ depth_marker }} {{ l10n.data.terms[0].designation }}
+{%- for term in l10n.data.terms offset:1 %}
+{%- if term.normative_status == "preferred" %}
+preferred:[{{ term.designation }}]
+{%- elsif term.normative_status == "admitted" %}
+admitted:[{{ term.designation }}]
+{%- elsif term.normative_status == "deprecated" %}
+deprecated:[{{ term.designation }}]
+{%- else %}
+alt:[{{ term.designation }}]
+{%- endif %}
+{%- endfor %}
+{% if l10n.data.domain %}
+domain:[{{ l10n.data.domain }}]
+
+{% endif %}
+{% if l10n.data.definition.definitions[0] %}
+{{ l10n.data.definition.definitions[0].content | sanitize_references }}
+
+{% endif %}
+{% for example in l10n.data.examples.definitions -%}
+[example]
+====
+{{ example.content | sanitize_references }}
+====
+
+{% endfor %}
+{% for note in l10n.data.notes.definitions -%}
+[NOTE]
+====
+{{ note.content | sanitize_references }}
+====
+
+{% endfor %}
+{% if l10n.data.annotations -%}
+{% for annotation in l10n.data.annotations.definitions -%}
+[NOTE]
+====
+{{ annotation.content | sanitize_references }}
+====
+
+{% endfor %}
+{% endif %}
+{% for source in l10n.data.sources.sources -%}
+{% assign ref_text = source.origin.text | format_ref -%}
+{% if ref_text != "" -%}
+[.source]
+<<{{ ref_text }}{% if source.origin.locality %},{{ source.origin.locality.type }}="{{ source.origin.locality.reference_from }}"{% elsif source.origin.original %},{{ source.origin.original }}{% endif %}>>{% if source.modification %}, {{ source.modification }}{% endif %}
+
+{% endif %}
+{% endfor %}

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

@@ -4,15 +4,17 @@ module Metanorma
   module Plugin
     module Glossarist
       module Sanitize
-        REF_REGEX = /{{([^,{}]+),([^}]+?)}}(.*)$/s
+        REF_REGEX = /{{(urn:[^,{}]+),([^}]+?)}}(.*)$/m
         XREF_REGEX = /<<((?>[^,>\n]+))(?:,[^>\n]*)?>>/
 
         def self.references(str)
           return str unless str&.match?(REF_REGEX)
 
-          match = str.match(REF_REGEX)
-          urn = Metanorma::Utils.to_ncname(match[1]).gsub(":", "_")
-          "{{#{urn},#{match[2]}}}#{match[3]}"
+          str.gsub(REF_REGEX) do
+            m = Regexp.last_match
+            urn = Metanorma::Utils.to_ncname(m[1]).gsub(":", "_")
+            "{{#{urn},#{m[2]}}}#{m[3]}"
+          end
         end
 
         def self.extract_xrefs(text)

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      class TemplateRenderer
+        TEMPLATES_DIR = File.join(File.dirname(__FILE__), "liquid_templates")
+        DEFAULT_TEMPLATE = File.join(TEMPLATES_DIR, "_concept.liquid")
+
+        def initialize(file_system:, lang: "eng")
+          @file_system = file_system
+          @lang = lang
+          @template_cache = {}
+        end
+
+        def render_concepts(concepts, depth:, anchor_prefix: nil)
+          tree = build_concept_tree(concepts)
+          parts = tree.map { |c| render_tree_node(c, depth, anchor_prefix) }
+          normalize_whitespace(parts.join("\n\n"))
+        end
+
+        def render_concept(concept, depth:, anchor_prefix: nil)
+          l10n = concept.localization(@lang)
+          context = {
+            "concept" => concept.to_liquid,
+            "l10n" => l10n&.to_liquid,
+            "depth_marker" => "=" * (depth + 1),
+            "anchor" => build_anchor(concept.data.id.to_s, anchor_prefix),
+          }
+          template_content = cached_template(concept)
+          rendered = render_template(template_content, context)
+          normalize_whitespace(rendered)
+        end
+
+        private
+
+        def cached_template(concept)
+          version = concept.schema_version
+          @template_cache[version] ||= begin
+            path = File.join(TEMPLATES_DIR, "_concept_#{version}.liquid")
+            File.exist?(path) ? File.read(path) : File.read(DEFAULT_TEMPLATE)
+          end
+        end
+
+        def render_tree_node((concept, children), depth, anchor_prefix)
+          result = render_concept(concept, depth: depth,
+                                           anchor_prefix: anchor_prefix)
+          children.each do |child_node|
+            result += "\n" + render_tree_node(child_node, depth + 1,
+                                              anchor_prefix)
+          end
+          result
+        end
+
+        def build_concept_tree(concepts)
+          concept_map = concepts.to_h { |c| [concept_id(c), c] }
+          children_of = Hash.new { |h, k| h[k] = [] }
+          roots = []
+
+          concepts.each do |c|
+            parent_id = find_parent_id(c)
+            if parent_id && concept_map[parent_id]
+              children_of[parent_id] << c
+            else
+              roots << c
+            end
+          end
+
+          build_tree_nodes(roots, children_of)
+        end
+
+        def build_tree_nodes(concepts, children_of)
+          concepts.map do |c|
+            [c, build_tree_nodes(children_of[concept_id(c)], children_of)]
+          end
+        end
+
+        def concept_id(concept)
+          concept.data.id.to_s
+        end
+
+        def find_parent_id(concept)
+          concept.data.related&.find { |r| r.type == "broader" }&.ref&.id&.to_s
+        end
+
+        def build_anchor(id, prefix)
+          anchor = prefix ? "#{prefix}#{id}" : id
+          if anchor.match?(/\A\d/)
+            anchor
+          else
+            Metanorma::Utils.to_ncname(anchor.gsub(
+                                         ":", "_"
+                                       ))
+          end
+        end
+
+        def render_template(content, assigns)
+          LiquidRendering.render(
+            content,
+            include_paths: [TEMPLATES_DIR, @file_system].compact,
+            assigns: assigns,
+          )
+        end
+
+        def normalize_whitespace(text)
+          text.gsub(/\n{3,}/, "\n\n")
+            .gsub(/([^\]\n])\n(={2,6} )/, "\\1\n\n\\2")
+            .strip
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Metanorma
   module Plugin
     module Glossarist
-      VERSION = "0.3.2"
+      VERSION = "0.3.6"
     end
   end
 end

data/lib/metanorma-plugin-glossarist.rb

@@ -2,10 +2,29 @@
 
 require "metanorma/plugin/glossarist/version"
 require "metanorma-utils"
-require "metanorma/plugin/glossarist/sanitize"
-require "metanorma/plugin/glossarist/concept_serializer"
-require "metanorma/plugin/glossarist/concept_renderer"
-require "metanorma/plugin/glossarist/bibliography_renderer"
-require "metanorma/plugin/glossarist/concept_filter"
-require "metanorma/plugin/glossarist/document"
-require "metanorma/plugin/glossarist/dataset_preprocessor"
+require "glossarist"
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      autoload :BibliographyRenderer,
+               "metanorma/plugin/glossarist/bibliography_renderer"
+      autoload :ConceptFilter, "metanorma/plugin/glossarist/concept_filter"
+      autoload :ConceptPathResolver,
+               "metanorma/plugin/glossarist/concept_path_resolver"
+      autoload :DatasetPreprocessor,
+               "metanorma/plugin/glossarist/dataset_preprocessor"
+      autoload :DatasetRegistry, "metanorma/plugin/glossarist/dataset_registry"
+      autoload :Document, "metanorma/plugin/glossarist/document"
+      autoload :Liquid, "metanorma/plugin/glossarist/liquid"
+      autoload :LiquidRendering, "metanorma/plugin/glossarist/liquid_rendering"
+      autoload :Sanitize, "metanorma/plugin/glossarist/sanitize"
+      autoload :TemplateRenderer,
+               "metanorma/plugin/glossarist/template_renderer"
+    end
+  end
+end
+
+Metanorma::Plugin::Glossarist::Liquid::PolyfillIndexedAccess.apply!
+Metanorma::Plugin::Glossarist::Liquid::WithGlossaristContext.register!
+Metanorma::Plugin::Glossarist::Liquid::CustomFilters::Filters.register!

data/metanorma-plugin-glossarist.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 3.1.0"
 
   spec.add_dependency "asciidoctor"
-  spec.add_dependency "glossarist", "~> 2.6.0"
+  spec.add_dependency "glossarist", "~> 2.8", ">= 2.8.7"
   spec.add_dependency "liquid"
   spec.add_dependency "metanorma-utils"
   spec.metadata["rubygems_mfa_required"] = "true"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-plugin-glossarist
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-13 00:00:00.000000000 Z
+date: 2026-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -30,14 +30,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.6.0
+        version: '2.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.6.0
+        version: '2.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.7
 - !ruby/object:Gem::Dependency
   name: liquid
   requirement: !ruby/object:Gem::Requirement
@@ -90,14 +96,23 @@ files:
 - lib/metanorma-plugin-glossarist.rb
 - lib/metanorma/plugin/glossarist/bibliography_renderer.rb
 - lib/metanorma/plugin/glossarist/concept_filter.rb
-- lib/metanorma/plugin/glossarist/concept_renderer.rb
-- lib/metanorma/plugin/glossarist/concept_serializer.rb
+- lib/metanorma/plugin/glossarist/concept_path_resolver.rb
 - lib/metanorma/plugin/glossarist/dataset_preprocessor.rb
+- lib/metanorma/plugin/glossarist/dataset_registry.rb
 - lib/metanorma/plugin/glossarist/document.rb
+- lib/metanorma/plugin/glossarist/liquid.rb
 - lib/metanorma/plugin/glossarist/liquid/custom_blocks/with_glossarist_context.rb
+- lib/metanorma/plugin/glossarist/liquid/custom_filters.rb
 - lib/metanorma/plugin/glossarist/liquid/custom_filters/filters.rb
+- lib/metanorma/plugin/glossarist/liquid/drop_bracket_access.rb
+- lib/metanorma/plugin/glossarist/liquid/drops/localization_collection_drop.rb
+- lib/metanorma/plugin/glossarist/liquid/drops/managed_concept_data_drop.rb
+- lib/metanorma/plugin/glossarist/liquid/drops/managed_concept_drop.rb
 - lib/metanorma/plugin/glossarist/liquid/multiply_local_file_system.rb
+- lib/metanorma/plugin/glossarist/liquid_rendering.rb
+- lib/metanorma/plugin/glossarist/liquid_templates/_concept.liquid
 - lib/metanorma/plugin/glossarist/sanitize.rb
+- lib/metanorma/plugin/glossarist/template_renderer.rb
 - lib/metanorma/plugin/glossarist/version.rb
 - metanorma-plugin-glossarist.gemspec
 homepage: https://github.com/metanorma/metanorma-plugin-glossarist

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Plugin
-    module Glossarist
-      class ConceptRenderer
-        TERM_TYPES = %w[preferred admitted deprecated].freeze
-
-        def initialize(concept, depth:, anchor_prefix: nil)
-          @concept = concept
-          @depth = depth
-          @anchor_prefix = anchor_prefix
-        end
-
-        def render
-          sections = [concept_header]
-          sections << alt_terms_section
-          sections << definition_section
-          sections << examples_section
-          sections << notes_section
-          sections << sources_section
-          sections.compact.join("\n\n")
-        end
-
-        private
-
-        def eng_l10n
-          @eng_l10n ||= @concept.localization("eng")
-        end
-
-        def concept_header
-          "[[#{anchor_id}]]\n#{heading_line}"
-        end
-
-        def anchor_id
-          id = "#{@anchor_prefix}#{@concept.data.id}"
-          id.match?(/\A\d/) ? id : Metanorma::Utils.to_ncname(id.gsub(":", "_"))
-        end
-
-        def heading_line
-          "#{'=' * (@depth + 1)} #{term_designation}"
-        end
-
-        def term_designation
-          eng_l10n.terms.first&.designation.to_s
-        end
-
-        def alt_terms_section
-          terms = eng_l10n.terms[1..].map do |term|
-            type = TERM_TYPES.include?(term.normative_status) ? term.normative_status : "alt"
-            "#{type}:[#{term.designation}]"
-          end
-          terms.empty? ? nil : terms.join("\n")
-        end
-
-        def definition_section
-          content = eng_l10n.definition.first&.content
-          return nil unless content
-
-          Sanitize.references(content.to_s)
-        end
-
-        def examples_section
-          examples = eng_l10n.examples.map do |example|
-            "[example]\n#{Sanitize.references(example.content.to_s)}"
-          end
-          examples.empty? ? nil : examples.join("\n")
-        end
-
-        def notes_section
-          notes = eng_l10n.notes.map do |note|
-            "[NOTE]\n====\n#{Sanitize.references(note.content.to_s)}\n===="
-          end
-          notes.empty? ? nil : notes.join("\n")
-        end
-
-        def sources_section
-          sources = eng_l10n.sources.filter_map do |source|
-            next if source.origin&.text.nil? || source.origin.text.empty?
-            next unless source.origin.locality&.type == "clause"
-
-            ref = source.origin.text.gsub(%r{[ /:]}, "_")
-            clause = source.origin.locality.reference_from
-            "[.source]\n<<#{ref},#{clause}>>"
-          end
-          sources.empty? ? nil : sources.join("\n")
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Plugin
-    module Glossarist
-      class ConceptSerializer
-        def initialize(concept)
-          @concept = concept
-        end
-
-        def to_h
-          data = @concept.data.to_hash
-          data["localizations"] = localizations_hash unless @concept.localizations.empty?
-          { "data" => data.compact }
-        end
-
-        private
-
-        def localizations_hash
-          @concept.localizations.to_h do |l10n|
-            [l10n.language_code, l10n.to_hash]
-          end
-        end
-      end
-    end
-  end
-end