datalog-theme 0.10.1 → 0.11.0

data/_plugins/config_validator.rb

@@ -73,7 +73,21 @@ module Datalog
         required: true,
         schema: {
           name: { type: :string, required: true },
-          email: { type: :string, format: :email }
+          email: { type: :string, format: :email },
+          # The `rel` of the author's profile links, `me noopener noreferrer` unless set.
+          profile_rel: { type: :string },
+          # What the JSON-LD Person says about them: one value or a list of them.
+          alternate_name: { type: %i[string array] }, alternate_names: { type: %i[array string] },
+          job_title: { type: %i[string array] }, roles: { type: %i[array string] },
+          knows_about: { type: %i[array string] }, same_as: { type: %i[array string] }
+        }
+      },
+      # The homepage's WebSite node (meta/schema.html): true, or a map naming the site.
+      site_identity: {
+        type: %i[boolean hash],
+        schema: {
+          enabled: { type: :boolean }, name: { type: :string },
+          alternate_names: { type: %i[array string] }, alternate_name: { type: :string }
         }
       },
       # Who publishes the site in structured data and citations. Without it, the author does.
@@ -145,6 +159,23 @@ module Datalog
       timezone: { type: :string },
       collections: { type: :hash },
       plugins: { type: :array },
+      # `datalog audit`: front matter keys a site's own templates read, internal
+      # links it builds outside Jekyll, and when an edit calls for a revision.
+      audit: {
+        type: :hash,
+        schema: {
+          known_keys: { type: :array }, ignore_links: { type: :array }, revision_after_days: { type: :integer }
+        }
+      },
+      # In-text citations (the datalog-citations plugin): the style, and the
+      # bibliography a page uses when it names none of its own.
+      citations: {
+        type: :hash,
+        schema: {
+          style: { type: :string, enum: %w[numeric author-year] },
+          bibliography: { type: %i[string array] }
+        }
+      },
       features: {
         type: :hash,
         schema: {
@@ -177,14 +208,34 @@ module Datalog
           style: { type: :string, enum: %w[compressed expanded] }
         }
       },
+      # `datalog critical-css` (lib/datalog/critical_css.rb).
+      critical_css: {
+        type: :hash,
+        schema: {
+          enabled: { type: :boolean },
+          engine: { type: :string, enum: %w[render static] },
+          dimensions: { type: :array },
+          pages: { type: :hash }
+        }
+      },
       theme_options: {
         type: :hash,
         schema: {
+          color_scheme: {
+            type: :hash,
+            schema: {
+              default: { type: :string, enum: %w[dark light system] }
+            }
+          },
           math: {
             type: :hash,
             schema: {
               engine: { type: :string, enum: %w[mathjax katex] },
-              enabled: { type: :boolean }
+              enabled: { type: :boolean },
+              # A display equation set plain on its line, or in a framed card.
+              display_style: { type: :string, enum: %w[plain card] },
+              # Which display equations MathJax numbers (its tex.tags).
+              numbering: { type: :string, enum: %w[ams all none] }
             }
           },
           # The "Reading mode" control on posts, and whether a reader's choice is kept.
@@ -205,6 +256,25 @@ module Datalog
               highlights: { type: :boolean },
               list_url: { type: :string }
             }
+          },
+          # Where a post's author and editorial note goes: after the article, or before it.
+          provenance: {
+            type: :hash,
+            schema: {
+              position: { type: :string, enum: %w[end start] }
+            }
+          },
+          # A share card drawn for each page without an image of its own (lib/datalog/social_cards.rb).
+          social_cards: {
+            type: :hash,
+            schema: {
+              enabled: { type: :boolean },
+              scheme: { type: :string, enum: %w[dark light] },
+              background: { type: :string },
+              logo: { type: %i[string boolean] },
+              template: { type: :string },
+              collections: { type: :array }
+            }
           }
         }
       }
