datalog-theme 0.6.0

data/_plugins/csp_generator.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "digest"
+
+module Datalog
+  module Security
+    class CspGenerator < Jekyll::Generator
+      priority :highest
+
+      DEFAULT_NONCE_BYTES = 16
+
+      def initialize(config = {})
+        super
+        @nonce_bytes = config.fetch("nonce_bytes", DEFAULT_NONCE_BYTES)
+      end
+
+      def generate(site)
+        site.data["csp"] ||= {}
+        site.data["csp"]["nonces"] ||= {}
+        site.data["csp"]["hashes"] ||= {}
+
+        assign_nonces(site, site.pages)
+        site.collections.each_value do |collection|
+          assign_nonces(site, collection.docs)
+        end
+      end
+
+      def assign_nonces(site, documents)
+        Array(documents).each do |doc|
+          self.class.assign_nonce(site, doc, @nonce_bytes)
+        end
+      end
+
+      def self.assign_nonce(site, document, nonce_bytes = DEFAULT_NONCE_BYTES)
+        return unless document.respond_to?(:data)
+
+        existing = document.data["csp_nonce"]
+        return existing if existing
+
+        nonce = SecureRandom.base64(nonce_bytes)
+        document.data["csp_nonce"] = nonce
+        document.data["csp_hashes"] ||= []
+
+        registry_site = site || (document.respond_to?(:site) ? document.site : nil)
+        if registry_site.respond_to?(:data)
+          registry_site.data["csp"] ||= {}
+          registry_site.data["csp"]["nonces"] ||= {}
+          key = document_key(document)
+          registry_site.data["csp"]["nonces"][key] = nonce if key
+        end
+
+        nonce
+      end
+
+      def self.document_key(doc)
+        if doc.respond_to?(:relative_path) && doc.relative_path
+          doc.relative_path
+        elsif doc.respond_to?(:path)
+          doc.path
+        end
+      end
+
+      def self.compute_hashes(document)
+        return unless document.respond_to?(:output)
+
+        output = document.output
+        return if output.nil? || output.empty?
+
+        site = document.respond_to?(:site) ? document.site : nil
+        nonce = assign_nonce(site, document)
+
+        # Case-insensitive: HTML tag names are, so <SCRIPT> in author content
+        # must be matched too. Without /i such a tag received no nonce and was
+        # then blocked by the policy, which fails closed but silently.
+        output = output.gsub(/<script(?![^>]*\bsrc=)(?![^>]*\bnonce=)([^>]*)>/i) do
+          attributes = Regexp.last_match(1)
+          "<script nonce=\"#{nonce}\"#{attributes}>"
+        end
+
+        document.output = output
+
+        hashes = []
+        output.scan(%r{<script(?![^>]*\bsrc=)[^>]*>(.*?)</script>}mi) do |match|
+          content = match.first
+          next if content.nil? || content.empty?
+
+          hashes << Digest::SHA256.base64digest(content)
+        end
+
+        hashes.uniq!
+        document.data["csp_hashes"] = hashes
+
+        return unless site.respond_to?(:data)
+
+        site.data["csp"] ||= {}
+        site.data["csp"]["hashes"] ||= {}
+
+        key = document_key(document)
+
+        site.data["csp"]["hashes"][key] = hashes if key
+      end
+    end
+  end
+end
+
+%i[pages documents].each do |target|
+  Jekyll::Hooks.register target, :pre_render do |document|
+    Datalog::Security::CspGenerator.assign_nonce(document.respond_to?(:site) ? document.site : nil, document)
+  end
+
+  Jekyll::Hooks.register target, :post_render do |document|
+    Datalog::Security::CspGenerator.compute_hashes(document)
+  end
+end

data/_plugins/datalog_bibliography.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class DatalogBibliographyTag < Liquid::Tag
+    def render(context)
+      page = context.registers[:page]
+      bib_data = page["datalog_bibliography"]
+      return "" unless bib_data
+
+      <<~HTML
+        <div class="datalog-bibliography-placeholder">
+          <p>Bibliography feature coming soon.</p>
+        </div>
+      HTML
+    end
+  end
+end
+
+Liquid::Template.register_tag("datalog_bibliography", Jekyll::DatalogBibliographyTag)

data/_plugins/datalog_comments.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class DatalogCommentsTag < Liquid::Tag
+    def render(context)
+      page = context.registers[:page]
+      return "" unless page["datalog_comments"]
+
+      <<~HTML
+        <div class="datalog-comments-placeholder">
+          <p>Comments feature coming soon.</p>
+        </div>
+      HTML
+    end
+  end
+end
+
+Liquid::Template.register_tag("datalog_comments", Jekyll::DatalogCommentsTag)

