metanorma-plugin-glossarist 0.3.9 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c239554930b872ac67bfa16144dbc77cabd558ff26f623c0b4cdfe53d56541c1
-  data.tar.gz: 03a9282d88ea2ed4087d70bc23d4cd41d2e31327890d0c427ca48d4e403a3a65
+  metadata.gz: 0e98a4e95056510d3c6071f7c46e4bd378b2898e7fa75b44e14d5ca423efc4ca
+  data.tar.gz: ebbf812935c1fb98b523675892813de831c1ec87d152d0de78d1fd9103d6342d
 SHA512:
-  metadata.gz: e1fcb83d207dfc99e857e4648cc69033c22072661d60081e9f001399666aad2534b84a9efafc95f3cdd324bcaa8446de37bb19ad2b9efb364c107a349d7cb27b
-  data.tar.gz: ebb50f86f097af9e82c93fc8f4112971ba407b66a793e9ed662ea9151eca3e91105e62fbded44a42a9d8cf86b6d738bd57e5331be84f1f2a2a657bb992cc77e7
+  metadata.gz: 99d6b54e76a006d51f7f657e5d408139e0dbcb1af14545f17d8f08f157d7c197c52a88934c84238560d5860dc0131fe78b4b4933c155934aea11410239a8cf6e
+  data.tar.gz: 34f5d1c25bb615c2a2a3efdac7710b9dd8e06d0c98c4f63bc4f8846475a952715fdf2269ca4dbc970a9bd5e0bdc17327f9f8204ef2c3a5ba42ed30a75d299747

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

@@ -15,6 +15,7 @@ module Metanorma
         BLOCK_REGEX = /^\[glossarist,(.+?),(.+?)\]$/m
         BIBLIOGRAPHY_REGEX = /^glossarist::render_bibliography\[(.*?)\]$/m
         BIBLIOGRAPHY_ENTRY_REGEX = /^glossarist::render_bibliography_entry\[(.*?)\]$/m
+        NON_VERBAL_REGEX = /^glossarist::render_(figures|tables|formulas)\[(.*?)\]$/m
 
         BIB_ANCHOR_REGEX = /^\*\s*\[\[\[([^,]+)/
 
@@ -69,32 +70,47 @@ module Metanorma
         end
 
         def process_line(document, input_lines, current_line, liquid_doc)
-          if (match = current_line.match(DATASET_ATTR_REGEX))
-            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))
-            process_bibliography(document, liquid_doc, match)
-          elsif (match = current_line.match(BIBLIOGRAPHY_ENTRY_REGEX))
-            process_bibliography_entry(document, liquid_doc, match)
-          elsif (match = current_line.match(BLOCK_REGEX))
-            process_glossarist_block(document, liquid_doc, input_lines, match)
+          handler = directive_handler(current_line)
+          if handler
+            handler.call(document, input_lines, liquid_doc)
           else
-            if /^==+ \S/.match?(current_line)
-              @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)
+            handle_plain_line(current_line, liquid_doc)
+          end
+        end
+
+        # Returns a callable that handles the directive on +line+, or nil
+        # for plain content. Keeping the dispatch table small (regex →
+        # block) lets us add a new directive by appending one entry.
+        def directive_handler(line)
+          if (m = line.match(DATASET_ATTR_REGEX))
+            ->(doc, lines, ldoc) { process_dataset_tag(doc, lines, ldoc, m) }
+          elsif (m = line.match(RENDER_REGEX))
+            ->(_, _, ldoc) { process_render_tag(ldoc, m) }
+          elsif (m = line.match(IMPORT_SECTIONS_REGEX))
+            ->(doc, _, ldoc) { process_import_sections_tag(doc, ldoc, m) }
+          elsif (m = line.match(IMPORT_REGEX))
+            ->(_, _, ldoc) { process_import_tag(ldoc, m) }
+          elsif (m = line.match(BIBLIOGRAPHY_REGEX))
+            ->(doc, _, ldoc) { process_bibliography(doc, ldoc, m) }
+          elsif (m = line.match(BIBLIOGRAPHY_ENTRY_REGEX))
+            ->(doc, _, ldoc) { process_bibliography_entry(doc, ldoc, m) }
+          elsif (m = line.match(NON_VERBAL_REGEX))
+            ->(_, _, ldoc) { process_non_verbal(ldoc, m) }
+          elsif (m = line.match(BLOCK_REGEX))
+            ->(doc, lines, ldoc) { process_glossarist_block(doc, ldoc, lines, m) }
           end
         end
 