@@ -224,6 +294,11 @@ module Datalog
       "theme_options.math.enabled" => {
         message: "Nothing reads it: theme_options.math.render_on_load decides which pages load the math engine, " \
                  "and a page's `math` front matter overrides that. Remove it."
+      },
+      # critical 9 dropped penthouse, and with it every option passed to it.
+      "critical_css.penthouse_options" => {
+        message: "`datalog critical-css` runs critical 9, which has no penthouse options, so these have no effect. " \
+                 "Remove them."
       }
     }.freeze
 

data/_plugins/correction_fallback.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Datalog
+  # A plain link is useful even on a static site, before JavaScript enriches
+  # the report with the section and selected passage.
+  module CorrectionFallback
+    module_function
+
+    MAX_BODY = 900
+    MAX_TITLE = 180
+    MAX_URL = 1800
+    HOSTS = %w[github.com gitlab.com].freeze
+    EMAIL = /\A[^\s@<>]+@[^\s@<>]+\.[^\s@<>]+\z/
+
+    def resolve(page, site, article_url, context)
+      settings = Authors.value(site, "corrections")
+      settings = {} unless settings.respond_to?(:[])
+      repository = repository_url(Authors.value(site, "repository"))
+      email = recipient(site)
+      mode = fallback_mode(settings, repository, email)
+      return unless (mode == "issue" && repository) || (mode == "email" && email)
+
+      title = Authors.value(page, "title").to_s.strip[0, MAX_TITLE]
+      subject = I18n.translate(context, "corrections.fallback.subject", "title" => title)
+      body_lines = [
+        "#{I18n.translate(context, 'corrections.fallback.article')}: #{title}",
+        "#{I18n.translate(context, 'corrections.fallback.url')}: #{article_url}"
+      ]
+      minimum = body_lines.join("\n").length
+      body = (body_lines + ["", I18n.translate(context, "corrections.fallback.prompt")]).join("\n")
+      body = body[0, [MAX_BODY, minimum].max]
+
+      if mode == "email"
+        { "kind" => mode, "body_param" => "body",
+          "href" => bounded_link("mailto:#{email}", { subject: subject, body: body }, :body, minimum) }
+      else
+        issue_link(repository, subject, body, minimum, settings)
+      end
+    end
+
+    def recipient(site)
+      email = Authors.value(site, "contact_email")
+      email = Authors.value(Authors.value(site, "author"), "email") if email.to_s.strip.empty?
+      email.to_s.strip if email.to_s.strip.match?(EMAIL)
+    end
+
+    def fallback_mode(settings, repository, email)
+      requested = Authors.value(settings, "fallback").to_s
+      return requested unless requested.empty?
+      return "issue" if repository
+      return "email" if email
+
+      "none"
+    end
+
+    def issue_link(repository, subject, body, minimum, settings)
+      github = URI.parse(repository).host == "github.com"
+      title_key, body_key = github ? %w[title body] : ["issue[title]", "issue[description]"]
+      params = { title_key => subject, body_key => body }
+      labels = Authors.value(settings, "issue_labels") || ["correction"]
+      labels = Array(labels).map(&:to_s).map(&:strip).reject(&:empty?)
+      params[github ? "labels" : "issue[label_names]"] = labels.join(",") unless labels.empty?
+      path = github ? "/issues/new" : "/-/issues/new"
+      { "kind" => "issue", "body_param" => body_key,
+        "href" => bounded_link("#{repository}#{path}", params, body_key, minimum) }
+    end
+
+    def bounded_link(destination, params, body_key, minimum)
+      address = "#{destination}?#{URI.encode_www_form(params)}"
+      while address.bytesize > MAX_URL && params[body_key].length > minimum
+        params[body_key] = params[body_key][0, [params[body_key].length - 20, minimum].max]
+        address = "#{destination}?#{URI.encode_www_form(params)}"
+      end
+      address
+    end
+
+    def repository_url(value)
+      uri = URI.parse(value.to_s.strip)
+      return unless valid_repository_uri?(uri)
+
+      parts = uri.path.to_s.sub(%r{/$}, "").split("/").reject(&:empty?)
+      return unless valid_repository_parts?(parts, uri.host)
+
+      "https://#{uri.host.downcase}/#{parts.join('/').sub(/\.git\z/, '')}"
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def valid_repository_uri?(uri)
+      uri.scheme == "https" && HOSTS.include?(uri.host&.downcase) && uri.port == 443 &&
+        !uri.userinfo && !uri.query && !uri.fragment
+    end
+
+    def valid_repository_parts?(parts, host)
+      return false unless parts.length >= 2 && (host.downcase == "gitlab.com" || parts.length == 2)
+
+      parts.all? { |part| part.match?(/\A[a-zA-Z0-9_.-]+\z/) && !%w[. ..].include?(part) }
+    end
+  end
+
+  module CorrectionFallbackFilters
+    def correction_fallback(page, article_url)
+      CorrectionFallback.resolve(page, @context["site"], article_url, @context)
+    end
+  end
+end
+
+Liquid::Template.register_filter(Datalog::CorrectionFallbackFilters)

