datalog-theme 0.6.0

data/_plugins/plugin_loader.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "jekyll/utils"
+
+require_relative "../lib/datalog/plugin_system"
+
+Dir[File.expand_path("../lib/datalog/plugins/**/*.rb", __dir__)].each do |plugin_file|
+  require plugin_file
+end
+
+module Datalog
+  class PluginLoader < Jekyll::Generator
+    safe true
+    priority :highest
+
+    def generate(site)
+      plugin_classes = enabled_plugins(site).filter_map do |identifier|
+        resolve_plugin_class(identifier)
+      end
+
+      resolver = Datalog::PluginSystem::DependencyResolver.new(
+        plugin_classes,
+        available: Datalog::PluginSystem.available_plugins
+      )
+
+      ordered_classes = resolver.resolve
+      log_dependency_resolution(resolver, ordered_classes)
+
+      instances = ordered_classes.filter_map do |klass|
+        instantiate_plugin(site, klass)
+      end
+
+      Datalog::PluginSystem.activate!(site, instances)
+      register_liquid_tags(instances)
+
+      site.config["datalog_plugin_state"] = {
+        "active" => instances.map(&:id),
+        "available" => Datalog::PluginSystem.available_plugins.keys.sort
+      }
+    rescue Datalog::PluginSystem::PluginDependencyError => e
+      logger.error("datalog plugin", e.message)
+      raise e
+    end
+
+    private
+
+    def enabled_plugins(site)
+      config = site.config.fetch("datalog_plugins", {})
+
+      plugins =
+        case config
+        when Array
+          config
+        when Hash
+          Array(config["enabled"] || config["plugins"] || [])
+        else
+          []
+        end
+
+      plugins.each_with_object([]) do |identifier, acc|
+        next if identifier.nil?
+
+        value = identifier.to_s.strip
+        next if value.empty?
+
+        acc << value unless acc.include?(value)
+      end
+    end
+
+    def instantiate_plugin(site, klass)
+      identifier = klass.id
+      config = fetch_plugin_config(site, identifier)
+      klass.new(site, config)
+    rescue StandardError => e
+      logger.error("datalog plugin", "#{identifier} failed to initialize: #{e.message}")
+      nil
+    end
+
+    def resolve_plugin_class(identifier)
+      klass = Datalog::PluginSystem.available_plugins[identifier]
+      unless klass
+        logger.warn("datalog plugin", "#{identifier} is not registered; skipping")
+        return
+      end
+
+      klass
+    end
+
+    def fetch_plugin_config(site, identifier)
+      config = site.config.fetch("datalog_plugins", {})
+      return {} unless config.is_a?(Hash)
+
+      options = config.fetch("options", {})
+      return {} unless options.is_a?(Hash)
+
+      key = identifier
+      value = options[key] || options[key.to_s] || options[key.to_sym]
+      value.is_a?(Hash) ? value : {}
+    end
+
+    def register_liquid_tags(instances)
+      instances.each do |plugin|
+        next unless plugin.respond_to?(:custom_liquid_tags)
+
+        tags = plugin.custom_liquid_tags
+        unless tags.is_a?(Hash)
+          logger.warn("datalog plugin", "#{plugin.id} returned invalid Liquid tags payload; expected a hash")
+          next
+        end
+
+        tags.each do |tag_name, tag_class|
+          next if tag_name.to_s.empty? || tag_class.nil?
+
+          Liquid::Template.register_tag(tag_name, tag_class)
+        rescue StandardError => e
+          logger.warn("datalog plugin", "#{plugin.id} failed to register #{tag_name} tag: #{e.message}")
+        end
+      rescue StandardError => e
+        logger.warn("datalog plugin", "#{plugin.id} failed while registering Liquid tags: #{e.message}")
+      end
+    end
+
+    def logger
+      Jekyll.logger
+    end
+
+    def log_dependency_resolution(resolver, ordered_classes)
+      return unless debug_logging?
+
+      identifiers = ordered_classes.map(&:id)
+      logger.debug("datalog plugin", "resolved load order: #{identifiers.join(' -> ')}")
+
+      graph = resolver.dependency_graph
+      return if graph.empty?
+
+      graph_summary = graph.map do |plugin_id, dependencies|
+        deps = Array(dependencies).map(&:to_s).sort
+        deps.empty? ? "#{plugin_id}: []" : "#{plugin_id}: [#{deps.join(', ')}]"
+      end.join("; ")
+
+      logger.debug("datalog plugin", "dependency graph: #{graph_summary}")
+    end
+
+    def debug_logging?
+      logger.respond_to?(:debug?) && logger.debug?
+    end
+  end
+end
+
+module Datalog
+  module PluginLoaderHooks
+    HOOK_SCOPES = %i[pages documents posts].freeze
+
+    module_function
+
+    def register!
+      HOOK_SCOPES.each do |scope|
+        Jekyll::Hooks.register scope, :pre_render do |document, payload|
+          Datalog::PluginSystem.run_hook(:before_render, document, payload)
+        end
+
+        Jekyll::Hooks.register scope, :post_render do |document|
+          extensions = Datalog::PluginSystem.collect_hook(:search_indexing, document)
+          next if extensions.nil? || extensions.empty?
+
+          existing = document.data["datalog_search_extensions"] || {}
+          document.data["datalog_search_extensions"] = deep_merge_extensions(existing, extensions)
+        end
+
+        Jekyll::Hooks.register scope, :post_write do |document|
+          Datalog::PluginSystem.run_hook(:after_post_process, document)
+        end
+      end
+    end
+
+    def deep_merge_extensions(existing, extensions)
+      return extensions unless existing.is_a?(Hash)
+      return existing unless extensions.is_a?(Hash)
+
+      Jekyll::Utils.deep_merge_hashes(existing, extensions)
+    end
+  end
+end
+
+Datalog::PluginLoaderHooks.register!

