datalog-theme 0.8.0 → 0.9.0

data/_plugins/math_preprocessor.rb

@@ -26,6 +26,16 @@ module MathPreprocessor
       regex: /(?<![\\$])(?<open>\$)(?![\s$])(?<body>(?:[^$\\\n]|\\.|\n(?![ \t]*\n))+?)(?<![\s\\])(?<close>\$)(?![$\d])/m,
       tag: "span"
     },
+    # MathJax and KaTeX also render math with spaces inside the dollars, such
+    # as `$ \frac{a}{b} $`, which the rule above leaves out, so a page whose
+    # only math was written that way loaded no engine. Such a pair counts when
+    # its body holds a TeX command, a superscript or a subscript, which prices
+    # like `$ 5 or $ 10` do not.
+    {
+      regex: /(?<![\\$])(?<open>\$)(?!\$)(?<body>(?:[^$\\\n]|\\.|\n(?![ \t]*\n))+?)(?<!\\)(?<close>\$)(?![$\d])/m,
+      tag: "span",
+      requires: /\\[a-zA-Z]+|[\^_]/
+    },
     {
       regex: /(?<open>\\\()(?<body>.+?)(?<close>\\\))/m,
       tag: "span"
@@ -57,22 +67,24 @@ module MathPreprocessor
     def process
       return @content unless @content&.match?(/\$|\\\(|\\\[|\\begin\{/)
 
-      code = []
+      @segments = []
       processed = CODE_PATTERNS.reduce(@content.dup) do |text, pattern|
-        text.gsub(pattern) do |match|
-          code << match
-          "\x00#{code.size - 1}\x00"
-        end
+        text.gsub(pattern) { |match| mask(match) }
       end
       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.
-      processed = processed.gsub(PLACEHOLDER) { code[Regexp.last_match(1).to_i] } while processed.match?(PLACEHOLDER)
+      processed = processed.gsub(PLACEHOLDER) { @segments[Regexp.last_match(1).to_i] } while processed.match?(PLACEHOLDER)
       processed
     end
 
     private
 
+    def mask(segment)
+      @segments << segment
+      "\x00#{@segments.size - 1}\x00"
+    end
+
     def apply_patterns(text, patterns, display: false)
       patterns.reduce(text) do |result, pattern|
         result.gsub(pattern[:regex]) do |match|
@@ -81,8 +93,11 @@ module MathPreprocessor
           close = Regexp.last_match[:close]
 
           next match if body.nil? || body.strip.empty?
+          next match if pattern[:requires] && !pattern[:requires].match?(body)
 
-          wrapper_for(match, body, open, close, pattern[:tag], display: display)
+          # Each wrapper is set aside like code. Otherwise a later pattern could
+          # pair a dollar sign inside it with one in the text that follows.
+          mask(wrapper_for(match, body, open, close, pattern[:tag], display: display))
         end
       end
     end
@@ -195,9 +210,9 @@ module MathPreprocessor
   def apply(document)
     return unless document.respond_to?(:content)
     return unless document.respond_to?(:output_ext) && document.output_ext == ".html"
-    # A page that opts out of math rendering (`math: false` or `mathjax: false`)
-    # keeps its dollar signs and TeX-looking text verbatim.
-    return if document.respond_to?(:data) && (document.data["math"] == false || document.data["mathjax"] == false)
+    # A page that opts out of math rendering keeps its dollar signs and
+    # TeX-looking text verbatim.
+    return if document.respond_to?(:data) && math_setting(document.data) == false
 
     content = document.content
     return unless content&.match?(/\$|\\\(|\\\[|\\begin\{/)
@@ -207,6 +222,13 @@ module MathPreprocessor
     document.content = updated_content
     document.data["math_expressions"] = processor.expressions if processor.expressions.any?
   end
+
+  # `math`, or its alias `mathjax` when `math` is unset, as
+  # _includes/meta/math-config.html reads them. A `mathjax: true` in front
+  # matter defaults used to win over a page's `math: false`.
+  def math_setting(data)
+    data["math"].nil? ? data["mathjax"] : data["math"]
+  end
 end
 
 # Posts are documents, so registering them separately ran the preprocessor

data/_plugins/references.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Datalog
+  # Numbered figures and tables, and references to them, within a page:
+  #
+  #   {% figure id="fig-power" src="/assets/img/power.png" alt="Power curve" %}
+  #   Power as a function of effect size $\delta$.
+  #   {% endfigure %}
+  #
+  #   {% table id="tab-runs" %}
+  #   Simulation runs by sample size.
+  #
+  #   | n | runs |
+  #   |---|------|
+  #   {% endtable %}
+  #
+  #   As {% ref fig-power %} shows, ...
+  #
+  # The tags write placeholders. Once the page's Markdown is converted, every
+  # target gets its number in the order it appears, so a reference may come
+  # before its figure, and each reference becomes a link reading "Figure 2".
+  # A duplicate id or a reference to nothing stops the build. Equations are
+  # numbered and referenced by MathJax (\label and \eqref) instead.
+  #
+  # A caption is the body of the tag, not an attribute, so math in it goes
+  # through the math preprocessor like the rest of the page.
+  #
+  # Theorems, definitions and the other statements in _plugins/statements.rb
+  # are numbered and referred to the same way.
+  module References
+    module_function
+
+    # Each kind counts separately; the label comes from _data/i18n.
+    KINDS = {
+      "figure" => "Figure", "table" => "Table",
+      "theorem" => "Theorem", "lemma" => "Lemma", "proposition" => "Proposition", "corollary" => "Corollary",
+      "definition" => "Definition", "assumption" => "Assumption", "example" => "Example", "remark" => "Remark"
+    }.freeze
+    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="([^"]+)")?/
+    # 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>}
+    SOURCE_TAG = /\{%-?\s*(#{KINDS.keys.join('|')})\b([^%]*)-?%\}/
+
+    def number(document)
+      content = document.content
+      return unless content&.include?("data-ref")
+
+      targets = targets(content.scan(TARGET), document)
+      content = content.gsub(LABEL) do
+        id, ending = Regexp.last_match.captures
+        text = "#{CGI.escapeHTML(targets.fetch(id))}#{ending || '.'}"
+        %(<span class="datalog-ref-label" data-ref-for="#{id}">#{text}</span>)
+      end
+      document.content = link_references(content, targets, document)
+    end
+
+    # Jekyll runs no hooks for an excerpt, and renders it when a template first
+    # asks for it, which on a listing page can be before its post is converted.
+    # Its references take their numbers from the post: from the converted
+    # content when there is one, and otherwise from the tags in the source,
+    # which are in the same order. A missing target is the post's error to report.
+    def number_excerpt(excerpt, html)
+      return html unless html&.include?("data-ref")
+
+      post = excerpt.doc
+      found = post.content.to_s.scan(TARGET)
+      found = source_targets(post.content.to_s) if found.empty?
+      targets = targets(found.uniq(&:first), post)
+      html.gsub(LINK) do
+        id = Regexp.last_match(1)
+        text = targets[id] ? CGI.escapeHTML(targets[id]) : id
+        %(<a class="datalog-ref" href="#{post.site.baseurl}#{post.url}##{id}" data-ref="#{id}">#{text}</a>)
+      end
+    end
+
+    # [id, kind, label] for each numbered tag in a page's source.
+    def source_targets(source)
+      source.scan(SOURCE_TAG).filter_map do |kind, markup|
+        attributes = markup.scan(/(\w+)=["']([^"']*)["']/).to_h
+        [attributes["id"], kind, attributes["label"]] if attributes["id"]
+      end
+    end
+
+    # The id => "Figure 2" of every [id, kind, label] target, numbered per kind in
+    # page order. A target with its own label does not take a number.
+    def targets(found, document)
+      counts = Hash.new(0)
+      found.each_with_object({}) do |(id, kind, custom), targets|
+        if targets.key?(id)
+          raise Jekyll::Errors::FatalException,
+                "#{document.relative_path} has two numbered figures, tables or statements with the id " \
+                "\"#{id}\"; each id has to be unique"
+        end
+
+        number = custom ? CGI.unescapeHTML(custom) : (counts[kind] += 1)
+        targets[id] = "#{label(document, kind)} #{number}"
+      end
+    end
+
+    def link_references(content, targets, document)
+      missing = content.scan(LINK).flatten.uniq - targets.keys
+      unless missing.empty?
+        raise Jekyll::Errors::FatalException,
+              "#{document.relative_path} refers to #{missing.map { |id| "\"#{id}\"" }.join(', ')}, which no " \
+              "numbered figure, table or statement on the page has as its id"
+      end
+
+      content.gsub(LINK) do
+        id = Regexp.last_match(1)
+        %(<a class="datalog-ref" href="##{id}" data-ref="#{id}">#{CGI.escapeHTML(targets[id])}</a>)
+      end
+    end
+
+    def label(document, kind)
+      site = document.site
+      locale = I18n.locale_code(site, document.data["lang"])
+      I18n.lookup(site, locale, "references.#{kind}") || KINDS.fetch(kind)
+    end
+
+    def validate_label(label, tag)
+      return if label.nil? || label.match?(CUSTOM_LABEL)
+
+      raise Liquid::ArgumentError,
+            "{% #{tag} %} takes a label of letters, digits, \".\", \"'\", \"*\" or \"-\", such as label=\"A\"; " \
+            "got #{label.inspect}"
+    end
+
+    def validate_id(id, tag)
+      return id if id.to_s.match?(ID)
+
+      raise Liquid::ArgumentError,
+            "{% #{tag} %} needs an id that starts with a letter and holds only letters, digits, " \
+            "\"-\", \"_\", \".\" or \":\", such as id=\"fig-power\"; got #{id.inspect}"
+    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]
+      end
+    end
+
+    def markdown(context, text)
+      site = context.registers[:site]
+      site.find_converter_instance(Jekyll::Converters::Markdown).convert(text.to_s.strip)
+    end
+
+    # A caption of one paragraph loses its <p>, which a <figcaption> or <caption> does not need.
+    def inline(html)
+      html = html.strip
+      paragraph = html.match(%r{\A<p>(.*)</p>\z}m)
+      paragraph && !paragraph[1].include?("<p>") ? paragraph[1] : html
+    end
+  end
+
+  class FigureTag < Liquid::Block
+    def initialize(tag_name, markup, options)
+      super
+      @markup = markup
+    end
+
+    def render(context)
+      attributes = References.attributes(@markup, context)
+      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?
+      if attributes["alt"].to_s.strip.empty?
+        raise Liquid::ArgumentError, "{% figure id=\"#{id}\" %} needs alt text for its image"
+      end
+
+      src = "#{context.registers[:site].config['baseurl'].to_s.chomp('/')}#{src}" if src.start_with?("/")
+      caption = References.inline(References.markdown(context, super))
+      classes = ["datalog-figure", attributes["class"]].compact.join(" ")
+
+      alt = CGI.escapeHTML(attributes["alt"])
+      %(<figure class="#{CGI.escapeHTML(classes)}" id="#{id}" data-ref-target="#{id}" data-ref-kind="figure">) +
+        %(<img src="#{CGI.escapeHTML(src)}" alt="#{alt}" loading="lazy" decoding="async">) +
+        %(<figcaption><span class="datalog-ref-label" data-ref-for="#{id}"></span> #{caption}</figcaption></figure>\n)
+    end
+  end
+
+  class TableTag < Liquid::Block
+    def initialize(tag_name, markup, options)
+      super
+      @markup = markup
+    end
+
+    # The body holds the caption and then a Markdown table.
+    def render(context)
+      id = References.validate_id(References.attributes(@markup, context)["id"], "table")
+      html = References.markdown(context, super)
+      tables = html.scan(/<table\b/).size
+      unless tables == 1
+        raise Liquid::ArgumentError, "{% table id=\"#{id}\" %} holds #{tables} tables; it needs one, after its caption"
+      end
+
+      caption, table = html.split(/(?=<table\b)/, 2)
+      caption = References.inline(caption)
+      numbered = table.sub(/<table\b([^>]*)>/) do
+        %(<table#{Regexp.last_match(1)} id="#{id}" data-ref-target="#{id}" data-ref-kind="table">) +
+          %(<caption><span class="datalog-ref-label" data-ref-for="#{id}"></span> #{caption}</caption>)
+      end
+      "#{numbered.strip}\n"
+    end
+  end
+
+  class ReferenceTag < Liquid::Tag
+    def initialize(tag_name, markup, options)
+      super
+      @id = References.validate_id(markup.strip, "ref")
+    end
+
+    def render(_context)
+      %(<a class="datalog-ref" href="##{@id}" data-ref="#{@id}">#{@id}</a>)
+    end
+  end
+end
+
+Liquid::Template.register_tag("figure", Datalog::FigureTag)
+Liquid::Template.register_tag("table", Datalog::TableTag)
+Liquid::Template.register_tag("ref", Datalog::ReferenceTag)
+
+Jekyll::Hooks.register %i[pages documents], :post_convert do |document|
+  Datalog::References.number(document)
+end
+
+Jekyll::Excerpt.prepend(Module.new do
+  # Excerpt#output renders once and keeps the result; numbering it is a quick gsub.
+  def output
+    Datalog::References.number_excerpt(self, super)
+  end
+end)

data/_plugins/reproducibility.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Datalog
+  # The computational artifacts behind an article, for the "Reproduce this
+  # analysis" panel (_includes/components/reproducibility.html):
+  #
+  #   reproducibility:
+  #     code:
+  #       url: https://github.com/example/project
+  #       ref: 4f2c1ab                   # the commit, tag or branch the article used
+  #     data:
+  #       doi: 10.5281/zenodo.1234567    # or url:
+  #       version: v2
+  #     environment:
+  #       file: requirements.txt         # in the code repository at the ref, a site path or a URL
+  #       container: ghcr.io/example/project:1.4.0
+  #       archive: https://doi.org/10.5281/zenodo.7654321
+  #     notebook:
+  #       url: /notebooks/example/
+  #     results:
+  #       url: https://github.com/example/project/releases/tag/results-v1
+  #       version: results-v1
+  #
+  # Every artifact is optional, and each may be a bare URL. The panel shows
+  # what is given and claims nothing more: a link is a link, a ref is a ref.
+  # A URL that is not http(s), a site path or a DOI stops the build.
+  module Reproducibility
+    module_function
+
+    KINDS = %w[code data notebook environment results].freeze
+    # Where a ref and a file in the repository can be linked.
+    HOSTS = {
+      "github.com" => { tree: "/tree/%s", blob: "/blob/%s/%s" },
+      "gitlab.com" => { tree: "/-/tree/%s", blob: "/-/blob/%s/%s" }
+    }.freeze
+    URL = %r{\Ahttps?://[^\s"'<>]+\z}i
+    PATH = %r{\A/[^\s"'<>]*\z}
+
+    # The artifacts, in KINDS order, or nil when the page gives none.
+    def resolve(page, site)
+      value = Authors.value(page, "reproducibility")
+      return unless value.is_a?(Hash)
+
+      given = value.transform_keys(&:to_s)
+      baseurl = Authors.value(site, "baseurl").to_s
+      artifacts = KINDS.filter_map { |kind| artifact(kind, given[kind], given, page, baseurl) }
+      { "artifacts" => artifacts } unless artifacts.empty?
+    end
+
+    def artifact(kind, value, all, page, baseurl)
+      return if value.nil? || value == false || (value.is_a?(String) && value.strip.empty?)
+
+      given = value.is_a?(Hash) ? Authors.present(value) : { "url" => value.to_s }
+      url = link(given["url"] || doi_url(given["doi"]), page, "#{kind}.url", baseurl)
+      artifact = { "kind" => kind, "url" => url, "external" => external?(url), "version" => given["version"]&.to_s,
+                   "label" => given["label"] || display(url), "doi" => bare_doi(given["doi"]) }
+      artifact.merge!(code(given, url)) if kind == "code"
+      artifact.merge!(environment(given, all, page, baseurl)) if kind == "environment"
+      artifact = artifact.compact
+      artifact if artifact.values_at("url", "file", "container", "archive").any?
+    end
+
+    def code(given, url)
+      ref = given["ref"].to_s.strip
+      return {} if ref.empty?
+
+      { "ref" => ref, "ref_url" => host_url(url, :tree, ref) }
+    end
+
+    # The environment file lives in the code repository at the article's ref
+    # unless it is a site path or a URL of its own.
+    def environment(given, all, page, baseurl)
+      file = given["file"].to_s.strip
+      archive = link(given["archive"], page, "environment.archive", baseurl)
+      {
+        "file" => (file unless file.empty?),
+        "file_url" => (file_url(file, all["code"], page, baseurl) unless file.empty?),
+        "container" => given["container"]&.to_s,
+        "archive" => archive, "archive_label" => display(archive)
+      }
+    end
+
+    def file_url(file, code, page, baseurl)
+      own = file.match?(URL) || file.match?(PATH) || file.match?(/\Adoi:/i)
+      return link(file, page, "environment.file", baseurl) if own
+
+      code = code.is_a?(Hash) ? Authors.present(code) : { "url" => code.to_s }
+      code_url = link(code["url"], page, "code.url", baseurl)
+      ref = code["ref"].to_s.strip
+      host_url(code_url, :blob, ref.empty? ? "HEAD" : ref, file)
+    end
+
+    # A page of a known host under the repository URL, such as a tree or a blob.
+    def host_url(url, kind, *parts)
+      return unless url
+
+      host = URI.parse(url).host.to_s.sub(/\Awww\./, "")
+      pattern = HOSTS.dig(host, kind)
+      "#{url.chomp('/')}#{format(pattern, *parts)}" if pattern
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    # An http(s) URL as given, a site path with the baseurl, or a DOI as its
+    # URL; anything else, such as a javascript: URL or an address without its
+    # scheme, stops the build.
+    def link(value, page, field, baseurl)
+      text = value.to_s.strip
+      return if text.empty?
+      return doi_url(text) if text.match?(/\Adoi:/i)
+      return text if text.match?(URL)
+      return "#{baseurl}#{text}" if text.match?(PATH)
+
+      raise Jekyll::Errors::FatalException,
+            "#{Authors.value(page, 'path')} reproducibility.#{field} is #{text.inspect}, which is not an http(s) " \
+            "URL, a site path starting with / or a doi:; give the whole address, such as https://github.com/example/project"
+    end
+
+    def bare_doi(doi)
+      text = doi.to_s.strip.sub(%r{\Ahttps?://(dx\.)?doi\.org/}i, "").sub(/\Adoi:\s*/i, "")
+      text unless text.empty?
+    end
+
+    def doi_url(doi)
+      bare = bare_doi(doi)
+      "https://doi.org/#{bare}" if bare
+    end
+
+    # What a link reads: the address without its scheme, or the site path.
+    def display(url)
+      return url unless external?(url)
+
+      url.sub(%r{\Ahttps?://(www\.)?}i, "").chomp("/")
+    end
+
+    def external?(url)
+      url.to_s.match?(URL)
+    end
+  end
+
+  module ReproducibilityFilters
+    def page_reproducibility(page)
+      Reproducibility.resolve(page, @context["site"])
+    end
+  end
+end
+
+Liquid::Template.register_filter(Datalog::ReproducibilityFilters)

data/_plugins/revisions.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+
+module Datalog
+  # The revision history of an article, for a post that is corrected or
+  # rewritten while keeping its URL:
+  #
+  #   revisions:
+  #     - date: 2026-09-16
+  #       type: correction
+  #       summary: Replaced the sample-size rules with model diagnostics.
+  #       details_url: https://github.com/example/repo/pull/425
+  #     - date: 2024-03-12
+  #       type: update
+  #       summary: Updated the code examples for the current SciPy.
+  #
+  # Before the site renders, each page's list is checked, its dates are
+  # parsed and its entries sorted newest first, so the includes read one
+  # shape. A correction or an update is substantive: the newest one becomes
+  # `revision_notice`, which the post layout announces under the metadata.
+  # A review or an editorial change appears in the history only.
+  #
+  # Every revision but a review changed the article, so the newest one sets
+  # `last_modified_at` when it is later than the date the page gives, and
+  # the JSON-LD, the microdata, the feed and the sitemap all carry it.
+  module Revisions
+    module_function
+
+    TYPES = %w[correction update review editorial].freeze
+    SUBSTANTIVE = %w[correction update].freeze
+    DEFAULT_TYPE = "update"
+
+    def normalize!(document)
+      data = document.data
+      return unless data.key?("revisions")
+
+      revisions = entries(data["revisions"], document)
+      data["revisions"] = revisions
+      notice = revisions.find { |revision| revision["substantive"] }
+      data["revision_notice"] = notice unless data["revision_notice"] == false
+
+      changed = revisions.find { |revision| revision["type"] != "review" }
+      modified = to_time(data["last_modified_at"] || data["updated"])
+      data["last_modified_at"] = changed["date"] if changed && (modified.nil? || changed["date"] > modified)
+    end
+
+    # Newest first; revisions on one day keep their order.
+    def entries(list, document)
+      unless list.is_a?(Array)
+        stop(document, "has revisions that is not a list; each revision is a map with a date, a summary and, " \
+                       "if wanted, a type and a details_url")
+      end
+
+      revisions = list.each_with_index.map { |entry, index| revision(entry, index + 1, document) }
+      revisions.each_with_index.sort_by { |revision, index| [-revision["date"].to_i, index] }.map(&:first)
+    end
+
+    def revision(entry, number, document)
+      stop(document, "revision #{number} is not a map with a date and a summary") unless entry.is_a?(Hash)
+
+      entry = entry.transform_keys(&:to_s)
+      type = (entry["type"] || DEFAULT_TYPE).to_s.strip.downcase
+      unless TYPES.include?(type)
+        stop(document, "revision #{number} has the type #{entry['type'].inspect}; it takes #{TYPES.join(', ')}")
+      end
+      summary = entry["summary"].to_s.strip
+      stop(document, "revision #{number} needs a summary saying what changed") if summary.empty?
+      date = to_time(entry["date"])
+      unless date
+        stop(document, "revision #{number} has the date #{entry['date'].inspect}, which is not a date such as " \
+                       "2026-09-16")
+      end
+
+      details = entry["details_url"].to_s.strip
+      { "date" => date, "type" => type, "summary" => summary, "details_url" => (details unless details.empty?),
+        "substantive" => SUBSTANTIVE.include?(type) }.compact
+    end
+
+    def stop(document, problem)
+      raise Jekyll::Errors::FatalException, "#{document.relative_path} #{problem}"
+    end
+
+    # A Date, a Time or a string naming a day, such as "2026-09-16".
+    def to_time(value)
+      case value
+      when Time then value
+      when Date then value.to_time
+      when String
+        parts = Date._parse(value)
+        Time.parse(value) if parts[:year] && parts[:mon] && parts[:mday]
+      end
+    end
+  end
+end
+
+Jekyll::Hooks.register :site, :post_read do |site|
+  site.documents.each { |document| Datalog::Revisions.normalize!(document) }
+  site.pages.each { |page| Datalog::Revisions.normalize!(page) }
+end

data/_plugins/scholarly.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Datalog
+  # Which pages get scholarly discovery metadata (_includes/meta/scholarly.html):
+  # the Highwire meta tags Google Scholar and reference managers read, and
+  # their Dublin Core equivalents. Not every post is a paper, so the tags are
+  # opt-in:
+  #
+  #   scholarly: true        # front matter: this page is a research article
+  #   scholarly: false       # front matter: this one is not, whatever the site says
+  #
+  #   scholarly: true        # _config.yml: every post and research article
+  #   scholarly: [notebooks] # _config.yml: these collections or layouts as well
+  #
+  # A page with the research layout, or in a research collection, is
+  # scholarly unless it says otherwise.
+  module Scholarly
+    module_function
+
+    ALWAYS = %w[research].freeze
+    POSTS = %w[posts post].freeze
+
+    def scholarly?(page, site)
+      own = Authors.value(page, "scholarly")
+      return own == true unless own.nil?
+
+      kinds = kinds(Authors.value(site, "scholarly"))
+      [Authors.value(page, "layout"), Authors.value(page, "collection")].any? { |kind| kinds.include?(kind.to_s) }
+    end
+
+    # The layouts and collections the site's setting covers, besides research.
+    def kinds(setting)
+      case setting
+      when true then ALWAYS + POSTS
+      when Array then ALWAYS + setting.map(&:to_s)
+      when String then ALWAYS + setting.split(/[\s,]+/)
+      else ALWAYS
+      end
+    end
+  end
+
+  module ScholarlyFilters
+    # A Liquid filter's name cannot end with "?".
+    def scholarly(page) # rubocop:disable Naming/PredicateMethod
+      Scholarly.scholarly?(page, @context["site"])
+    end
+  end
+end
+
+Liquid::Template.register_filter(Datalog::ScholarlyFilters)