data/_plugins/image_optimizer.rb

@@ -35,6 +35,12 @@ module Jekyll
     CODERS = { "jpeg" => "JPEG", "png" => "PNG", "webp" => "WEBP" }.freeze
     CACHE_DIR = "datalog-images"
 
+    # The file-name suffix that marks a dark twin, and the query the markup
+    # asks the browser. The site's script narrows this when a reader has used
+    # the theme toggle, whose choice the operating system does not know about.
+    DEFAULT_DARK_SUFFIX = "-dark"
+    DARK_MEDIA = "(prefers-color-scheme: dark)"
+
     # The one image a page fetches early: the first in its post or page content,
     # unless the author made it lazy or the page already preloads an image, as
     # the hero does. The first <img> anywhere used to be marked both lazy and
@@ -80,23 +86,18 @@ module Jekyll
         normalized_src = normalize_src(img["src"], site)
         picture_entry = manifest[normalized_src]
 
+        dark = dark_twin(img, picture_entry, manifest, site)
+        offer_variants(img, picture_entry, dark, image_config, baseurl) if picture_entry || dark
+
         if picture_entry
-          offer_variants(img, picture_entry, image_config, baseurl)
           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"]
-
-          source = image_source_path(site, normalized_src)
-          next unless source && File.exist?(source)
-
-          width, height = FastImage.size(source)
-          next unless width && height
-
-          img["width"] ||= width.to_s
-          img["height"] ||= height.to_s
+        elsif (size = unlisted_size(img, site, normalized_src))
+          img["width"], img["height"] = size.map(&:to_s)
+        elsif dark.nil?
+          next
         end
         optimized = true
       rescue StandardError => e
@@ -110,21 +111,31 @@ module Jekyll
 
     # Offers an image's generated variants: the resized copies as the <img>'s
     # srcset, and each modern format as a <source> in a <picture> around it.
-    # Markup the author chose, a srcset of their own or a <picture>, is left
-    # alone, and so is an image with nothing generated besides the original.
-    def offer_variants(img, entry, image_config, baseurl)
+    # An image with a dark companion is wrapped for that alone, even when the
+    # pipeline generated nothing else for it. Markup the author chose, a srcset
+    # of their own or a <picture>, is left alone, and so is an image with
+    # nothing generated besides the original.
+    def offer_variants(img, entry, dark, image_config, baseurl)
       return if img["srcset"] || img.parent&.name == "picture"
 
-      fallback = entry.dig("fallback", "variants") || []
-      sources = entry.fetch("sources", []).select { |source| source["type"] && source["variants"]&.any? }
-      return if fallback.size < 2 && sources.empty?
+      fallback = entry&.dig("fallback", "variants") || []
+      sources = (entry || {}).fetch("sources", []).select { |source| source["type"] && source["variants"]&.any? }
+      return if fallback.size < 2 && sources.empty? && dark.nil?
 
       sizes = img["sizes"] || image_config.fetch("default_sizes", "100vw")
-      img["srcset"] = build_srcset(fallback, baseurl) if fallback.size > 1
-      img["sizes"] = sizes
-      return if sources.empty?
+      # `sizes` without a `srcset` on the <img> says nothing; the <source>
+      # elements carry their own.
+      if fallback.size > 1
+        img["srcset"] = build_srcset(fallback, baseurl)
+        img["sizes"] = sizes
+      end
+      dark_first = dark_elements(img, dark, sizes, baseurl)
+      return if sources.empty? && dark_first.empty?
 
       picture = Nokogiri::XML::Node.new("picture", img.document)