data/_plugins/publications_generator.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class PublicationsGenerator < Generator
+    safe true
+    priority :low
+
+    def generate(site)
+      publications_data = site.data["publications"] ||= {}
+      settings = publications_data["settings"] || {}
+      config_source = site.config.dig("theme_options", "publications", "bibtex_source")
+      bibtex_source = settings["bibtex_source"] || config_source
+
+      imported_entries = []
+      if bibtex_source
+        bibtex_path = site.in_source_dir(bibtex_source)
+        if File.exist?(bibtex_path)
+          content = File.read(bibtex_path, encoding: "UTF-8")
+          imported_entries = parse_bibtex_entries(content)
+        else
+          Jekyll.logger.warn("PublicationsGenerator:", "BibTeX source not found at #{bibtex_path}")
+        end
+      end
+
+      manual_entries = publications_data["manual_entries"] || []
+      combined = (imported_entries + manual_entries).map { |entry| normalize_entry(entry) }
+
+      academic_citations = site.data.dig("academic", "citations", "per_publication") || {}
+      citations_map = {}
+      combined.each do |entry|
+        identifier = entry["id"] || parameterize(entry["title"])
+        citation_info = locate_citation_info(academic_citations, identifier)
+        if citation_info
+          entry["citations"] = citation_info["total"] || citation_info[:total]
+          entry["citations_last_updated"] = citation_info["last_updated"] || citation_info[:last_updated]
+        end
+        next unless identifier
+
+        citations_map[identifier] = {
+          "total" => entry["citations"]&.to_i,
+          "last_updated" => entry["citations_last_updated"]
+        }
+      end
+
+      sort_order = (settings["sort"] || settings["sort_order"] || "descending").to_s
+      combined.sort_by! { |entry| [entry["year"] ? entry["year"].to_i : 0, entry["title"].to_s.downcase] }
+      combined.reverse! if sort_order == "descending"
+
+      group_field = settings["group_by"] || site.config.dig("theme_options", "publications", "group_by")
+      grouped = group_entries(combined, group_field, sort_order)
+
+      include_bibliography = if settings.key?("include_bibliography")
+                               settings["include_bibliography"]
+                             else
+                               site.config.dig(
+                                 "theme_options", "publications", "include_bibliography"
+                               )
+                             end
+      exports = settings["export_formats"] || site.config.dig("theme_options", "publications", "export_formats") || []
+
+      metrics_override = site.data.dig("academic", "citations", "metrics") || {}
+      metrics = compute_metrics(combined, citations_map, metrics_override)
+
+      publications_data["imported"] = imported_entries
+      publications_data["entries"] = combined
+      publications_data["grouped"] = grouped if grouped
+      publications_data["citation_totals"] = citations_map
+      publications_data["metrics"] = metrics
+      publications_data["yearly_totals"] = metrics["yearly_totals"]
+      return unless include_bibliography
+
+      publications_data["bibliography"] = build_bibliography(combined)
+      publications_data["export_formats"] = exports
+    end
+
+    private
+
+    ENTRY_REGEX = /@(?<type>\w+)\s*\{\s*(?<key>[^,]+),\s*(?<fields>.*?)\}\s*(?=@|\z)/m
+
+    def parse_bibtex_entries(content)
+      entries = []
+      content.to_s.scan(ENTRY_REGEX) do |type, key, raw_fields|
+        fields = {}
+        raw_fields.lines.each do |line|
+          cleaned = line.strip
+          next if cleaned.empty?
+
+          cleaned = cleaned.delete_suffix(",")
+          name, value = cleaned.split("=", 2)
+          next unless name && value
+
+          name = name.strip.downcase
+          value = value.strip
+          value = value.gsub(/\A["{]+/, "").gsub(/["}]+\z/, "")
+          fields[name] = value.strip
+        end
+        entries << {
+          "id" => key.strip,
+          "type" => type.strip.downcase,
+          "title" => fields["title"],
+          "authors" => parse_authors(fields["author"]),
+          "venue" => fields["journal"] || fields["booktitle"] || fields["institution"],
+          "year" => fields["year"],
+          "doi" => fields["doi"],
+          "url" => fields["url"],
+          "raw" => fields
+        }
+      end
+      entries
+    end
+
+    def parse_authors(raw)
+      return [] unless raw
+
+      raw.split(/\s+and\s+/i).map(&:strip)
+    end
+
+    def normalize_entry(entry)
+      normalized = entry.transform_keys(&:to_s)
+      normalized["authors"] = parse_authors(normalized["authors"]) if normalized["authors"].is_a?(String)
+      normalized["year"] = normalized["year"].to_s if normalized["year"]
+      normalized
+    end
+
+    def locate_citation_info(map, identifier)
+      return nil unless identifier
+
+      map[identifier] || map[identifier.to_s] || map[identifier.to_s.downcase]
+    end
+
+    def parameterize(value)
+      return nil unless value
+
+      value.to_s.downcase.strip.gsub(/[^a-z0-9]+/, "-").gsub(/^-|-$/, "")
+    end
+
+    def group_entries(entries, field, sort_order)
+      return nil unless field && !field.to_s.empty?
+
+      grouped = entries.group_by { |entry| entry[field.to_s] || "Other" }
+      sorted = grouped.sort_by do |group_key, _|
+        group_value = group_key.to_s
+        if group_value.match?(/\A\d+\z/)
+          group_value.to_i
+        else
+          group_value.downcase
+        end
+      end
+      sorted.reverse! if sort_order == "descending"
+      sorted
+    end
+
+    def compute_metrics(entries, citations_map, override)
+      yearly_totals = Hash.new(0)
+      citation_counts = []
+      entries.each do |entry|
+        year = entry["year"]
+        citations = entry["citations"]
+        citation_value = citations.to_i if citations
+        if citation_value&.positive?
+          citation_counts << citation_value
+          yearly_totals[year.to_s] += citation_value if year
+        elsif year
+          yearly_totals[year.to_s] += 1
+        end
+      end
+
+      citation_counts.sort! { |a, b| b <=> a }
+      total = citation_counts.reduce(0, :+)
+      h_index = 0
+      citation_counts.each_with_index do |count, index|
+        h_index = index + 1 if count >= index + 1
+      end
+      i10_index = citation_counts.count { |count| count >= 10 }
+
+      metrics = {
+        "total" => total,
+        "h_index" => h_index,
+        "i10_index" => i10_index,
+        "per_publication" => citations_map,
+        "yearly_totals" => yearly_totals
+      }
+
+      override.each do |key, value|
+        metrics[key.to_s] = if value.is_a?(Hash)
+                              merge_nested_hash(metrics[key.to_s], value)
+                            else
+                              value
+                            end
+      end
+
+      metrics
+    end
+
+    def merge_nested_hash(base, override)
+      base = (base || {}).transform_keys(&:to_s)
+      override.each do |key, value|
+        key = key.to_s
+        base[key] = if value.is_a?(Hash)
+                      merge_nested_hash(base[key], value)
+                    else
+                      value
+                    end
+      end
+      base
+    end
+
+    def build_bibliography(entries)
+      entries.map { |entry| format_bibtex(entry) }.compact
+    end
+
+    def format_bibtex(entry)
+      type = entry["type"] || "article"
+      identifier = entry["id"] || parameterize(entry["title"]) || "reference"
+      authors = Array(entry["authors"]).map { |author| author.to_s.strip }.reject(&:empty?)
+      buffer = []
+      buffer << "@#{type}{ #{identifier},"
+      buffer << "  title = { #{entry['title']} }," if entry["title"]
+      buffer << "  author = { #{authors.join(' and ')} }," if authors.any?
+      buffer << "  year = { #{entry['year']} }," if entry["year"]
+      buffer << "  journal = { #{entry['venue']} }," if entry["venue"]
+      buffer << "  doi = { #{entry['doi']} }," if entry["doi"]
+      buffer << "  url = { #{entry['url']} }," if entry["url"]
+      raw_fields = entry["raw"] || {}
+      %w[volume number pages publisher].each do |field|
+        next unless raw_fields[field]
+
+        buffer << "  #{field} = { #{raw_fields[field]} },"
+      end
+      buffer << "}"
+      buffer.join("\n")
+    end
+  end
+end