+        def handle_plain_line(current_line, liquid_doc)
+          if /^==+ \S/.match?(current_line)
+            @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
+
         def process_dataset_tag(document, input_lines, liquid_doc, match)
           @seen_glossarist = true
           @registry.register(document, match[1])
@@ -157,7 +173,8 @@ module Metanorma
           renderer = @renderer
           rendered = renderer.render_concept(concept,
                                              depth: @title_depth,
-                                             anchor_prefix: options["anchor-prefix"])
+                                             anchor_prefix: options["anchor-prefix"],
+                                             non_verbal: non_verbal_for(context_name))
           liquid_doc.add_content("\n#{rendered}")
         end
 
@@ -179,7 +196,8 @@ module Metanorma
           renderer = @renderer
           rendered = renderer.render_concepts(concepts,
                                               depth: @title_depth,
-                                              anchor_prefix: options["anchor-prefix"])
+                                              anchor_prefix: options["anchor-prefix"],
+                                              non_verbal: non_verbal_for(context_name))
           liquid_doc.add_content("\n#{rendered}")
         end
 
@@ -196,11 +214,11 @@ module Metanorma
           dataset = @registry.resolve_dataset(nil, context_name)
           return unless dataset
 
-          parts = render_sections(dataset, register, sections, options)
+          parts = render_sections(dataset, register, sections, context_name, options)
           liquid_doc.add_content("\n#{parts.join("\n\n")}")
         end
 
-        def render_sections(dataset, register, sections, options)
+        def render_sections(dataset, register, sections, context_name, options)
           section_filter = SectionFilter.new(
             exclude: (options["section_exclude"] || "").split("|"),
             include: (options["section_include"] || "").split("|"),
@@ -213,12 +231,25 @@ module Metanorma
             depth: @title_depth,
             sort_by: options["sort_by"] || SectionRenderer::DEFAULT_SORT_BY,
             anchor_prefix: options["anchor-prefix"],
+            non_verbal: non_verbal_for(context_name),
           )
           renderer.render(filtered) do |concepts|
             @rendered_concepts.concat(concepts)
           end
         end
 
+        # Builds a NonVerbalRenderer scoped to a dataset context, or
+        # returns nil if the dataset has no figures/tables/formulas. The
+        # resulting renderer is passed through to TemplateRenderer and
+        # SectionRenderer so concept-attached refs render as AsciiDoc
+        # blocks alongside the concept body.
+        def non_verbal_for(context_name)
+          collections = @registry.non_verbal_collections(context_name)
+          return nil if collections.empty?
+
+          NonVerbalRenderer.new(collections: collections)
+        end
+
         def process_bibliography(document, liquid_doc, match)
           @seen_glossarist = true
           dataset_name = match[1].strip
@@ -252,6 +283,21 @@ module Metanorma
           liquid_doc.add_content(entry) if entry
         end
 
+        # Renders all dataset-level entities of a non-verbal kind
+        # (figures, tables, formulas) as AsciiDoc blocks. The directive
+        # shape is +glossarist::render_<kind>[dataset]+.
+        def process_non_verbal(liquid_doc, match)
+          @seen_glossarist = true
+          kind = :"#{match[1]}"
+          dataset_name = match[2].strip
+          collection = @registry.non_verbal_collection(dataset_name, kind)
+          return unless collection
+
+          renderer = NonVerbalRenderer.new(collections: { kind => collection })
+          rendered = renderer.render_kind(kind)
+          liquid_doc.add_content("\n#{rendered}") unless rendered.empty?
+        end
+
         def relative_file_path(document, file_path)
           return file_path if File.absolute_path?(file_path)
 

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