+      # A <picture> takes the first source whose media and type both match, so
+      # the dark ones come first or they would never be reached.
+      dark_first.each { |element| picture.add_child(element) }
       sources.each do |source|
         element = Nokogiri::XML::Node.new("source", img.document)
         element["type"] = source["type"]
@@ -136,6 +147,59 @@ module Jekyll
       picture.add_child(img)
     end
 
+    # The dark companion of an image: the one the author named with `dark_src`,
+    # or the twin the build found beside it. A named companion is looked up in
+    # the manifest, so it is served with the same responsive variants as any
+    # other image; one the pipeline never saw, an SVG or an image on another
+    # host, is carried as the single file it is.
+    def dark_twin(img, entry, manifest, site)
+      named = img["data-dark-src"]
+      return entry && entry["dark"] unless named
+
+      img.remove_attribute("data-dark-src")
+      manifest[normalize_src(named, site)] || { "url" => named }
+    end
+
+    # The companion's <source> elements: its modern formats, then its own, so a
+    # browser that supports neither AVIF nor WebP still gets the dark image
+    # rather than the light one.
+    def dark_elements(img, dark, sizes, baseurl)
+      return [] unless dark
+      return [dark_element(img, nil, dark["url"], sizes)] if dark["url"]
+
+      sources = dark.fetch("sources", []).select { |source| source["type"] && source["variants"]&.any? }
+      fallback = dark["fallback"]
+      sources += [fallback] if fallback && fallback["variants"]&.any?
+      sources.map do |source|
+        dark_element(img, source["type"], build_srcset(source["variants"], baseurl), sizes)
+      end
+    end
+
+    # `data-dark-source` marks it for the toggle: a reader whose system is
+    # light and who has switched the site to dark needs the media query
+    # overruled, and the script has to know which sources to overrule.
+    def dark_element(img, type, srcset, sizes)
+      element = Nokogiri::XML::Node.new("source", img.document)
+      element["media"] = DARK_MEDIA
+      element["type"] = type if type
+      element["srcset"] = srcset
+      element["sizes"] = sizes
+      element["data-dark-source"] = ""
+      element
+    end
+
+    # The real size of an image the variant pipeline did not touch, read from
+    # the file, so the page does not shift while it loads. An image the author
+    # gave a width or a height has a deliberate aspect ratio and keeps it.
+    def unlisted_size(img, site, src)
+      return if img["width"] || img["height"]
+
+      source = image_source_path(site, src)
+      return unless source && File.exist?(source)
+
+      FastImage.size(source)
+    end
+
     def prepare_site(site)
       config = image_config(site)
       encoders = config["variants"] ? tools : {}
@@ -149,11 +213,37 @@ module Jekyll
         manifest[entry.delete("source")] = entry
       end
 
+      link_dark_variants(manifest, config)
       site.data["datalog_responsive_images"] = manifest
       site.config["datalog_image_config"] = config
       report(encoders, counts)
     end
 
+    # A plot exported for a white page is unreadable on a dark one. An author
+    # exports a second file beside the first — power.png and power-dark.png —
+    # and every image that has such a twin carries it in the manifest, so the
+    # markup can offer both and the browser can choose.
+    #
+    # The twin is an image in its own right, so it already has its own entry
+    # with its own variants; this only records which entry belongs to which.
+    def link_dark_variants(manifest, config)
+      suffix = config.fetch("dark_suffix", DEFAULT_DARK_SUFFIX).to_s
+      return if suffix.empty?
+
+      manifest.each do |src, entry|
+        extension = File.extname(src)
+        next if extension.empty?
+        # The twin of a twin is not a thing.
+        next if File.basename(src, extension).end_with?(suffix)
+
+        twin = "#{src.delete_suffix(extension)}#{suffix}#{extension}"
+        dark = manifest[twin]
+        next unless dark
+
+        entry["dark"] = { "source" => twin, "sources" => dark["sources"], "fallback" => dark["fallback"] }
+      end
+    end
+
     def report(encoders, counts)
       if counts[:created].positive? || counts[:cached].positive?
         Jekyll.logger.info "Images:", "#{counts[:created]} variants created, #{counts[:cached]} reused from the cache"