data/_plugins/datalog_slides.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class DatalogSlidesTag < Liquid::Tag
+    def render(context)
+      page = context.registers[:page]
+      slides_data = page["datalog_slides"]
+      return "" unless slides_data
+
+      # Render a simple placeholder or embed
+      <<~HTML
+        <div class="datalog-slides-placeholder">
+          <p>Slides feature coming soon. Configured: #{slides_data}</p>
+        </div>
+      HTML
+    end
+  end
+end
+
+Liquid::Template.register_tag("datalog_slides", Jekyll::DatalogSlidesTag)

data/_plugins/front_matter_compat.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# Minimal Mistakes front-matter compatibility.
+#
+# Sites migrating from the Minimal Mistakes theme carry front matter such as
+#
+#   header:
+#     image: /assets/images/hero.jpg
+#     overlay_image: /assets/images/hero.jpg
+#     teaser: /assets/images/hero.jpg
+#     og_image: /assets/images/hero.jpg
+#   seo_title: Short title for search engines
+#   seo_description: Meta description
+#   classes: wide
+#
+# DataLog's layouts read `image`, `og_image`, `twitter_image`, `teaser`,
+# `description` and an array of `classes`; the post hero is read from a
+# `post_hero` hash. This hook fills those fields from the Minimal Mistakes
+# ones when they are absent, so a migrated site keeps its hero images,
+# teasers, titles and descriptions without every post being edited. Explicit
+# DataLog fields always win: the mapping only fills gaps and never overwrites
+# a value the author set.
+#
+# The hero is deliberately kept under its own key rather than `hero_image`,
+# which DataLog's page and portfolio layouts already use for their own hero
+# rendering.
+#
+# See docs/migrating-from-minimal-mistakes.md for the full field table.
+module Datalog
+  module FrontMatterCompat
+    SOCIAL_IMAGE_KEYS = %w[og_image image overlay_image teaser].freeze
+    HERO_IMAGE_KEYS = %w[overlay_image image].freeze
+    TEASER_IMAGE_KEYS = %w[teaser image og_image overlay_image].freeze
+
+    module_function
+
+    # Normalises one document's front matter in place and returns it.
+    def normalize!(data)
+      return data unless data.is_a?(Hash)
+
+      header = data["header"].is_a?(Hash) ? data["header"] : {}
+
+      assign_missing(data, "og_image", header["og_image"])
+      assign_missing(data, "image", first_present(header, SOCIAL_IMAGE_KEYS))
+      assign_missing(data, "twitter_image", header["twitter_image"])
+      assign_missing(data, "teaser", first_present(header, TEASER_IMAGE_KEYS))
+
+      hero = first_present(header, HERO_IMAGE_KEYS)
+      data["post_hero"] = post_hero_from(header, hero) if hero && !data["post_hero"].is_a?(Hash)
+
+      assign_missing(data, "description", data["seo_description"])
+      data["classes"] = normalize_classes(data["classes"]) if data.key?("classes")
+      data
+    end
+
+    def post_hero_from(header, image)
+      {
+        "image" => image,
+        "overlay" => overlay?(header),
+        "alt" => header["image_description"],
+        "caption" => header["caption"],
+        "overlay_filter" => header["overlay_filter"],
+        "overlay_color" => header["overlay_color"]
+      }.reject { |_key, value| !present?(value) && value != false }
+    end
+
+    # Minimal Mistakes renders the title over the image when either an overlay
+    # image or an overlay colour is given; a plain `header.image` is a figure.
+    def overlay?(header)
+      present?(header["overlay_image"]) || present?(header["overlay_color"])
+    end
+
+    def first_present(hash, keys)
+      keys.map { |key| hash[key] }.find { |value| present?(value) }
+    end
+
+    def assign_missing(data, key, value)
+      return unless present?(value)
+      return if present?(data[key])
+
+      data[key] = value
+    end
+
+    # `classes: wide` (a string) and `classes: [wide]` (a list) both become a
+    # list, which is what the default layout joins into the body class.
+    def normalize_classes(value)
+      case value
+      when Array then value.flatten.compact.map(&:to_s).flat_map(&:split)
+      when String then value.split
+      else []
+      end
+    end
+
+    def present?(value)
+      case value
+      when nil, false then false
+      when String then !value.strip.empty?
+      else true
+      end
+    end
+  end
+end
+
+Jekyll::Hooks.register :site, :post_read do |site|
+  site.collections.each_value do |collection|
+    collection.docs.each { |doc| Datalog::FrontMatterCompat.normalize!(doc.data) }
+  end
+  site.pages.each { |page| Datalog::FrontMatterCompat.normalize!(page.data) }
+end