@@ -8,17 +8,28 @@ module Metanorma
       # Resolves, caches, and exposes dataset models for a document.
       #
       # Single source of truth for everything the preprocessor needs from a
-      # glossarist dataset: concepts, section hierarchy, and bibliography.
+      # glossarist dataset: concepts, section hierarchy, bibliography, and
+      # dataset-level non-verbal entities (figures, tables, formulas).
       # Each is exposed as the typed Glossarist model object so callers
       # never poke at raw YAML hashes.
       class DatasetRegistry
         BIBLIOGRAPHY_FILENAME = "bibliography.yaml"
         REGISTER_FILENAME = "register.yaml"
 
+        # Map of plural kind symbol → (collection class, subdirectory name).
+        # Adding a new non-verbal kind = adding one entry here. The accessor
+        # `{kind}_for` and loader are derived from this table.
+        NON_VERBAL_KINDS = {
+          figures: [::Glossarist::Collections::FigureCollection, "figures"],
+          tables: [::Glossarist::Collections::TableCollection, "tables"],
+          formulas: [::Glossarist::Collections::FormulaCollection, "formulas"],
+        }.freeze
+
         def initialize
           @stores = {}
           @registers = {}
           @bibliographies = {}
+          @non_verbal = {}
           @context_paths = {}
         end
 
@@ -81,6 +92,38 @@ module Metanorma
           store_for(path).concepts
         end
 
+        # Returns the typed NonVerbalCollection for a registered context
+        # (e.g. FigureCollection), or nil if the dataset has no such
+        # subdirectory. +kind+ is one of the keys of NON_VERBAL_KINDS.
+        def non_verbal_collection(context_name, kind)
+          unless NON_VERBAL_KINDS.key?(kind)
+            raise ArgumentError, "unknown non-verbal kind: #{kind.inspect}"
+          end
+
+          path = @context_paths[context_name]
+          return nil unless path
+
+          collection_class, subdir = NON_VERBAL_KINDS.fetch(kind)
+          non_verbal_at(path, kind, subdir, collection_class)
+        end
+
+        NON_VERBAL_KINDS.each_key do |kind|
+          define_method("#{kind}_for") do |context_name|
+            non_verbal_collection(context_name, kind)
+          end
+        end
+
+        # Returns all available non-verbal collections for a context as a
+        # hash keyed by kind symbol (e.g. +{ figures: FigureCollection }+).
+        # Kinds whose subdirectory doesn't exist are omitted. Convenient
+        # for building a NonVerbalRenderer in one call.
+        def non_verbal_collections(context_name)
+          NON_VERBAL_KINDS.each_with_object({}) do |(kind, _), memo|
+            collection = non_verbal_collection(context_name, kind)
+            memo[kind] = collection if collection
+          end
+        end
+
         private
 
         def concepts_for(context_name)
@@ -108,6 +151,14 @@ module Metanorma
           end
         end
 
+        def non_verbal_at(path, kind, subdir, collection_class)
+          dir = File.join(path, subdir)
+          return nil unless File.directory?(dir)
+
+          @non_verbal[path] ||= {}
+          @non_verbal[path][kind] ||= collection_class.from_directory(dir)
+        end
+
         def relative_file_path(document, file_path)
           return file_path if File.absolute_path?(file_path)
 