@@ -469,7 +559,10 @@ module Jekyll
         "sizes" => options["sizes"] || options["breakpoints"] || DEFAULT_SIZES,
         "quality" => qualities,
         "lazy_loading" => options["lazy_loading"] || "lazy",
-        "default_sizes" => options["default_sizes"] || "100vw"
+        "default_sizes" => options["default_sizes"] || "100vw",
+        # An empty suffix turns the convention off, for a site whose file names
+        # end in "-dark" for some other reason.
+        "dark_suffix" => options.fetch("dark_suffix", DEFAULT_DARK_SUFFIX).to_s
       }
     end
   end
@@ -491,6 +584,20 @@ class Jekyll::ResponsiveImageStaticFile < Jekyll::StaticFile
   end
 end
 
+# The srcset of a list of manifest variants, for markup built in Liquid.
+# `responsive-image.html` wrote its own, three times over, and it had to keep
+# in step with the one the optimizer writes for every other image.
+module Jekyll
+  module ImageSrcsetFilter
+    def image_srcset(variants)
+      site = @context.registers[:site]
+      Jekyll::ImageOptimizer.build_srcset(Array(variants), site&.config&.fetch("baseurl", "").to_s)
+    end
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::ImageSrcsetFilter)
+
 class Jekyll::ImageOptimizerGenerator < Jekyll::Generator
   safe true
   priority :low

data/_plugins/math_preprocessor.rb

@@ -3,6 +3,7 @@
 require "cgi"
 require "kramdown"
 require "kramdown-parser-gfm"
+require_relative "../lib/datalog/latex_speech"
 
 module MathPreprocessor
   DISPLAY_PATTERNS = [
@@ -215,55 +216,13 @@ module MathPreprocessor
       latex.to_s.strip
     end
 
+    # The words the expression reads as (lib/datalog/latex_speech.rb), as the
+    # browser reads one the build didn't wrap. Every command is read, or left out
+    # when it isn't part of what the expression says; this used to drop each command it had no rule
+    # for, so "c \in (a, b)" was labelled "c (a, b)" (#417).
     def auto_alt_text(latex)
-      text = latex.to_s.dup
-
-      text.gsub!(/\\frac\s*\{([^{}]+)\}\s*\{([^{}]+)\}/) do
-        numerator = sanitize_segment(Regexp.last_match[1])
-        denominator = sanitize_segment(Regexp.last_match[2])
-        "#{numerator} over #{denominator}"
-      end
-
-      text.gsub!(/\\int(?:_\{([^}]*)\}|_([^\s^{}]+))?(?:\^\{([^}]*)\}|\^([^\s_{}]+))?/) do
-        lower = Regexp.last_match[1] || Regexp.last_match[2]
-        upper = Regexp.last_match[3] || Regexp.last_match[4]
-        phrase = "integral"
-        phrase += " from #{sanitize_segment(lower)}" if lower && !lower.empty?
-        phrase += " to #{sanitize_segment(upper)}" if upper && !upper.empty?
-        phrase
-      end
-
-      text.gsub!(/\\sum(?:_\{([^}]*)\}|_([^\s^{}]+))?(?:\^\{([^}]*)\}|\^([^\s_{}]+))?/) do
-        lower = Regexp.last_match[1] || Regexp.last_match[2]
-        upper = Regexp.last_match[3] || Regexp.last_match[4]
-        phrase = "summation"
-        phrase += " from #{sanitize_segment(lower)}" if lower && !lower.empty?
-        phrase += " to #{sanitize_segment(upper)}" if upper && !upper.empty?
-        phrase
-      end
-
-      text.gsub!(/\\sqrt\s*\{([^{}]+)\}/) do
-        "square root of #{sanitize_segment(Regexp.last_match[1])}"
-      end
-
-      text.gsub!(/\\mathrm\s*\{([^{}]+)\}/) { sanitize_segment(Regexp.last_match[1]) }
-      text.gsub!(/\\operatorname\*?\s*\{([^{}]+)\}/) { sanitize_segment(Regexp.last_match[1]) }
-      text.gsub!(/\\[a-zA-Z]+\s*/m, " ")
-      text.gsub!(/[{}]/, " ")
-      text.gsub!(/\s+/, " ")
-      text = text.strip
-
-      return "Mathematical expression" if text.empty?
-
-      text
-    end
-
-    def sanitize_segment(segment)
-      return "" unless segment
-
-      cleaned = segment.gsub(/\\[a-zA-Z]+/, " ")
-      cleaned = cleaned.gsub(/[{}]/, " ")
-      cleaned.gsub(/\s+/, " ").strip
+      text = Datalog::LatexSpeech.speak(latex)
+      text.empty? ? "Mathematical expression" : text
     end
   end
 