data/_plugins/reading_time.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module ReadingTimeFilter
+    WORDS_PER_MINUTE = 180.0
+
+    def reading_time(input)
+      words = input.to_s.split.size
+      minutes = (words / WORDS_PER_MINUTE).ceil
+      minutes.positive? ? minutes : 1
+    end
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::ReadingTimeFilter)

data/_plugins/search_normalizer.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+begin
+  require "unicode_normalize"
+  UNICODE_NORMALIZE_SUPPORTED = true
+rescue LoadError
+  UNICODE_NORMALIZE_SUPPORTED = false
+  warn "[search_normalizer] unicode_normalize gem not available; falling back to basic normalization"
+end
+
+module Datalog
+  module SearchFilters
+    module_function
+
+    def normalize_search(input)
+      value = input.to_s
+      return "" if value.empty?
+
+      normalized = if UNICODE_NORMALIZE_SUPPORTED && value.respond_to?(:unicode_normalize)
+                     value.unicode_normalize(:nfkd).gsub(/\p{Mn}/, "")
+                   else
+                     transliterate(value)
+                   end
+
+      normalized.downcase.strip
+    rescue StandardError
+      input.to_s.downcase
+    end
+
+    def transliterate(value)
+      value.encode("ASCII", fallback: lambda { |char|
+        approximate_character(char)
+      }, invalid: :replace, undef: :replace, replace: "")
+    rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
+      value
+    end
+
+    def approximate_character(char)
+      @transliteration_map ||= build_transliteration_map
+      @transliteration_map.fetch(char, "")
+    end
+
+    def build_transliteration_map
+      basic_map = {}
+
+      accents = {
+        "ÀÁÂÃÄÅàáâãäå" => "a",
+        "ÈÉÊËèéêë" => "e",
+        "ÌÍÎÏìíîï" => "i",
+        "ÒÓÔÕÖØòóôõöø" => "o",
+        "ÙÚÛÜùúûü" => "u",
+        "Çç" => "c",
+        "Ññ" => "n",
+        "Ýýÿ" => "y",
+        "Ææ" => "ae",
+        "Œœ" => "oe"
+      }
+
+      accents.each do |chars, replacement|
+        chars.each_char { |char| basic_map[char] = replacement }
+      end
+
+      basic_map
+    end
+
+    def normalize_search_array(values)
+      Array(values)
+        .map { |value| normalize_search(value) }
+        .reject(&:empty?)
+    end
+  end
+end
+
+Liquid::Template.register_filter(Datalog::SearchFilters)