data/lib/metanorma/plugin/glossarist/non_verbal_formatters/base.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      module NonVerbalFormatters
+        # Shared rendering helpers for non-verbal entity formatters.
+        #
+        # Each formatter owns the kind-specific body (image block, table
+        # block, stem block) and delegates anchor, caption, and a11y
+        # framing to this base. Localized text is resolved by ISO 639 code
+        # with graceful fallback to the first available value.
+        class Base
+          def initialize(entity, lang: "eng")
+            @entity = entity
+            @lang = lang
+          end
+
+          def to_asciidoc
+            parts = [anchor_line, caption_line, body].compact.reject(&:empty?)
+            "#{parts.join("\n")}\n"
+          end
+
+          protected
+
+          attr_reader :entity, :lang
+
+          # Subclasses implement this with the kind-specific AsciiDoc body
+          # (e.g. image::, table, stem block).
+          def body
+            raise NotImplementedError
+          end
+
+          def anchor_line
+            id = entity.id
+            id ? "[[#{id}]]" : nil
+          end
+
+          def caption_line
+            text = localized(entity.caption)
+            text ? ".#{text}" : nil
+          end
+
+          def alt_text
+            localized(entity.alt)
+          end
+
+          def description_text
+            localized(entity.description)
+          end
+
+          # Picks the value for the requested language, falling back to
+          # the first available value if missing. Returns nil for empty
+          # or absent hashes.
+          def localized(hash)
+            return nil if hash.nil? || hash.empty?
+
+            hash[lang] || hash.values.first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/glossarist/non_verbal_formatters/figure.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      module NonVerbalFormatters
+        # Renders a Glossarist::Figure as an AsciiDoc image block.
+        #
+        # Picks a single best image variant: vector (SVG) preferred for
+        # resolution-independence, then any first image. Subfigures are
+        # rendered recursively as separate image blocks so each carries
+        # its own anchor and caption.
+        class Figure < Base
+          ROLE_PRIORITY = %w[vector raster print light dark].freeze
+
+          protected
+
+          def body
+            image = best_image
+            return subfigure_blocks if image.nil?
+
+            line = "image::#{image.src}[#{image_attrs(image)}]"
+            subfigure_blocks ? "#{line}\n\n#{subfigure_blocks}" : line
+          end
+
+          private
+
+          def best_image
+            images = Array(entity.images)
+            return nil if images.empty?
+
+            ROLE_PRIORITY.each do |role|
+              found = images.find { |img| img.role == role }
+              return found if found
+            end
+            images.first
+          end
+
+          def image_attrs(image)
+            attrs = []
+            attrs << alt_text if alt_text
+            attrs << "width=#{image.width}" if image.width
+            attrs << "height=#{image.height}" if image.height
+            attrs.join(",")
+          end
+
+          def subfigure_blocks
+            subs = Array(entity.subfigures)
+            return nil if subs.empty?
+
+            subs.map do |sub|
+              self.class.new(sub, lang: lang).to_asciidoc
+            end.join("\n").strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/glossarist/non_verbal_formatters/formula.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      module NonVerbalFormatters
+        # Renders a Glossarist::Formula as an AsciiDoc stem block.
+        #
+        # The expression hash is keyed by language (matching caption/alt);
+        # the +notation+ field carries the markup language (latex, mathml,
+        # asciimath) but the body is format-agnostic — Metanorma's stem
+        # block accepts any notation supported by the renderer.
+        class Formula < Base
+          protected
+
+          def body
+            expr = localized(entity.expression)
+            return "" if expr.nil? || expr.empty?
+
+            <<~STEM
+              [stem]
+              ++++
+              #{expr}
+              ++++
+            STEM
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/glossarist/non_verbal_formatters/table.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      module NonVerbalFormatters
+        # Renders a Glossarist::Table as an AsciiDoc table block.
+        #
+        # Two payload shapes are supported:
+        #   - +format: structured+ — +content+ has +headers+ and +rows+
+        #     arrays, rendered as an AsciiDoc table.
+        #   - +format: asciidoc+ (or any non-structured) — +content+ is a
+        #     raw markup string emitted verbatim between caption and the
+        #     next block.
+        class Table < Base
+          STRUCTURED = "structured"
+
+          protected
+
+          def body
+            entity.format == STRUCTURED ? structured_table : raw_block
+          end
+
+          private
+
+          def structured_table
+            lines = ["|==="]
+            append_headers(lines)
+            Array(entity.content&.dig("rows")).each do |row|
+              lines << "|#{Array(row).join(' |')}"
+            end
+            lines << "|==="
+            lines.join("\n")
+          end
+
+          def append_headers(lines)
+            headers = Array(entity.content&.dig("headers"))
+            lines << "|#{headers.join(' |')}" unless headers.empty?
+          end
+
+          def raw_block
+            content = entity.content
+            (content&.dig("asciidoc") || content&.dig("text")).to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      # Namespace for per-kind AsciiDoc formatters for dataset-level
+      # non-verbal entities. Adding a new kind = adding a new formatter
+      # class and registering it in NonVerbalRenderer::FORMATTERS.
+      module NonVerbalFormatters
+        autoload :Base, "metanorma/plugin/glossarist/non_verbal_formatters/base"
+        autoload :Figure,
+                 "metanorma/plugin/glossarist/non_verbal_formatters/figure"
+        autoload :Table,
+                 "metanorma/plugin/glossarist/non_verbal_formatters/table"
+        autoload :Formula,
+                 "metanorma/plugin/glossarist/non_verbal_formatters/formula"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Plugin
+    module Glossarist
+      # Renders dataset-level non-verbal entities (Figure, Table, Formula)
+      # as AsciiDoc blocks. MECE sibling to BibliographyRenderer: where
+      # BibliographyRenderer owns citation provenance, NonVerbalRenderer
+      # owns the rendering of authored figures/tables/formulas.
+      #
+      # Per-kind formatting is delegated to a formatter class registered
+      # in +FORMATTERS+. Adding a new kind = adding one formatter class
+      # and one entry here; the dispatcher itself never changes shape.
+      class NonVerbalRenderer
+        FORMATTERS = {
+          figures: NonVerbalFormatters::Figure,
+          tables: NonVerbalFormatters::Table,
+          formulas: NonVerbalFormatters::Formula,
+        }.freeze
+
+        # @param collections [Hash{Symbol => NonVerbalCollection, nil}]
+        #   one entry per non-verbal kind, e.g.
+        #   `{ figures: FigureCollection, tables: ..., formulas: ... }`.
+        #   Missing or nil entries are silently skipped.
+        def initialize(collections:, lang: "eng")
+          @collections = collections
+          @lang = lang
+        end
+
+        # Render every entity in the named collection.
+        #
+        # @param kind [Symbol] key in FORMATTERS (e.g. +:figures+)
+        # @return [String] AsciiDoc blocks joined by blank lines, or ""
+        def render_kind(kind)
+          collection = @collections[kind]
+          return "" if collection.nil? || collection.entries.empty?
+
+          entries = collection.entries
+          "#{entries.map { |e| format_one(kind, e) }.join("\n\n")}\n"
+        end
+
+        # Render the non-verbal entities referenced by a concept's
+        # figures/tables/formulas ref collections, in deterministic order
+        # (figures, tables, formulas). Unknown refs are skipped silently —
+        # they will surface as missing anchors during Metanorma rendering.
+        #
+        # @param concept [Glossarist::ManagedConcept]
+        # @return [String]
+        def render_concept_refs(concept)
+          FORMATTERS.keys.filter_map do |kind|
+            refs = concept_refs(concept, kind)
+            next if refs.empty?
+
+            blocks = refs.filter_map { |ref| render_ref(kind, ref) }
+            next if blocks.empty?
+
+            "#{blocks.join("\n\n")}\n"
+          end.join("\n")
+        end
+
+        private
+
+        def render_ref(kind, ref)
+          collection = @collections[kind]
+          return nil unless collection
+
+          entity = collection.by_id(ref.entity_id)
+          return nil unless entity
+
+          format_one(kind, entity)
+        end
+
+        def format_one(kind, entity)
+          FORMATTERS.fetch(kind).new(entity, lang: @lang).to_asciidoc
+        end
+
+        def concept_refs(concept, kind)
+          refs = concept.data&.public_send(kind)
+          Array(refs)
+        end
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ module Metanorma
         # @param register [Glossarist::DatasetRegister, nil] for cascading
         # @param renderer [TemplateRenderer] concept renderer
         # @param depth [Integer] base heading depth for sections
