metanorma-document 0.2.0 → 0.2.1

data/lib/metanorma/html/drops/admonition_drop.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Drops
+      class AdmonitionDrop < BlockElementDrop
+        def self.from_model(admonition, renderer:)
+          type = renderer.safe_attr(admonition, :type) || "note"
+          id = renderer.safe_attr(admonition, :id)
+
+          content_html = renderer.capture_output do
+            admonition.paragraphs&.each { |para| renderer.render_paragraph(para) }
+          end
+
+          new(
+            id: id,
+            type: type,
+            label_html: renderer.escape_html(type.capitalize),
+            content_html: content_html,
+            css_class: "admonition #{type}",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/drops/block_element_drop.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Drops
+      class BlockElementDrop < Liquid::Drop
+        attr_reader :id, :type, :label_html, :content_html, :css_class
+
+        def initialize(attrs = {})
+          attrs.each { |k, v| instance_variable_set(:"@#{k}", v) }
+        end
+
+        # Subclasses override to build from model + RendererContext
+        def self.from_model(_model, renderer:)
+          raise NotImplementedError, "#{name} must implement .from_model"
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/drops/example_drop.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Drops
+      class ExampleDrop < BlockElementDrop
+        def self.from_model(example, renderer:)
+          id = renderer.safe_attr(example, :id)
+          label = renderer.extract_block_label(example, "EXAMPLE")
+
+          content_html = renderer.capture_output do
+            if example.paragraphs && !example.paragraphs.empty?
+              example.paragraphs.each { |para| renderer.render_paragraph(para) }
+            end
+            example.ul&.each { |ul| renderer.render_unordered_list(ul) }
+            example.ol&.each { |ol| renderer.render_ordered_list(ol) }
+            example.dl&.each { |dl| renderer.render_definition_list(dl) }
+            example.sourcecode&.each { |sc| renderer.render_sourcecode(sc) }
+            example.table&.each { |t| renderer.render_table(t) }
+            example.figure&.each { |f| renderer.render_figure(f) }
+            example.quote&.each { |q| renderer.render_quote(q) }
+            example.formula&.each { |f| renderer.render_formula(f) }
+          end
+
+          new(
+            id: id,
+            label_html: renderer.escape_html(label),
+            content_html: content_html,
+            css_class: "example",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/drops/figure_drop.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Drops
+      class FigureDrop < BlockElementDrop
+        attr_reader :image_html, :caption_html, :key_html, :sub_figures_html
+
+        def self.from_model(figure, renderer:)
+          id = renderer.safe_attr(figure, :id)
+          fig_name = renderer.safe_attr(figure, :fmt_name) || renderer.safe_attr(figure, :name)
+          if id && fig_name
+            renderer.register_figure_entry(id: id, text: renderer.extract_plain_text(fig_name))
+          end
+
+          image_html = renderer.capture_output do
+            if figure.image
+              renderer.render_image(figure.image)
+            elsif renderer.safe_attr(figure, :source)
+              src = renderer.safe_attr(figure, :source)
+              @output << %(<img src="#{renderer.escape_html(src)}" />)
+            end
+          end
+
+          caption_html = if fig_name || renderer.safe_attr(figure, :name)
+                           renderer.capture_output do
+                             el = renderer.safe_attr(figure, :fmt_name) || figure.name
+                             renderer.render_inline_element(el)
+                           end
+                         end
+
+          sub_figures_html = renderer.capture_output do
+            figure.figure&.each { |sub| renderer.render_figure(sub) }
+          end
+
+          key_html = renderer.capture_output do
+            renderer.safe_attr(figure, :note)&.each { |n| renderer.render_note(n) }
+            renderer.safe_attr(figure, :dl)&.then { |dl| renderer.render_definition_list(dl) }
+          end
+
+          new(
+            id: id,
+            image_html: image_html,
+            caption_html: caption_html,
+            key_html: key_html,
+            sub_figures_html: sub_figures_html,
+            css_class: "figure",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/drops/formula_drop.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Drops
+      class FormulaDrop < BlockElementDrop
+        attr_reader :stem_html, :where_html, :number_html
+
+        def self.from_model(formula, renderer:)
+          id = renderer.safe_attr(formula, :id)
+
+          stem_html = renderer.capture_output do
+            renderer.render_stem_content(formula.stem) if formula.stem
+          end
+
+          where_html = renderer.capture_output do
+            if formula.key
+              if formula.key.dl
+                @output = renderer.capture_output {}
+                # "where" label rendered in template, just render the dl
+                renderer.render_definition_list(formula.key.dl)
+              end
+              formula.key.p&.each { |para| renderer.render_paragraph(para) }
+            end
+            formula.dl&.then { |dl| renderer.render_definition_list(dl) }
+          end
+
+          name_el = renderer.safe_attr(formula, :fmt_name) || renderer.safe_attr(formula, :name)
+          number_html = if name_el
+                          renderer.capture_output { renderer.render_inline_element(name_el) }
+                        end
+
+          new(
+            id: id,
+            stem_html: stem_html,
+            where_html: where_html,
+            number_html: number_html,
+            css_class: "formula",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/drops/note_drop.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Drops
+      class NoteDrop < BlockElementDrop
+        def self.from_model(note, renderer:)
+          id = renderer.safe_attr(note, :id)
+          label = renderer.extract_block_label(note, "NOTE")
+
+          content_html = renderer.capture_output do
+            if note.content && !note.content.empty?
+              note.content.each { |para| renderer.render_paragraph(para) }
+            else
+              renderer.render_mixed_inline(note)
+            end
+            note.ul&.each { |ul| renderer.render_unordered_list(ul) }
+            note.ol&.each { |ol| renderer.render_ordered_list(ol) }
+            note.dl&.then { |dl| renderer.render_definition_list(dl) }
+          end
+
+          new(
+            id: id,
+            label_html: renderer.escape_html(label),
+            content_html: content_html,
+            css_class: "note-block",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/drops/sourcecode_drop.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Drops
+      class SourcecodeDrop < BlockElementDrop
+        attr_reader :lang, :name_html, :code_html
+
+        def self.from_model(sc, renderer:)
+          id = renderer.safe_attr(sc, :id)
+          lang = renderer.safe_attr(sc, :lang)
+
+          name_html = if sc.name
+                        renderer.capture_output { renderer.render_inline_element(sc.name) }
+                      end
+
+          code_text = if sc.body&.content
+                        sc.body.content
+                      elsif sc.content
+                        sc.content
+                      else
+                        ""
+                      end
+          raw_text = code_text.gsub("&lt;", "<").gsub("&gt;", ">").gsub("&amp;", "&").gsub("&quot;", "\"")
+
+          new(
+            id: id,
+            lang: lang,
+            name_html: name_html,
+            code_html: renderer.escape_html(raw_text),
+            css_class: "sourcecode",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/drops.rb

@@ -4,6 +4,13 @@ module Metanorma
   module Html
     module Drops
       autoload :FootnoteDrop, "metanorma/html/drops/footnote_drop"
+      autoload :BlockElementDrop, "metanorma/html/drops/block_element_drop"
+      autoload :NoteDrop, "metanorma/html/drops/note_drop"
+      autoload :AdmonitionDrop, "metanorma/html/drops/admonition_drop"
+      autoload :ExampleDrop, "metanorma/html/drops/example_drop"
+      autoload :SourcecodeDrop, "metanorma/html/drops/sourcecode_drop"
+      autoload :FormulaDrop, "metanorma/html/drops/formula_drop"
+      autoload :FigureDrop, "metanorma/html/drops/figure_drop"
     end
   end
 end