data/_plugins/i18n.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Datalog
+  module I18n
+    module_function
+
+    def locale(context)
+      page_lang = context["page"] && context["page"]["lang"]
+      site = context.registers[:site]
+      site_locale = site.config.dig("theme_options", "localization", "default_locale") || site.config["locale"] || "en"
+      lang = page_lang || site_locale
+      lang.to_s.split(/[-_]/).first
+    end
+
+    def data_for(site)
+      site.data.fetch("i18n", {})
+    end
+
+    def lookup(site, locale_code, key)
+      data = data_for(site)
+      locales = [locale_code, "en"].uniq
+      path = key.to_s.split(".")
+
+      locales.each do |code|
+        scope = data[code]
+        next unless scope
+
+        value = path.reduce(scope) do |memo, segment|
+          break unless memo.is_a?(Hash)
+
+          memo[segment] || memo[segment.to_sym]
+        end
+
+        return value if value.is_a?(String)
+      end
+
+      nil
+    end
+
+    def interpolate(value, options)
+      return value unless options.is_a?(Hash) && !options.empty?
+
+      options.reduce(value) do |memo, (key, replacement)|
+        memo.gsub("{{#{key}}}", replacement.to_s)
+      end
+    end
+
+    def translate(context, key, options = {})
+      site = context.registers[:site]
+      locale_code = locale(context)
+      value = lookup(site, locale_code, key)
+      value ||= key
+      interpolate(value.to_s, stringify_keys(options))
+    end
+
+    def stringify_keys(options)
+      return {} unless options
+
+      options.each_with_object({}) do |(key, value), memo|
+        memo[key.to_s] = value
+      end
+    end
+
+    def localized_format(context, input, format_key = "long")
+      date = if input.respond_to?(:to_time)
+               input.to_time
+             else
+               Liquid::Utils.to_date(input)
+             end
+      return "" unless date
+
+      site = context.registers[:site]
+      locale_code = locale(context)
+      translations = data_for(site)
+      locale_data = translations[locale_code] || translations["en"] || {}
+      date_scope = locale_data["date"] || {}
+      formats = date_scope["formats"] || {}
+      format_string = formats[format_key] || formats["default"] || "%B %-d, %Y"
+      formatted = date.strftime(format_string)
+
+      months = date_scope["months"] || {}
+      short_months = date_scope["months_short"] || {}
+      weekdays = date_scope["weekdays"] || {}
+      short_weekdays = date_scope["weekdays_short"] || {}
+
+      if months && !months.empty?
+        formatted = replace_name(formatted, date.strftime("%B"),
+                                 months[date.month.to_s] || months[date.month])
+      end
+      if short_months && !short_months.empty?
+        formatted = replace_name(formatted, date.strftime("%b"),
+                                 short_months[date.month.to_s] || short_months[date.month])
+      end
+      if weekdays && !weekdays.empty?
+        formatted = replace_name(formatted, date.strftime("%A"),
+                                 weekdays[date.wday.to_s] || weekdays[date.wday])
+      end
+      if short_weekdays && !short_weekdays.empty?
+        formatted = replace_name(formatted, date.strftime("%a"),
+                                 short_weekdays[date.wday.to_s] || short_weekdays[date.wday])
+      end
+
+      formatted
+    end
+
+    def replace_name(text, english, localized)
+      return text unless english && localized
+
+      text.gsub(english, localized)
+    end
+  end
+end
+
+class TranslateTag < Liquid::Tag
+  # The key may be bare or quoted; a quoted key must not leak its closing
+  # quote into the first option name, or interpolation silently fails.
+  SYNTAX = /\A\s*(['"]?)(\w[\w.-]*)\1(.*)?\z/m
+
+  def initialize(tag_name, markup, tokens)
+    super
+    raise Liquid::SyntaxError, "Syntax Error in 't' - Valid syntax: t key [arg: value]" unless markup.strip =~ SYNTAX
+
+    @key = Regexp.last_match(2)
+    @markup = Regexp.last_match(3)
+  end
+
+  def render(context)
+    options = parse_options(@markup, context)
+    Datalog::I18n.translate(context, @key, options)
+  end
+
+  private
+
+  def parse_options(markup, context)
+    return {} unless markup && !markup.strip.empty?
+
+    tokens = markup.strip.split(",").map(&:strip)
+    tokens.each_with_object({}) do |token, memo|
+      next if token.empty?
+
+      if token.include?(":")
+        key, value = token.split(":", 2)
+        memo[key.strip.to_sym] = context.evaluate(Liquid::Expression.parse(value.strip))
+      end
+    end
+  end
+end
+
+module TranslateFilter
+  def t(key, options = {})
+    Datalog::I18n.translate(@context, key, options)
+  end
+
+  def localize_date(input, format = "long")
+    Datalog::I18n.localized_format(@context, input, format)
+  end
+end
+
+Liquid::Template.register_tag("t", TranslateTag)
+Liquid::Template.register_filter(TranslateFilter)