data/_plugins/sri_filter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module SriFilter
+    def add_sri(url)
+      site = @context.registers[:site]
+      integrity_map = site.data["cdn-integrity"] || {}
+      entry = integrity_map[url]
+      return url unless entry
+
+      attributes = "#{url}\" integrity=\"#{entry['integrity']}"
+      attributes += "\" crossorigin=\"#{entry['crossorigin']}" if entry["crossorigin"]
+      attributes
+    end
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::SriFilter)

data/_plugins/toc_filter.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+# `tocify` builds a nested list of links to the headings of a rendered HTML
+# fragment. The table-of-contents includes (`components/enhanced-toc.html`,
+# `toc.html`) call it as `content | tocify: h_min, h_max`.
+#
+# Headings keep the ids kramdown gives them; a heading without an id gets a
+# slug of its text, which still needs an anchor in the page to be useful.
+module Jekyll
+  module TocifyFilter
+    def tocify(html, h_min = 2, h_max = 4)
+      return "" if html.nil? || html.to_s.strip.empty?
+
+      lowest = h_min.to_i.clamp(1, 6)
+      highest = h_max.to_i.clamp(lowest, 6)
+      fragment = Nokogiri::HTML::DocumentFragment.parse(html.to_s)
+      selector = (lowest..highest).map { |level| "h#{level}" }.join(",")
+
+      headings = fragment.css(selector).filter_map do |node|
+        text = node.text.strip
+        next if text.empty?
+
+        id = node["id"].to_s.strip
+        id = Jekyll::Utils.slugify(text) if id.empty?
+        [node.name[1].to_i, id, text]
+      end
+      return "" if headings.empty?
+
+      tocify_render_list(headings, lowest)
+    end
+
+    private
+
+    def tocify_render_list(headings, top_level)
+      out = +""
+      open_levels = []
+      headings.each do |level, id, text|
+        level = [level, top_level].max
+        if open_levels.empty?
+          out << %(<ul class="toc-list">)
+          open_levels << level
+        elsif level > open_levels.last
+          out << "<ul>"
+          open_levels << level
+        else
+          out << "</li>"
+          while open_levels.size > 1 && level < open_levels.last
+            out << "</ul></li>"
+            open_levels.pop
+          end
+        end
+        out << %(<li class="toc-item toc-level-#{level}"><a href="##{id}">#{tocify_escape_text(text)}</a>)
+      end
+      out << "</li>"
+      out << "</ul></li>" * (open_levels.size - 1)
+      out << "</ul>"
+      out
+    end
+
+    def tocify_escape_text(text)
+      text.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub('"', "&quot;")
+    end
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::TocifyFilter)

data/_plugins/warning_filter.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "../lib/datalog/warning_filter"