datalog-theme 0.9.0 → 0.9.2

data/_layouts/research.html

@@ -38,7 +38,7 @@ schema_type: ScholarlyArticle
 {% assign show_publications = page.show_publications | default: false %}
 
 <div class="research-wrapper" itemscope itemtype="https://schema.org/ScholarlyArticle">
-  <meta itemprop="headline" content="{{ page.title }}" />
+  <meta itemprop="headline" content="{{ page.title | escape }}" />
   {% if page.date %}
     <meta itemprop="datePublished" content="{{ page.date | date_to_xmlschema }}" />
   {% endif %}
@@ -56,7 +56,7 @@ schema_type: ScholarlyArticle
   {% endif %}
 
   <header class="research-header" aria-labelledby="research-title">
-    <h1 id="research-title" class="research-title">{{ page.title }}</h1>
+    <h1 id="research-title" class="research-title">{{ page.title | escape }}</h1>
 
     <div class="research-authors" aria-label="Authors">
       <h2 class="visually-hidden">Authors</h2>
@@ -207,67 +207,7 @@ schema_type: ScholarlyArticle
     </section>
   {% endif %}
 
-  <section class="research-citation" aria-labelledby="citation-exports-heading">
-    <h2 id="citation-exports-heading">Citation exports</h2>
-    {% capture bibtex_authors %}
-      {% for author in authors %}
-        {% assign author_name = author.name | default: author %}
-        {{ author_name | strip }}{% unless forloop.last %} and {% endunless %}
-      {% endfor %}
-    {% endcapture %}
-    {% capture bibtex_entry %}
-@article{ {{ citation_key }},
-  title = { {{ page.title | strip }} },
-  author = { {{ bibtex_authors | strip }} },
-  {% if publication_name %}journal = { {{ publication_name | strip }} },{% endif %}
-  {% if page.date %}year = { {{ page.date | date: '%Y' }} },{% endif %}
-  {% if doi %}doi = { {{ doi }} },{% endif %}
-  {% if page.publisher %}publisher = { {{ page.publisher }} },{% endif %}
-  {% if page.volume %}volume = { {{ page.volume }} },{% endif %}
-  {% if page.number %}number = { {{ page.number }} },{% endif %}
-  {% if page.pages %}pages = { {{ page.pages }} },{% endif %}
-}
-    {% endcapture %}
-    {% capture ris_entry %}
-TY  - JOUR
-TI  - {{ page.title | strip }}
-{% if publication_name %}JO  - {{ publication_name | strip }}
-{% endif %}
-{% if page.date %}PY  - {{ page.date | date: '%Y/%m/%d' }}
-{% endif %}
-{% for author in authors %}{% assign author_name = author.name | default: author %}AU  - {{ author_name | strip }}
-{% endfor %}
-{% if doi %}DO  - {{ doi }}
-{% endif %}
-ER  -
-    {% endcapture %}
-    {% capture endnote_entry %}
-%0 Journal Article
-%T {{ page.title | strip }}
-{% for author in authors %}{% assign author_name = author.name | default: author %}%A {{ author_name | strip }}
-{% endfor %}
-{% if publication_name %}%J {{ publication_name | strip }}
-{% endif %}
-{% if page.date %}%D {{ page.date | date: '%Y' }}
-{% endif %}
-{% if doi %}%R {{ doi }}
-{% endif %}
-    {% endcapture %}
-    <div class="citation-export-grid">
-      <article>
-        <h3>BibTeX</h3>
-        <textarea readonly aria-label="BibTeX citation">{{ bibtex_entry | strip }}</textarea>
-      </article>
-      <article>
-        <h3>RIS</h3>
-        <textarea readonly aria-label="RIS citation">{{ ris_entry | strip }}</textarea>
-      </article>
-      <article>
-        <h3>EndNote</h3>
-        <textarea readonly aria-label="EndNote citation">{{ endnote_entry | strip }}</textarea>
-      </article>
-    </div>
-  </section>
+  {% include components/citation-tools.html authors=authors journal=publication_name %}
 
   <section class="research-body" itemprop="articleBody">
     {% if methodology_content %}
@@ -347,7 +287,7 @@ ER  -
             <li>
               <article class="appendix-item">
                 {% if appendix.title %}
