asciidoctor-html 0.1.2 → 0.1.4

data/exe/adoctohtml

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "asciidoctor/html"
+
+Asciidoctor::Html::CLI.run

data/lib/asciidoctor/html/bi_inline_macro.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "asciidoctor"
+require "pathname"
+
+module Asciidoctor
+  module Html
+    # Insert an icon from https://icons.getbootstrap.com/
+    class BiInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+
+      named :bi
+      name_positional_attributes "size", "color"
+
+      def process(parent, target, attrs)
+        s_attr = c_attr = nil
+        s_attr = "font-size:#{attrs["size"]};" if attrs.include?("size")
+        c_attr = "color:#{attrs["color"]};" if attrs.include?("color")
+        attr_str = s_attr || c_attr ? %( style="#{s_attr}#{c_attr}") : ""
+        icon = %(<i class="bi bi-#{target}"#{attr_str}></i>)
+        create_inline_pass parent, icon
+      end
+    end
+  end
+end

data/lib/asciidoctor/html/book.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "erb"
+require "date"
+require "asciidoctor"
+require_relative "converter"
+require_relative "ref_tree_processor"
+require_relative "cref_inline_macro"
+require_relative "bi_inline_macro"
+require_relative "template"
+
+module Asciidoctor
+  module Html
+    # A book is a collection of documents with cross referencing
+    # supported via the cref macro.
+    class Book
+      attr_reader :title, :author, :date, :chapname,
+                  :refs, :templates
+
+      Asciidoctor::Extensions.register do
+        tree_processor RefTreeProcessor
+        inline_macro CrefInlineMacro
+        inline_macro BiInlineMacro
+      end
+
+      DOCATTRS = {
+        "sectids" => false,
+        "stem" => "latexmath",
+        "hide-uri-scheme" => true,
+        "source-highlighter" => "highlight.js",
+        "imagesdir" => IMG_PATH
+      }.freeze
+
+      DEFAULT_OPTS = {
+        title: "Untitled Book",
+        author: "Anonymous Author",
+        chapname: "Chapter"
+      }.freeze
+
+      # Template data to be processed by each document
+      TData = Struct.new("TData", :chapnum, :chaptitle)
+
+      # opts:
+      # - title
+      # - short_title
+      # - author
+      # - date
+      # - se_id
+      # - chapname
+      def initialize(opts = {})
+        opts = DEFAULT_OPTS.merge opts
+        @title = ERB::Escape.html_escape opts[:title]
+        @short_title = ERB::Escape.html_escape opts[:short_title]
+        @author = ERB::Escape.html_escape opts[:author]
+        @date = opts.include?(:date) ? Date.parse(opts[:date]) : Date.today
+        @se_id = opts[:se_id]
+        @chapname = opts[:chapname]
+        @refs = {} # Hash(docname => Hash(id => reftext))
+        @templates = {} # Hash(docname => TData)
+      end
+
+      # params:
+      # - chapters: array of filenames
+      # - appendices: array of filenames
+      # returns: Hash(file_basename_without_ext => html)
+      def read(chapters = [], appendices = [])
+        docs = {} # Hash(docname => document)
+        chapters.each_with_index do |filename, idx|
+          doc = chapter filename, idx
+          register! docs, filename, doc
+        end
+        appendices.each_with_index do |filename, idx|
+          doc = appendix filename, idx, appendices.size
+          register! docs, filename, doc
+        end
+        html docs
+      end
+
+      # params:
+      # - chapters: array of filenames
+      # - appendices: array of filenames
+      # - outdir: directory to write the converted html files to
+      def write(chapters, appendices, outdir)
+        read(chapters, appendices).each do |name, html|
+          File.write("#{outdir}/#{name}.html", html)
+        end
+        File.write("#{outdir}/#{SEARCH_PAGE}", search_page(@se_id)) if @se_id
+      end
+
+      private
+
+      def search_page(se_id)
+        content = <<~HTML
+          <script async src="https://cse.google.com/cse.js?cx=#{se_id}"></script>
+          <div class="gcse-search"></div>
+        HTML
+        Template.html(
+          content,
+          nav_items,
+          title: @title,
+          short_title: @short_title,
+          author: @author,
+          date: @date,
+          chapnum: "",
+          chaptitle: "Search",
+          langs: []
+        )
+      end
+
+      def register!(docs, filename, doc)
+        key = key filename
+        docs[key] = doc
+      end
+
+      def langs(doc)
+        doc.attr?("source-langs") ? doc.attr("source-langs").keys : []
+      end
+
+      def doctitle(doc)
+        doc.doctitle sanitize: true, use_fallback: true
+      end
+
+      def chapter(filename, idx)
+        numeral = idx.to_s
+        doc = parse_file filename, @chapname, numeral
+        chaptitle = doctitle doc
+        chapref = idx.zero? ? chaptitle : chapref_default(@chapname, numeral)
+        chapnum = idx.zero? ? "" : numeral
+        process_doc key(filename), doc, chapnum:, chaptitle:, chapref:
+      end
+
+      def appendix(filename, idx, num_appendices)
+        chapname = "Appendix"
+        numeral = ("a".."z").to_a[idx].upcase
+        doc = parse_file filename, chapname, numeral
+        chapref = num_appendices == 1 ? chapname : chapref_default(chapname, numeral)
+        chapnum = ""
+        chaptitle = Template.appendix_title chapname, numeral, doctitle(doc), num_appendices
+        process_doc key(filename), doc, chapnum:, chaptitle:, chapref:
+      end
+
+      def key(filename)
+        Pathname(filename).basename.sub_ext("").to_s
+      end
+
+      # opts:
+      # - chapnum
+      # - chaptitle
+      # - chapref
+      def process_doc(key, doc, opts)
+        val = doc.catalog[:refs].transform_values(&method(:reftext)).compact
+        val["chapref"] = opts[:chapref]
+        @refs[key] = val
+        @templates[key] = TData.new(
+          chapnum: opts[:chapnum],
+          chaptitle: opts[:chaptitle]
+        )
+        doc
+      end
+
+      def parse_file(filename, chapname, numeral)
+        attributes = { "chapnum" => numeral, "chapname" => chapname }.merge DOCATTRS
+        Asciidoctor.load_file filename, safe: :unsafe, attributes:
+      end
+
+      def chapref_default(chapname, numeral)
+        "#{ERB::Escape.html_escape chapname} #{numeral}"
+      end
+
+      def reftext(node)
+        node.reftext || (node.title unless node.inline?) || "[#{node.id}]" if node.id
+      end
+
+      def outline(doc)
+        items = []
+        doc.sections.each do |section|
+          next unless section.id && section.level == 1
+
+          items << Template.nav_item("##{section.id}", section.title)
+        end
+        items.size > 1 ? "<ul>#{items.join "\n"}</ul>" : ""
+      end
+
+      def html(docs)
+        html = {} # Hash(docname => html)
+        docs.each do |key, doc|
+          html[key] = build_template key, doc
+        end
+        html
+      end
+
+      def nav_items(active_key = -1, doc = nil)
+        items = @templates.map do |k, td|
+          active = (k == active_key)
+          subnav = active && doc ? outline(doc) : ""
+          navtext = Template.nav_text td.chapnum, td.chaptitle
+          Template.nav_item "#{k}.html", navtext, subnav, active:
+        end
+        return items unless @se_id
+
+        items.unshift(Template.nav_item(
+                        SEARCH_PAGE,
+                        %(<i class="bi bi-search"></i> Search),
+                        active: (active_key == -1)
+                      ))
+      end
+
+      def build_template(key, doc)
+        tdata = @templates[key]
+        nav_items = nav_items key, doc
+        content = ERB.new(doc.convert).result(binding)
+        Template.html(
+          content,
+          nav_items,
+          title: @title,
+          short_title: @short_title,
+          author: @author,
+          date: @date,
+          chapnum: tdata.chapnum,
+          chaptitle: tdata.chaptitle,
+          langs: langs(doc),
+          nav: (nav_items.size > 1)
+        )
+      end
+    end
+  end
+end

data/lib/asciidoctor/html/cli.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "filewatcher"
+require "optparse"
+require "pathname"
+require "psych"
+require_relative "book"
+require_relative "webmanifest"
+
+module Asciidoctor
+  module Html
+    # The command line interface
+    module CLI
+      DEFAULT_OPTIONS = {
+        "config-file": "config.yml",
+        watch: false
+      }.freeze
+
+      DEFAULT_DIRS = {
+        "srcdir" => ".",
+        "outdir" => "www"
+      }.freeze
+
+      def self.parse_opts
+        options = DEFAULT_OPTIONS.dup
+        OptionParser.new do |parser|
+          parser.on("-w", "--watch",
+                    "Watch for file changes in SRCDIR. Default: unset")
+          parser.on("-c", "--config-file CONFIG",
+                    "Location of config file. Default: #{options[:"config-file"]}")
+        end.parse!(into: options)
+        options
+      end
+
+      def self.read_config(config_file)
+        begin
+          config = Psych.safe_load_file config_file
+        rescue StandardError
+          puts "Error opening configuration file #{config_file}"
+          exit 1
+        end
+        config_dir = Pathname(config_file).dirname
+        %w[outdir srcdir].each do |prop|
+          config[prop] = File.expand_path(config[prop] || DEFAULT_DIRS[prop], config_dir)
+        end
+        %w[chapters appendices].each do |prop|
+          config[prop] ||= []
+          config[prop] = config[prop].map do |f|
+            File.expand_path(f, config_dir)
+          end
+        end
+        config
+      end
+
+      def self.setup_outdir(outdir)
+        assets_dir = "#{outdir}/#{ASSETS_PATH}"
+        FileUtils.mkdir_p assets_dir unless File.directory?(assets_dir)
+        rootdir = File.absolute_path "#{__dir__}/../../.."
+        %W[#{CSS_PATH} #{FAVICON_PATH}].each do |p|
+          dir = "#{outdir}/#{p}"
+          next if Dir.exist?(dir)
+
+          puts "Generating #{dir}"
+          FileUtils.cp_r "#{rootdir}/#{p}", assets_dir
+        end
+      end
+
+      def self.generate_webmanifest(outdir, name, short_name)
+        filename = "#{outdir}/#{FAVICON_PATH}/site.webmanifest"
+        puts "Generating #{filename}"
+        File.write filename, Webmanifest.generate(name, short_name)
+      end
+
+      def self.generate_bookopts(config)
+        book_opts = {}
+        %i[title short_title author date se_id chapname].each do |opt|
+          key = opt.to_s
+          book_opts[opt] = config[key] if config.include?(key)
+        end
+        book_opts[:short_title] ||= book_opts[:title]
+        book_opts
+      end
+
+      def self.run(opts = nil)
+        opts ||= parse_opts
+        config = read_config opts[:"config-file"]
+        outdir = config["outdir"]
+        book_opts = generate_bookopts config
+        setup_outdir outdir
+        generate_webmanifest outdir, book_opts[:title], book_opts[:short_title]
+        book = Book.new book_opts
+        puts "Writing book to #{outdir}"
+        book.write config["chapters"], config["appendices"], config["outdir"]
+        return unless opts[:watch]
+
+        Filewatcher.new("#{config["srcdir"]}/*.adoc").watch do |changes|
+          chapters = []
+          appendices = []
+          changes.each_key do |filename|
+            puts "Detected change in #{filename}"
+            chapters.append(filename) if config["chapters"].include?(filename)
+            appendices.append(filename) if config["appendices"].include?(filename)
+          end
+          puts "Regenerating book:"
+          puts "    Chapters: #{chapters.map { |c| Pathname(c).basename }.join ", "}" unless chapters.empty?
+          puts "    Appendices: #{appendices.map { |a| Pathname(a).basename }.join ", "}" unless appendices.empty?
+          book.write chapters, appendices, config["outdir"]
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/html/converter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "asciidoctor"
-require_relative "olist"
+require_relative "list"
 require_relative "utils"
 require_relative "figure"
 
@@ -13,59 +13,200 @@ module Asciidoctor
 
       include Figure
 
+      def convert_embedded(node)
+        result = [node.content]
+        if node.footnotes?
+          result << %(<div class="footnotes">)
+          node.footnotes.each do |fn|
+            result << %(<div class="footnote" id="_footnotedef_#{fn.index}">#{fn.text}</div>)
+          end
+          result << %(</div>)
+        end
+        result.join("\n")
+      end
+
+      def convert_preamble(node)
+        %(<div class="preamble">\n#{node.content}</div> <!-- .preamble -->\n)
+      end
+
       def convert_section(node)
         document = node.document
         level = node.level
         show_sectnum = node.numbered && level <= (document.attr("sectnumlevels") || 1).to_i
         tag_name = %(h#{[level + 2, 6].min})
         sectnum = show_sectnum ? %(<span class="title-mark">#{node.sectnum ""}</span>) : ""
-        content = %(<#{tag_name}>#{sectnum}#{node.title}) +
-                  %(</#{tag_name}>\n#{node.content})
+        content = %(<#{tag_name}>#{sectnum}#{node.title}</#{tag_name}>\n#{node.content})
         Utils.wrap_node content, node, :section
       end
 
       def convert_paragraph(node)
-        content = %(<p>#{node.content}</p>\n)
+        content = %(<p#{Utils.dyn_id_class_attr_str node, node.role}>#{node.content}</p>\n)
         Utils.wrap_node_with_title content, node
       end
 
+      def convert_quote(node)
+        attribution = node.attr?("attribution") ? node.attr("attribution") : nil
+        citetitle = node.attr?("citetitle") ? node.attr("citetitle") : nil
+        classes = ["blockquote", node.role].compact.join(" ")
+        cite_element = citetitle ? %(<cite>#{citetitle}</cite>) : ""
+        attr_element = attribution ? %(<span class="attribution">#{attribution}</span>) : ""
+        content = %(<blockquote#{Utils.dyn_id_class_attr_str node, classes}>\n#{node.content}\n</blockquote>)
+        if attribution || citetitle
+          caption = %(<figcaption class="blockquote-footer">\n#{attr_element}#{cite_element}\n</figcaption>)
+          content = %(<figure>\n#{content}\n#{caption}\n</figure>\n)
+        end
+        Utils.wrap_node_with_title content, node
+      end
+
+      def convert_admonition(node)
+        name = node.attr "name"
+        icon_class = case name
+                     when "note" then "info-lg"
+                     when "tip" then "lightbulb"
+                     else "exclamation-lg"
+                     end
+        icon = %(<div class="icon"><i class="bi bi-#{icon_class}"></i></div>)
+        content = %(#{icon}\n#{Utils.display_title node, needs_prefix: false}#{node.content})
+        Utils.wrap_id_classes content, node.id, "admonition admonition-#{name}"
+      end
+
+      def convert_sidebar(node)
+        classes = ["aside", node.role].compact.join(" ")
+        title = node.title? ? %(<h5 class="aside-title">#{node.title}</h5>\n) : ""
+        content = "#{title}#{node.content}"
+        %(<aside#{Utils.id_class_attr_str node.id, classes}>\n#{content}\n</aside>\n)
+      end
+
+      def convert_stem(node)
+        open, close = BLOCK_MATH_DELIMITERS[node.style.to_sym]
+        equation = node.content || ""
+        equation = "#{open}#{equation}#{close}" unless (equation.start_with? open) && (equation.end_with? close)
+        classes = ["stem"]
+        if node.option? "numbered"
+          equation = %(<div class="equation">\n#{equation}\n</div> <!-- .equation -->)
+          equation = %(#{equation}\n<div class="equation-number">#{node.reftext}</div>)
+          classes << "stem-equation"
+        end
+        content = %(<div#{Utils.dyn_id_class_attr_str node, classes.join(" ")}>\n#{equation}\n</div>\n)
+        Utils.wrap_id_classes_with_title content, node, node.id, "stem-wrapper"
+      end
+
+      def convert_inline_callout(node)
+        i = node.text.to_i
+        case i
+        when 1..20
+          (i + 9311).chr(Encoding::UTF_8)
+        when 21..50
+          (i + 3230).chr(Encoding::UTF_8)
+        else
+          "[#{node.text}]"
+        end
+      end
+
+      def convert_inline_footnote(node)
+        if (index = node.attr "index")
+          icon = %(<i class="bi bi-question-circle-fill"></i>)
+          %(<sup>#{Utils.popover_button icon, "_footnotedef_#{index}", "fnref"}</sup>)
+        else
+          %(<sup class="text-danger">[??]</sup>)
+        end
+      end
+
+      def convert_listing(node)
+        nowrap = (node.option? "nowrap") || !(node.document.attr? "prewrap")
+        if node.style == "source"
+          lang = node.attr "language"
+          code_open = %(<code#{%( class="language-#{lang}") if lang}>)
+          pre_open = %(<pre#{%( class="nowrap") if nowrap}>#{code_open})
+          pre_close = "</code></pre>"
+        else
+          pre_open = %(<pre#{%( class="nowrap") if nowrap}>)
+          pre_close = "</pre>"
+        end
+        needs_prefix = node.option? "numbered"
+        title = Utils.display_title(node, needs_prefix:)
+        content = title + pre_open + node.content + pre_close
+        Utils.wrap_node content, node
+      end
+
+      def convert_open(node)
+        collapsible = node.option? "collapsible"
+        title = if collapsible
+                  %(<summary>#{node.title || "Details"}</summary>\n)
+                else
+                  Utils.display_title(node, needs_prefix: false)
+                end
+        tag_name = collapsible ? :details : :div
+        Utils.wrap_node(title + node.content, node, tag_name)
+      end
+
       def convert_example(node)
-        p node.context unless Utils.show_title?(node)
         Utils.wrap_node_with_title node.content, node, needs_prefix: true
       end
 
       def convert_image(node)
-        return super if node.option?("inline") || node.option?("interactive")
-
         content = display_figure node
         Utils.wrap_id_classes content, node.id, ["figbox", node.role].compact.join(" ")
       end
 
       def convert_inline_image(node)
-        return super if node.option?("inline") || node.option?("interactive")
-
         target = node.target
-        mark = node.parent.attr("mark")
-        attrs = image_attrs node
-        image = display_image node, target, attrs
-        title = node.attr?("title") ? node.attr("title") : ""
-        caption = mark ? %(<span class="li-mark">#{mark}</span>#{title}) : title
-        %(    #{image}\n    <figcaption>#{caption}</figcaption>)
+        mark = node.parent.attr "mark"
+        title_attr = node.attr? "title"
+        if mark # The image is part of a figlist
+          title = title_attr ? node.attr("title") : ""
+          %(    #{display_image node, target}
+          <figcaption><span class="li-mark">#{mark}</span>#{title}</figcaption>).gsub(/^      /, "")
+        else
+          display_image node, target, title_attr:
+        end
       end
 
       def convert_olist(node)
         return convert_figlist(node) if node.style == "figlist"
 
-        depth = node.attr "list-depth"
-        flat = node.attr? "flat-style"
-        level = depth + 1
-        classes = ["olist level-#{level}", flat ? "pseudocode" : node.style, node.role].compact.join(" ")
-        result = [%(<ol#{Utils.dyn_id_class_attr_str node, classes}>)]
-        node.items.each do |item|
-          result << Olist.display_list_item(item)
+        List.convert node
+      end
+
+      def convert_colist(node)
+        node.style = "arabic-circled"
+        List.convert node
+      end
+
+      def convert_ulist(node)
+        List.convert node, :ul
+      end
+
+      def convert_dlist(node)
+        classes = ["dlist", node.style, node.role].compact.join(" ")
+        result = [%(<dl#{Utils.dyn_id_class_attr_str node, classes}>)]
+        node.items.each do |terms, dd|
+          terms.each do |dt|
+            result << %(<dt>#{dt.text}</dt>)
+          end
+          next unless dd
+
+          result << "<dd>"
+          result << %(<p>#{dd.text}</p>) if dd.text?
+          result << dd.content if dd.blocks?
+          result << "</dd>"
+        end
+        result << "</dl>\n"
+        Utils.wrap_id_classes_with_title result.join("\n"), node, node.id, "dlist-wrapper"
+      end
+
+      def convert_inline_anchor(node)
+        if node.type == :xref && !node.text
+          target = node.document.catalog[:refs][node.attr("refid")]
+          if target&.inline?
+            text = target.text
+            return %(<a href="#{node.target}">#{text}</a>) if text&.match?(/\A<i class="bi/)
+
+            list_style = target.parent&.parent&.style
+            return Utils.popover_button(target.reftext, target.id, "bibref") if list_style == "bibliography"
+          end
         end
-        result << %(</ol> <!-- .level-#{level} -->\n)
-        Utils.wrap_id_classes_with_title result.join("\n"), node, node.id, "list-wrapper"
+        super
       end
     end
   end

data/lib/asciidoctor/html/cref_inline_macro.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "asciidoctor"
+require "pathname"
+
+module Asciidoctor
+  module Html
+    # Allow cross references between documents by creating a suitable
+    # ERB inline ruby string:
+    #
+    # cref:example.adoc#element-id[]
+    # => <a href="example.html#element-id"><%= refs.dig("example", "element-id") %></a>
+    #
+    # cref:example.adoc[]
+    # => <a href="example.html"><%= refs.dig("example", "chapref") %></a>
+    #
+    # cref:example.adoc[here]
+    # => <a href="example.html">here</a>
+    class CrefInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+
+      named :cref
+      name_positional_attributes "text"
+
+      def process(parent, target, attrs)
+        path_tag = target.split "#"
+        path = path_tag.first
+        tag = path_tag.size > 1 ? path_tag[1] : "chapref"
+        doc_key = Pathname(path).sub_ext ""
+        text = attrs["text"] || %(<%= refs.dig("#{doc_key}", "#{tag}") || "[#{doc_key}][#{tag}]" %>)
+        hash_tag = path_tag.size > 1 ? "##{path_tag[1]}" : ""
+        href = "#{Pathname(path).sub_ext ".html"}#{hash_tag}"
+        create_anchor parent, text, type: :link, target: href
+      end
+    end
+  end
+end