data/_plugins/notebook_converter.rb

@@ -59,8 +59,10 @@ module Datalog
       cells = Array(notebook["cells"])
       return if cells.empty?
 
+      opening = cells.index { |cell| cell["cell_type"] == "markdown" && !Array(cell["source"]).join.strip.empty? }
       fragments = cells.each_with_index.filter_map do |cell, index|
         source = Array(cell["source"]).join
+        source = without_title_heading(source, metadata) if index == opening
         next if source.strip.empty?
 
         case cell["cell_type"]
@@ -98,10 +100,45 @@ module Datalog
       %(<section class="notebook-cell notebook-cell--markdown">\n#{demote_headings(sanitized.to_s)}\n</section>)
     end
 
-    # The notebook layout gives the page its <h1>, and a notebook's first
-    # markdown cell usually repeats the title as `# Title`. Each heading moves
-    # down a level (h1 to h2, and so on to h6), which keeps one <h1> on the
-    # page and the cells' own outline under it.
+    # The notebook layout writes the page's title as its <h1>, and a notebook
+    # usually opens with the same title as a heading, which showed straight
+    # under it a second time (#416). The first markdown cell loses a heading it
+    # opens with when the heading's text is the title. A heading that says
+    # something else stays, and so does the rest of the cell.
+    def without_title_heading(source, metadata)
+      title = metadata.is_a?(Hash) ? metadata[:title] || metadata["title"] : nil
+      wanted = title.to_s.split.join(" ")
+      return source if wanted.empty?
+
+      lines = source.lines
+      first = lines.index { |line| !line.strip.empty? }
+      return source unless first
+
+      texts, taken = heading_at(lines[first].chomp, lines[first + 1].to_s.chomp)
+      return source unless texts&.any? { |text| text.casecmp?(wanted) }
+
+      lines.drop(first + taken).join
+    end
+
+    # The texts a line can be read as a heading with, as the site's Markdown
+    # (kramdown, GFM) reads it, and how many lines the heading takes. An ATX
+    # heading starts the line and may end with #s, which kramdown leaves out
+    # and a title taken from the heading keeps. A setext heading's text may be
+    # indented up to three spaces, its underline starts the line, and its #s
+    # are text. Anything indented further is code, and is never a heading.
+    def heading_at(line, underline)
+      if line.match?(/\A\#{1,6}(?:[ \t]|\z)/)
+        words = line.sub(/\A#+/, "").split
+        texts = [words.join(" ")]
+        texts << words[0...-1].join(" ") if words.last&.match?(/\A#+\z/)
+        [texts, 1]
+      elsif line.match?(/\A {0,3}\S/) && underline.match?(/\A(?:=+|-+)[ \t]*\z/)
+        [[line.split.join(" ")], 2]
+      end
+    end
+
+    # Each heading left in a cell moves down a level (h1 to h2, and so on to
+    # h6), which keeps one <h1> on the page and the cells' own outline under it.
     def demote_headings(html)
       html.gsub(%r{<(/?)h([1-5])(?=[\s>])}i) { "<#{Regexp.last_match(1)}h#{Regexp.last_match(2).to_i + 1}" }
     end
@@ -782,8 +819,10 @@ module Jekyll
       language = kernelspec["language"] || language_info["name"]
 
       execution_meta = meta["execution_info"] || meta["execution"] || meta.dig("datalog", "execution") || {}
+      # The time the notebook records, or none. The file's own time is the
+      # checkout's: a fresh clone executed and published every notebook at
+      # the moment it was cloned (#411).
       executed_at = parse_time(execution_meta["finished_at"] || execution_meta["timestamp"] || meta["modified"])
-      executed_at ||= File.mtime(absolute_path)
       duration = format_duration(execution_meta["duration"] || meta.dig("datalog", "duration"))
 
       counts = count_cells(cells)

data/_plugins/packages.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../lib/datalog/packages"
+require_relative "licenses"
+
+module Datalog
+  # Liquid's view of a package page: the registries its front matter names
+  # (lib/datalog/packages.rb), and its latest release as
+  # `datalog packages refresh` wrote it to _data/package_releases.yml, which
+  # wins over the `version` and `license` typed in front matter.
+  module PackageFilters
+    # What each registry's language requirement is called on the page.
+    REQUIREMENTS = {
+      "requires_python" => "Python", "rust_version" => "Rust", "required_ruby_version" => "Ruby",
+      "r_version" => "R", "node_version" => "Node.js"
+    }.freeze
+
+    # [{"registry", "label", "url"}]: the registry pages, docs.rs for a crate.
+    def package_links(page)
+      Packages.links(PackageFilters.data(page))
+    end
+
+    # The install panel's tabs. The options are the include's parameters,
+    # which win over the front matter: language, name, git_url, and pip,
+    # conda and cran to replace that tab's command.
+    def package_install_tabs(page, options = {})
+      data = PackageFilters.data(page)
+      options = options.is_a?(Hash) ? options.transform_keys(&:to_s) : {}
+      Packages.install_tabs(data, language: options["language"] || data["language"],
+                                  git_url: options["git_url"] || data["github_url"],
+                                  name: options["name"] || data["title"],
+                                  overrides: options.slice("pip", "conda", "cran"))
+    end
+
+    # {"version", "released", "license", "license_url", "requirement",
+    # "prerelease", "yanked", "registry", "status"}: from the data file, for
+    # the first of the page's registries it has, else from the front matter.
+    def package_release(page)
+      data = PackageFilters.data(page)
+      named = Packages.registries(data)
+      releases = @context["site"]["data"]["package_releases"]
+      releases = {} unless releases.is_a?(Hash)
+      registry, name = named.find { |key, value| releases[key].is_a?(Hash) && releases[key][value].is_a?(Hash) }
+      release = registry ? releases[registry][name].transform_keys(&:to_s) : {}
+      release["registry"] = registry
+      release["version"] = (release["version"] || data["version"])&.to_s
+      unless release.key?("prerelease")
+        release["prerelease"] = Packages.prerelease?(release["version"], registry || named.keys.first)
+      end
+      license(release, data)
+      release["requirement"] = requirement(release)
+      release["status"] = data["status"]&.to_s
+      release.compact.reject { |_key, value| value == "" }
+    end
+
+    def self.data(page)
+      page.respond_to?(:[]) && !page.is_a?(String) ? page : {}
+    end
+
+    private
+
+    # The registry's licence, else the front matter's; and the licence's
+    # address when the front matter resolves the same one, for the JSON-LD.
+    # A `license:` map shows its name, and `license: false` shows none.
+    def license(release, data)
+      given = Licenses.content(data, @context["site"])
+      own = data["license"].is_a?(String) ? data["license"].strip : given&.dig("name")
+      release["license"] = (release["license"] || own)&.to_s
+      same = given && [given["id"], given["name"], own].compact.include?(release["license"])
+      release["license_url"] = given["url"] if same
+    end
+
+    def requirement(release)
+      key = REQUIREMENTS.keys.find { |name| release[name] }
+      return nil unless key
+
+      value = release[key].to_s
+      value = ">= #{value}" if value.match?(/\A\d/)
+      "#{REQUIREMENTS[key]} #{value}"
+    end
+  end
+end
+
+Liquid::Template.register_filter(Datalog::PackageFilters)