-                  <h3>{{ appendix.title }}</h3>
+                  <h3>{{ appendix.title | escape }}</h3>
                 {% endif %}
                 {% if appendix.content %}
                   {{ appendix.content | markdownify }}
@@ -393,7 +333,7 @@ ER  -
             {% for publication in group_items %}
             <li class="publication-list__item">
               <article>
-                <h4 class="publication-title">{{ publication.title }}</h4>
+                <h4 class="publication-title">{{ publication.title | escape }}</h4>
                 {% assign publication_authors = publication.authors | arrayify %}
                 {% if publication_authors and publication_authors.size > 0 %}
                 <p class="publication-authors">{{ publication_authors | join: ', ' }}</p>
@@ -416,7 +356,7 @@ ER  -
           {% for publication in publication_entries %}
           <li class="publication-list__item">
             <article>
-              <h4 class="publication-title">{{ publication.title }}</h4>
+              <h4 class="publication-title">{{ publication.title | escape }}</h4>
               {% assign publication_authors = publication.authors | arrayify %}
               {% if publication_authors and publication_authors.size > 0 %}
               <p class="publication-authors">{{ publication_authors | join: ', ' }}</p>
@@ -456,7 +396,7 @@ ER  -
             <li>
               <article class="version-entry">
                 <header>
-                  <strong>{{ version.version | default: version.title | default: version }}</strong>
+                  <strong>{{ version.version | default: version.title | default: version | escape }}</strong>
                   {% if version.date %}<span class="version-date">{{ version.date | localize_date: date_format }}</span>{% endif %}
                 </header>
                 {% if version.notes %}

data/_plugins/authors.rb

@@ -27,13 +27,13 @@ module Datalog
     def authors(page, site)
       entries = entries(value(page, "authors"))
       entries = entries(value(page, "author")) if entries.empty?
-      records = entries.filter_map { |entry| resolve(entry, site) }
+      records = entries.filter_map { |entry| resolve(entry, site, page) }
       records = [site_author(site)].compact if records.empty?
       apply_page_affiliation(records, page)
     end
 
     def contributors(page, site)
-      entries(value(page, "contributors")).filter_map { |entry| resolve(entry, site) }
+      entries(value(page, "contributors")).filter_map { |entry| resolve(entry, site, page) }
     end
 
     # A list, one entry, or names in a string separated by semicolons.
@@ -46,9 +46,15 @@ module Datalog
     end
 
     # A plain entry is a key or a name; a map's own fields win over the record's.
-    def resolve(entry, site)
+    def resolve(entry, site, page = {})
       own = entry.is_a?(Hash) ? present(entry) : {}
-      key = own["id"] || own["name"] || entry.to_s.strip
+      key = own["id"] || own["name"] || (entry if entry.is_a?(String) || entry.is_a?(Symbol))
+      unless (key.is_a?(String) || key.is_a?(Symbol)) && !key.to_s.strip.empty?
+        path = value(page, "path")
+        raise Jekyll::Errors::FatalException,
+              "#{path} author entry #{entry.inspect} needs a name, an author id, or a map with name or id"
+      end
+      key = key.to_s.strip
       record = known(key, site).merge(own)
       record["name"] ||= key
       return if record["name"].to_s.strip.empty?
@@ -63,6 +69,11 @@ module Datalog
       record = value(data, key.to_s)
       return present(record) if record.is_a?(Hash)
 
+      if data.is_a?(Hash)
+        record = data.values.find { |candidate| candidate.is_a?(Hash) && candidate["name"] == key }
+        return present(record) if record
+      end
+
       author = site_author_profile(site)
       author && author["name"] == key ? author : {}
     end
@@ -85,6 +96,13 @@ module Datalog
       record["image"] ||= record["avatar"] || record["photo"]
       record["orcid"] = "https://orcid.org/#{record['orcid']}" if record["orcid"].to_s.match?(ORCID_ID)
       record["site_author"] = record["name"] == site_author_profile(site)&.fetch("name")