-        # @param options [Hash] :sort_by, :anchor_prefix
+        # @param options [Hash] :sort_by, :anchor_prefix, :non_verbal
         def initialize(dataset:, register:, renderer:, depth:, **options)
           @dataset = dataset
           @register = register
@@ -26,6 +26,7 @@ module Metanorma
           @depth = depth
           @sort_by = options[:sort_by] || DEFAULT_SORT_BY
           @anchor_prefix = options[:anchor_prefix]
+          @non_verbal = options[:non_verbal]
         end
 
         # @param sections [Array<Glossarist::Section>]
@@ -55,7 +56,8 @@ module Metanorma
           heading = "#{'=' * (@depth + 1)} #{section.name || section.id}"
           body = @renderer.render_concepts(concepts,
                                            depth: @depth + 1,
-                                           anchor_prefix: @anchor_prefix)
+                                           anchor_prefix: @anchor_prefix,
+                                           non_verbal: @non_verbal)
           "#{heading}\n\n#{body}"
         end
       end

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

@@ -12,13 +12,17 @@ module Metanorma
           @template_cache = {}
         end
 
-        def render_concepts(concepts, depth:, anchor_prefix: nil)
+        def render_concepts(concepts, depth:, anchor_prefix: nil,
+                            non_verbal: nil)
           tree = build_concept_tree(concepts)
