metanorma-plugin-glossarist 0.3.3 → 0.3.7

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

@@ -1,76 +1,63 @@
 # 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("=").map(&:strip)
-                                    @contexts << { name: context_name,
-                                                   file_path: file_path }
-                                  end
-                                end
+            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
 
-                                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
+          def render(context)
+            registry = context.registers[:dataset_registry]
 
-                                  super
-                                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
 
-                                private
+            super
+          end
 
-                                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
+          private
 
-                                def load_collection(folder_path)
-                                  Metanorma::Plugin::Glossarist::Liquid::CollectionCache.fetch(folder_path)
-                                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)
+            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

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,52 @@
+{% if anchor %}[[{{ anchor }}]]
+{% endif %}{{ 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/section_filter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      # Filters an array of Glossarist::Section objects by include/exclude patterns.
+      #
+      # Pattern matching uses *substring* matching against section IDs
+      # (e.g., pattern "3" matches sections with IDs "3", "3.1", "34").
+      # For the common _arm/_mim filtering, use patterns like "_arm" and "_mim"
+      # which are specific enough to avoid false positives.
+      #
+      # @example Exclude _arm and _mim sections
+      #   SectionFilter.new(exclude: ["_arm", "_mim"]).apply(sections)
+      #
+      # @example Include only _arm sections
+      #   SectionFilter.new(include: ["_arm"]).apply(sections)
+      class SectionFilter
+        # @param exclude [Array<String>] substring patterns; sections whose ID
+        #   contains any of these are removed
+        # @param include [Array<String>] substring patterns; only sections whose
+        #   ID contains at least one of these are kept (empty = include all)
+        def initialize(exclude: [], include: [])
+          @exclude = exclude.reject(&:empty?)
+          @include = include.reject(&:empty?)
+        end
+
+        # @param sections [Array<Glossarist::Section>]
+        # @return [Array<Glossarist::Section>]
+        def apply(sections)
+          sections.select { |s| matches?(s) }
+        end
+
+        private
+
+        def matches?(section)
+          !excluded?(section) && included?(section)
+        end
+
+        def excluded?(section)
+          @exclude.any? { |p| section.id.include?(p) }
+        end
+
+        def included?(section)
+          @include.empty? || @include.any? { |p| section.id.include?(p) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      class TemplateRenderer
+        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.3"
+      VERSION = "0.3.7"
     end
   end
 end