+      PROFILE_URLS.each do |key, template|
+        next unless record[key]
+
+        prefix = template.delete_suffix("%s").delete_prefix("https://")
+        record[key] = record[key].to_s.strip.sub(%r{\Ahttps?://(?:www\.)?#{Regexp.escape(prefix)}}i, "")
+                                 .sub(/\A@/, "").chomp("/")
+      end
       record["same_as"] = profiles(record)
       record
     end

data/_plugins/citation_exports.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Datalog
+  module CitationExports
+    module_function
+
+    TYPES = {
+      "article" => ["article", "JOUR", "Journal Article"],
+      "journal" => ["article", "JOUR", "Journal Article"],
+      "blog" => %w[misc BLOG Blog],
+      "dataset" => %w[misc DATA Dataset],
+      "software" => ["misc", "COMP", "Computer Program"],
+      "book" => %w[book BOOK Book],
+      "inproceedings" => ["inproceedings", "CPAPER", "Conference Paper"],
+      "misc" => %w[misc GEN Generic]
+    }.freeze
+
+    def text(value)
+      value.to_s.gsub(/\s+/, " ").strip
+    end
+
+    def bibtex(value)
+      text(value).gsub(/[\\&%$#_{}~^]/) do |character|
+        { "\\" => '\\textbackslash{}', "~" => '\\textasciitilde{}', "^" => '\\textasciicircum{}' }
+          .fetch(character) { "\\#{character}" }
+      end
+    end
+
+    def render(record, authors, kind, key)
+      bib_type, ris_type, endnote_type = TYPES.fetch(kind.to_s.downcase, TYPES["misc"])
+      names = authors.map { |author| text(Authors.value(author, "name") || author) }
+      bib_names = authors.each_with_index.map do |author, index|
+        name = bibtex(names[index])
+        Authors.value(author, "type") == "Organization" ? "{#{name}}" : name
+      end
+      fields = { "title" => bibtex(record["title"]), "author" => bib_names.join(" and ") }
+      record.each { |field, value| fields[field] = bibtex(value) unless field == "title" || value.to_s.empty? }
+      body = fields.map { |field, value| "  #{field} = { #{value} }" }.join(",\n")
+      bib = "@#{bib_type}{ #{key},\n#{body}\n}"
+
+      { "bibtex" => bib, "ris" => ris(record, names, ris_type), "endnote" => endnote(record, names, endnote_type) }
+    end
+
+    def ris(record, names, type)
+      lines = ["TY  - #{type}", "TI  - #{text(record['title'])}"]
+      lines.concat(names.map { |name| "AU  - #{name}" })
+      { "year" => "PY", "publisher" => "PB", "journal" => "JO", "doi" => "DO", "url" => "UR",
+        "volume" => "VL", "number" => "IS" }.each do |field, tag|
+        lines << "#{tag}  - #{text(record[field])}" unless record[field].to_s.empty?
+      end
+      unless record["pages"].to_s.empty?
+        first, last = text(record["pages"]).split(/[-–—]+/, 2)
+        lines << "SP  - #{first}"
+        lines << "EP  - #{last}" if last
+      end
+      (lines << "ER  -").join("\n")
+    end
+
+    def endnote(record, names, type)
+      lines = ["%0 #{type}", "%T #{text(record['title'])}"]
+      lines.concat(names.map { |name| "%A #{name}" })
+      { "year" => "D", "publisher" => "I", "journal" => "J", "doi" => "R", "url" => "U",
+        "volume" => "V", "number" => "N", "pages" => "P" }.each do |field, tag|
+        lines << "%#{tag} #{text(record[field])}" unless record[field].to_s.empty?
+      end
+      lines.join("\n")
+    end
+  end
+
+  module CitationExportFilters
+    def citation_exports(page, options = {})
+      site = @context["site"]
+      get = ->(key) { Authors.value(options, key) || Authors.value(page, key) }
+      title = get.call("title") || Authors.value(site, "title")
+      authors = Authors.value(options, "authors") || Authors.authors(page, site)
+      authors = Authors.entries(authors)
+      publisher = get.call("publisher") || Authors.value(Authors.value(site, "publisher"), "name") ||
+                  Authors.value(site, "title")
+      key = slugify(get.call("citation_key") || Authors.value(page, "slug") || title)
+      kind = get.call("citation_type") || Authors.value(options, "type") || "article"
+      record = {
+        "title" => title, "year" => (date(get.call("date"), "%Y") if get.call("date")),
+        "publisher" => publisher, "journal" => get.call("journal") || get.call("publication"),
+        "doi" => get.call("doi"), "url" => absolute_url(get.call("url") || "/"),
+        "volume" => get.call("volume"), "number" => get.call("issue") || get.call("number"),
+        "pages" => get.call("pages")
+      }
+      CitationExports.render(record, authors, kind, key)
+    end
+  end
+end
+
+Liquid::Template.register_filter(Datalog::CitationExportFilters)

data/_plugins/image_optimizer.rb

@@ -8,6 +8,7 @@ require "nokogiri"
 require "open3"
 require "tmpdir"
 require "tempfile"
+require "uri"
 
 module Jekyll
   module ImageOptimizer
@@ -76,18 +77,19 @@ module Jekyll
           img["loading"] ||= "lazy"
         end
         img["decoding"] ||= "async"
-
         normalized_src = normalize_src(img["src"], site)
         picture_entry = manifest[normalized_src]
 
         if picture_entry
           offer_variants(img, picture_entry, image_config, baseurl)
-          img["width"] ||= picture_entry["width"].to_s if picture_entry["width"]
-          img["height"] ||= picture_entry["height"].to_s if picture_entry["height"]
+          if !img["width"] && !img["height"] && picture_entry["width"] && picture_entry["height"]
+            img["width"] = picture_entry["width"].to_s
+            img["height"] = picture_entry["height"].to_s
+          end
         else
-          next if img["width"] && img["height"]
+          next if img["width"] || img["height"]
 
-          source = image_source_path(site, img["src"])
+          source = image_source_path(site, normalized_src)
           next unless source && File.exist?(source)
 
           width, height = FastImage.size(source)
@@ -270,7 +272,7 @@ module Jekyll
       relative_path = static_file.relative_path.sub(%r{^/}, "")
       dir = File.dirname(relative_path)
       responsive_dir = dir == "." ? "responsive" : File.join(dir, "responsive")
-      base = File.basename(relative_path, File.extname(relative_path))
+      base = File.basename(relative_path)
       Jekyll::ResponsiveImageStaticFile.new(site, responsive_dir, "#{base}-#{target_width}w.#{extension_for(format)}",
                                             cached)
     end
@@ -420,13 +422,19 @@ module Jekyll
 
     def original_variant(src, width, height)
       {
-        "url" => src,
+        "url" => encode_image_path(src),
         "width" => width,
         "height" => height,
         "format" => normalize_format(File.extname(src))
       }
     end
 
+    # These are filesystem paths, not already escaped URLs. Encode them once
+    # when creating the manifest so both Markdown and the include use valid srcsets.
+    def encode_image_path(path)
+      path.split("/", -1).map { |part| URI.encode_www_form_component(part).gsub("+", "%20") }.join("/")
+    end
+
     # Variant URLs are site paths. A site served below a baseurl needs it in
     # front of them, as relative_url adds it in templates.
     def build_srcset(variants, baseurl = "")
@@ -440,16 +448,16 @@ module Jekyll
     end
 
     def normalize_src(src, site)
-      return src if src.nil? || src.empty?
-      return src if src.start_with?("http://", "https://", "data:")
+      # Relative image URLs belong to the page, not to the source root. Leave
+      # them alone rather than offer another image's dimensions or variants.
+      return unless src&.start_with?("/") && !src.start_with?("//")
 
       baseurl = site&.baseurl.to_s
-      normalized = src.dup
-      normalized = normalized.delete_prefix(baseurl) if baseurl && !baseurl.empty? && normalized.start_with?(baseurl)
-      site_url = site&.config&.fetch("url", "").to_s
-      normalized = normalized.delete_prefix(site_url) if !site_url.empty? && normalized.start_with?(site_url)
-      normalized = normalized.gsub(%r{^/+}, "")
-      "/#{normalized}"
+      normalized = URI::DEFAULT_PARSER.unescape(src.split(/[?#]/, 2).first)
+      if !baseurl.empty? && (normalized == baseurl || normalized.start_with?("#{baseurl.chomp('/')}/"))
+        normalized = normalized.delete_prefix(baseurl.chomp("/"))
+      end
+      normalized
     end
 
     def image_config(site)
@@ -475,7 +483,7 @@ class Jekyll::ResponsiveImageStaticFile < Jekyll::StaticFile
   def initialize(site, relative_dir, name, cached_path)
     @cached_path = cached_path
     super(site, site.source, "/#{relative_dir}", name)
-    @url = "/#{relative_dir}/#{name}"
+    @url = Jekyll::ImageOptimizer.encode_image_path("/#{relative_dir}/#{name}")
   end
 
   def path

data/_plugins/licenses.rb

@@ -76,16 +76,27 @@ module Datalog
     # The page's own value, else the site's; `false` declines the site's.
     def setting(page, page_key, site, site_key)
       value = Authors.value(page, page_key)
-      return value unless value.nil?
-      return if OWN_LICENSE.include?(Authors.value(page, "collection").to_s)
+      own_only = OWN_LICENSE.include?(Authors.value(page, "collection").to_s)
+      fallback = Authors.value(site, site_key) unless own_only
+      return fallback if value.nil? || value == true
 
-      Authors.value(site, site_key)
+      if value.is_a?(Hash) && !Authors.present(value).keys.intersect?(%w[id name url])
+        defaults = fallback.is_a?(Hash) ? Authors.present(fallback) : { "name" => fallback }
+        return defaults.merge(Authors.present(value))
+      end
+
+      value
     end
 
     def resolve(value, page, site)
       return if value.nil? || value == false || (value.is_a?(String) && value.strip.empty?)
+      unless value.is_a?(String) || value.is_a?(Hash)
+        raise Jekyll::Errors::FatalException, "#{Authors.value(page, 'path')} license must be a name, a map or false"
+      end
 
       given = value.is_a?(Hash) ? Authors.present(value) : { "name" => value.to_s.strip }
+      return unless given.keys.intersect?(%w[id name url])
+
       id = LOOKUP[key(given["id"] || given["name"])]
       name, url = KNOWN[id] if id
       # A name that is not itself an identifier is the label the page chose.
@@ -114,6 +125,7 @@ module Datalog
 
       text = value.to_s.strip
       return text.to_i if text.match?(/\A\d{4}\z/)
+      return text if text.match?(/\A\d{4}[-–]\d{4}\z/)
 
       Time.parse(text).year unless text.empty?
     rescue ArgumentError

data/_plugins/math_preprocessor.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "cgi"
+require "kramdown"
+require "kramdown-parser-gfm"
 
 module MathPreprocessor
   DISPLAY_PATTERNS = [
@@ -46,7 +48,7 @@ module MathPreprocessor
   # so fenced blocks, highlight tags, <pre>/<code> elements and inline code
   # spans are set aside before looking for math and put back afterwards.
   CODE_PATTERNS = [
-    /^([ \t]*)(`{3,}|~{3,})[^\n]*\n.*?(?:^\1\2[ \t]*$|\z)/m,
+    /^[ \t]*(?<fence>(?<marker>`|~)\k<marker>{2,})[^\n]*\n.*?(?:^[ \t]*\k<fence>\k<marker>*[ \t]*$|\z)/m,
     /\{%-?\s*highlight\b.*?\{%-?\s*endhighlight\s*-?%\}/m,
     %r{<(pre|code)\b[^>]*>.*?</\1>}mi,
     /(?<!`)(`+)(?!`)(?:(?!\n[ \t]*\n).)+?(?<!`)\1(?!`)/m
@@ -56,6 +58,31 @@ module MathPreprocessor
   # an escape: a raw NUL byte in the source stopped RuboCop from parsing the file.
   PLACEHOLDER = /\x00(\d+)\x00/
 
+  # Indentation alone does not identify code: list continuations and continued
+  # paragraphs can have the same indentation. Let the Markdown parser identify
+  # the code blocks, retaining their original source lines for masking.
+  class IndentedCodeParser < Kramdown::Parser::GFM
+    attr_reader :code_ranges
+
+    def initialize(source, options)
+      super
+      @code_ranges = []
+    end
+
+    def parse_codeblock
+      first = @src.current_line_number - 1
+      super.tap do |parsed|
+        @code_ranges << (first...(@src.current_line_number - 1)) if parsed
+      end
+    end
+
+    def self.ranges(source)
+      parser = new(source, {})
+      parser.parse
+      parser.code_ranges
+    end
+  end
+
   class Processor
     attr_reader :expressions
 
@@ -68,9 +95,10 @@ module MathPreprocessor
       return @content unless @content&.match?(/\$|\\\(|\\\[|\\begin\{/)
 
       @segments = []
-      processed = CODE_PATTERNS.reduce(@content.dup) do |text, pattern|
+      processed = CODE_PATTERNS.reduce(mask_indented_code(@content)) do |text, pattern|
         text.gsub(pattern) { |match| mask(match) }
       end
+      processed = normalize_inline_dollars(processed)
       processed = apply_patterns(processed, DISPLAY_PATTERNS, display: true)
       processed = apply_patterns(processed, INLINE_PATTERNS, display: false)
       # A segment set aside can contain the placeholder of an earlier one.
@@ -85,6 +113,37 @@ module MathPreprocessor
       "\x00#{@segments.size - 1}\x00"
     end
 
+    def mask_indented_code(text)
+      return text unless text.match?(/^(?: {4}|\t)/)
+
+      lines = text.lines
+      IndentedCodeParser.ranges(text).reverse_each do |range|
+        block = lines[range].join
+        # Keep the final line boundary visible to subsequent block patterns.
+        ending = block.end_with?("\n") ? "\n" : ""
+        lines[range] = [mask(block.delete_suffix(ending)) + ending]
+      end
+      lines.join
+    end
+
+    # Kramdown accepts $$...$$ inside prose as inline math. A div there is
+    # escaped by Markdown and leaks its attributes into the visible article.
+    # Normalize before wrapping; code is already masked and standalone or
+    # multiline display equations retain their original delimiters.
+    def normalize_inline_dollars(text)
+      text.gsub(DISPLAY_PATTERNS.first[:regex]) do |expression|
+        match = Regexp.last_match
+        body = match[:body]
+        next expression if body.include?("\n") || body.strip.empty?
+
+        before = match.pre_match.split("\n", -1).last.to_s
+        after = match.post_match.split("\n", 2).first.to_s
+        next expression unless before.match?(/\S/) || after.match?(/\S/)
+
+        "$#{body.strip}$"
+      end
+    end
+
     def apply_patterns(text, patterns, display: false)
       patterns.reduce(text) do |result, pattern|
         result.gsub(pattern[:regex]) do |match|
@@ -118,6 +177,9 @@ module MathPreprocessor
         "aria-label" => alt_text,
         "tabindex" => "0"
       }
+      # Kramdown must not interpret TeX's escaped delimiters or underscores as
+      # Markdown inside an inline HTML span.
+      attributes["markdown"] = "0" unless display
 
       attribute_string = attributes.map do |key, value|
         next if value.nil? || value.strip.empty?
@@ -125,7 +187,7 @@ module MathPreprocessor
         %(#{key}="#{CGI.escapeHTML(value)}")
       end.compact.join(" ")
 
-      inner = "#{open}#{latex}#{close}"
+      inner = CGI.escapeHTML("#{open}#{latex}#{close}")
       "<#{tag} #{attribute_string}>#{inner}</#{tag}>"
     end
 

data/_plugins/references.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "cgi"
+require "strscan"
 
 module Datalog
   # Numbered figures and tables, and references to them, within a page:
@@ -41,7 +42,8 @@ module Datalog
     ID = /\A[A-Za-z][\w.:-]*\z/
     # A label given in place of the number, as in "Theorem A".
     CUSTOM_LABEL = /\A[[:alnum:]][[:alnum:].'*-]*\z/
-    TARGET = /data-ref-target="([^"]+)" data-ref-kind="([a-z]+)"(?: data-ref-number="([^"]+)")?/
+    TARGET = /data-ref-target="([^"]+)"[ ]data-ref-kind="([a-z]+)"(?:[ ]data-ref-number="([^"]+)")?
+              ([ ]data-ref-numbered="true")?/x
     # A label ends with a full stop unless the tag chose another ending.
     LABEL = %r{<span class="datalog-ref-label" data-ref-for="([^"]+)"(?: data-ref-end="([^"]*)")?></span>}
     LINK = %r{<a class="datalog-ref" href="#([^"]+)" data-ref="\1">[^<]*</a>}
@@ -51,7 +53,12 @@ module Datalog
       content = document.content
       return unless content&.include?("data-ref")
 
-      targets = targets(content.scan(TARGET), document)
+      # Feeds and listings embed content that has already been numbered on its
+      # own page. Only process this document's remaining placeholders.
+      targets = targets(content.scan(TARGET).reject { |entry| entry[3] }, document)
+      content = content.gsub(TARGET) do |target|
+        Regexp.last_match(4) ? target : %(#{target} data-ref-numbered="true")
+      end
       content = content.gsub(LABEL) do
         id, ending = Regexp.last_match.captures
         text = "#{CGI.escapeHTML(targets.fetch(id))}#{ending || '.'}"
@@ -113,7 +120,8 @@ module Datalog
 
       content.gsub(LINK) do
         id = Regexp.last_match(1)
-        %(<a class="datalog-ref" href="##{id}" data-ref="#{id}">#{CGI.escapeHTML(targets[id])}</a>)
+        label = CGI.escapeHTML(targets[id])
+        %(<a class="datalog-ref" href="##{id}" data-ref="#{id}" data-ref-numbered="true">#{label}</a>)
       end
     end
 
@@ -140,10 +148,24 @@ module Datalog
     end
 
     # key="value", key='value' or key=variable.
-    def attributes(markup, context)
-      markup.scan(/(\w+)=(?:"([^"]*)"|'([^']*)'|([\w.\[\]-]+))/).to_h do |key, double, single, variable|
-        [key, double || single || context[variable].to_s]
+    def attributes(markup, context, tag = "reference")
+      scanner = StringScanner.new(markup)
+      result = {}
+      until scanner.eos?
+        scanner.skip(/\s+/)
+        break if scanner.eos?
+
+        unless scanner.scan(/(\w+)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'|([\w.\[\]-]+))(?=\s|\z)/m)
+          page = context.registers[:page] || {}
+          raise Liquid::ArgumentError,
+                "#{page['path'] || page['url']} {% #{tag} %} has invalid attributes near #{scanner.rest.inspect}"
+        end
+        # Ruby 3.2's StringScanner#captures returns "" for unmatched groups.
+        # values_at preserves nil so quoted literals stay distinct from variables.
+        key, double, single, variable = scanner.values_at(1, 2, 3, 4)
+        result[key] = variable ? context[variable].to_s : (double || single).gsub(/\\([\\"'])/, '\\1')
       end
+      result
     end
 
     def markdown(context, text)
@@ -166,7 +188,7 @@ module Datalog
     end
 
     def render(context)
-      attributes = References.attributes(@markup, context)
+      attributes = References.attributes(@markup, context, "figure")
       id = References.validate_id(attributes["id"], "figure")
       src = attributes["src"].to_s
       raise Liquid::ArgumentError, "{% figure id=\"#{id}\" %} needs a src, the image it shows" if src.empty?
@@ -193,7 +215,7 @@ module Datalog
 
     # The body holds the caption and then a Markdown table.
     def render(context)
-      id = References.validate_id(References.attributes(@markup, context)["id"], "table")
+      id = References.validate_id(References.attributes(@markup, context, "table")["id"], "table")
       html = References.markdown(context, super)
       tables = html.scan(/<table\b/).size
       unless tables == 1

data/_plugins/reproducibility.rb

@@ -96,9 +96,22 @@ module Datalog
     def host_url(url, kind, *parts)
       return unless url
 
-      host = URI.parse(url).host.to_s.sub(/\Awww\./, "")
+      uri = URI.parse(url)
+      host = uri.host.to_s.downcase.sub(/\Awww\./, "")
       pattern = HOSTS.dig(host, kind)
-      "#{url.chomp('/')}#{format(pattern, *parts)}" if pattern
+      return unless pattern
+
+      root = if host == "github.com"
+               uri.path.split("/").reject(&:empty?).first(2).join("/")
+             else
+               uri.path.sub(%r{/-/.*}, "").delete_prefix("/")
+             end
+      root = root.chomp("/").delete_suffix(".git")
+      # A ref is one route argument; a file retains its directory separators.
+      encoded = parts.each_with_index.map do |part, index|
+        index.zero? ? URI.encode_www_form_component(part).gsub("+", "%20") : encode_path(part)
+      end
+      "#{uri.scheme}://#{host}/#{root}#{format(pattern, *encoded)}"
     rescue URI::InvalidURIError
       nil
     end
@@ -125,7 +138,11 @@ module Datalog
 
     def doi_url(doi)
       bare = bare_doi(doi)
-      "https://doi.org/#{bare}" if bare
+      "https://doi.org/#{encode_path(bare)}" if bare
+    end
+
+    def encode_path(value)
+      value.to_s.split("/", -1).map { |part| URI.encode_www_form_component(part).gsub("+", "%20") }.join("/")
     end
 
     # What a link reads: the address without its scheme, or the site path.