-          parts = tree.map { |c| render_tree_node(c, depth, anchor_prefix) }
+          parts = tree.map do |node|
+            render_tree_node(node, depth, anchor_prefix, non_verbal)
+          end
           normalize_whitespace(parts.join("\n\n"))
         end
 
-        def render_concept(concept, depth:, anchor_prefix: nil)
+        def render_concept(concept, depth:, anchor_prefix: nil,
+                           non_verbal: nil)
           l10n = concept.localization(@lang)
           context = {
             "concept" => concept.to_liquid,
@@ -28,6 +32,9 @@ module Metanorma
           }
           template_content = cached_template(concept)
           rendered = render_template(template_content, context)
+          if non_verbal
+            rendered += "\n\n#{non_verbal.render_concept_refs(concept)}"
+          end
           normalize_whitespace(rendered)
         end
 
@@ -41,12 +48,14 @@ module Metanorma
           end
         end
 
-        def render_tree_node((concept, children), depth, anchor_prefix)
+        def render_tree_node((concept, children), depth, anchor_prefix,
+                             non_verbal)
           result = render_concept(concept, depth: depth,
-                                           anchor_prefix: anchor_prefix)
+                                           anchor_prefix: anchor_prefix,
+                                           non_verbal: non_verbal)
           children.each do |child_node|
             result += "\n" + render_tree_node(child_node, depth + 1,
-                                              anchor_prefix)
+                                              anchor_prefix, non_verbal)
           end
           result
         end

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

@@ -3,7 +3,7 @@
 module Metanorma
   module Plugin
     module Glossarist
-      VERSION = "0.3.9"
+      VERSION = "0.3.10"
     end
   end
 end

data/lib/metanorma-plugin-glossarist.rb

@@ -21,6 +21,10 @@ module Metanorma
       autoload :Document, "metanorma/plugin/glossarist/document"
       autoload :Liquid, "metanorma/plugin/glossarist/liquid"
       autoload :LiquidRendering, "metanorma/plugin/glossarist/liquid_rendering"
+      autoload :NonVerbalFormatters,
+               "metanorma/plugin/glossarist/non_verbal_formatters"
+      autoload :NonVerbalRenderer,
+               "metanorma/plugin/glossarist/non_verbal_renderer"
       autoload :Sanitize, "metanorma/plugin/glossarist/sanitize"
       autoload :SectionCascade, "metanorma/plugin/glossarist/section_cascade"
       autoload :SectionFilter, "metanorma/plugin/glossarist/section_filter"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-plugin-glossarist
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.3.10
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-18 00:00:00.000000000 Z
+date: 2026-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -111,6 +111,12 @@ files:
 - 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/non_verbal_formatters.rb
+- lib/metanorma/plugin/glossarist/non_verbal_formatters/base.rb
+- lib/metanorma/plugin/glossarist/non_verbal_formatters/figure.rb
+- lib/metanorma/plugin/glossarist/non_verbal_formatters/formula.rb
+- lib/metanorma/plugin/glossarist/non_verbal_formatters/table.rb
+- lib/metanorma/plugin/glossarist/non_verbal_renderer.rb
 - lib/metanorma/plugin/glossarist/sanitize.rb
 - lib/metanorma/plugin/glossarist/section_cascade.rb
 - lib/metanorma/plugin/glossarist/section_filter.rb