datalog-theme 0.6.0

data/lib/datalog/plugins/comments.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Datalog
+  module Plugins
+    class Comments < Datalog::PluginSystem::Plugin
+      id "datalog-comments"
+      depends_on "datalog-search"
+      priority :low
+
+      class CommentsTag < Liquid::Tag
+        def render(context)
+          plugin = Datalog::PluginSystem.plugin("datalog-comments")
+          return "" unless plugin
+
+          plugin.render_comments(context)
+        end
+      end
+
+      REQUIRED_FIELDS = {
+        "giscus" => %w[repo repo_id category category_id],
+        "utterances" => %w[repo],
+        "disqus" => %w[shortname]
+      }.freeze
+
+      def initialize(site, config = {})
+        super
+        @defaults = {
+          "provider" => "giscus",
+          "mapping" => "pathname",
+          "theme" => "light",
+          "enabled_by_default" => false
+        }.merge(@config)
+        @memo = {}
+      end
+
+      def before_render(document, _payload = nil)
+        return unless comments_enabled?(document)
+
+        settings = resolve_settings(document)
+        embed = build_embed(document, settings)
+
+        document.data["datalog_comments"] = settings.merge("embed" => embed)
+        document.data["datalog_comments_state"] = storage_key(document)
+        @memo[storage_key(document)] = settings.merge("embed" => embed)
+      end
+
+      def custom_liquid_tags
+        { "datalog_comments" => CommentsTag }
+      end
+
+      def search_indexing(document)
+        key = storage_key(document)
+        settings = @memo[key]
+        return {} unless settings
+
+        {
+          "comments" => {
+            "provider" => settings["provider"],
+            "mapping" => settings["mapping"]
+          }
+        }
+      end
+
+      def render_comments(context)
+        page = context.registers[:page] || {}
+        key = page["datalog_comments_state"]
+        settings = @memo[key]
+        return "" unless settings
+
+        <<~HTML
+          <div class="datalog-comments" aria-label="Comments">
+            #{settings['embed']}
+          </div>
+        HTML
+      end
+
+      private
+
+      def comments_enabled?(document)
+        front_matter = document.data.fetch("comments", nil)
+        if front_matter.nil?
+          @defaults["enabled_by_default"]
+        else
+          front_matter != false
+        end
+      end
+
+      def resolve_settings(document)
+        front_matter = document.data.fetch("comments", {})
+        front_settings = front_matter.is_a?(Hash) ? front_matter.transform_keys(&:to_s) : {}
+        @defaults.merge(front_settings)
+      end
+
+      def build_embed(document, settings)
+        provider = settings["provider"]
+        missing = missing_required_fields(provider, settings)
+        unless missing.empty?
+          logger.warn(
+            "datalog comments",
+            %(Missing required settings for #{provider.inspect}: #{missing.join(', ')})
+          )
+          return %(<p class="datalog-comments-missing">Comments provider "#{provider}" missing required settings: #{missing.join(', ')}. Check your front matter or datalog configuration.</p>)
+        end
+
+        case provider
+        when "giscus"
+          render_giscus(settings)
+        when "utterances"
+          render_utterances(settings)
+        when "disqus"
+          render_disqus(document, settings)
+        else
+          %(<p class="datalog-comments-unsupported">Comments provider "#{settings['provider']}" is not supported.</p>)
+        end
+      end
+
+      def render_giscus(settings)
+        %(<script src="https://giscus.app/client.js"
+          data-repo="#{settings['repo']}"
+          data-repo-id="#{settings['repo_id']}"
+          data-category="#{settings['category']}"
+          data-category-id="#{settings['category_id']}"
+          data-mapping="#{settings['mapping']}"
+          data-strict="0"
+          data-reactions-enabled="1"
+          data-emit-metadata="0"
+          data-input-position="bottom"
+          data-theme="#{settings['theme']}"
+          data-lang="#{settings['lang'] || 'en'}"
+          crossorigin="anonymous"
+          async></script>)
+      end
+
+      def render_utterances(settings)
+        %(<script src="https://utteranc.es/client.js"
+          repo="#{settings['repo']}"
+          issue-term="#{settings['mapping']}"
+          theme="#{settings['theme']}"
+          crossorigin="anonymous"
+          async></script>)
+      end
+
+      def render_disqus(document, settings)
+        shortname = settings["shortname"] || ""
+        nonce = nonce_attribute(document)
+        <<~HTML
+          <div id="disqus_thread"></div>
+          <script#{nonce}>
+            var disqus_config = function () {
+              this.page.url = window.location.href;
+              this.page.identifier = '#{settings['mapping']}';
+            };
+            (function() {
+              var d = document, s = d.createElement('script');
+              s.src = 'https://#{shortname}.disqus.com/embed.js';
+              s.setAttribute('data-timestamp', +new Date());
+              (d.head || d.body).appendChild(s);
+            })();
+          </script>
+          <noscript>Please enable JavaScript to view the comments powered by Disqus.</noscript>
+        HTML
+      end
+
+      def nonce_attribute(document)
+        nonce = document.data.fetch("csp_nonce", nil)
+        nonce ? %( nonce="#{nonce}") : ""
+      end
+
+      def storage_key(document)
+        document.relative_path || document.path
+      end
+
+      def missing_required_fields(provider, settings)
+        required = REQUIRED_FIELDS.fetch(provider.to_s, [])
+        required.select { |key| settings[key].to_s.strip.empty? }
+      end
+
+      def logger
+        Jekyll.logger
+      end
+    end
+  end
+end

data/lib/datalog/plugins/search.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "jekyll/utils"
+
+module Datalog
+  module Plugins
+    class Search < Datalog::PluginSystem::Plugin
+      id "datalog-search"
+      priority :highest
+
+      def initialize(site, config = {})
+        super
+        @index_metadata = config.fetch("metadata", {})
+      end
+
+      def before_render(document, _payload = nil)
+        document.data["datalog_search"] = base_metadata(document)
+      end
+
+      def search_indexing(document)
+        base_metadata(document)
+      end
+
+      private
+
+      def base_metadata(document)
+        # Get collection label safely - only Jekyll::Document has the collection method
+        collection_label = if document.respond_to?(:collection) && document.collection
+                             document.collection.label
+                           else
+                             document.data["collection"]
+                           end
+
+        data = {
+          "id" => document.data["id"] || document.data["permalink"] || document.url,
+          "title" => document.data["title"],
+          "url" => document.url,
+          "collection" => collection_label
+        }
+
+        Jekyll::Utils.deep_merge_hashes(@index_metadata, data.compact)
+      end
+    end
+  end
+end

data/lib/datalog/plugins/slides.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Datalog
+  module Plugins
+    class Slides < Datalog::PluginSystem::Plugin
+      id "datalog-slides"
+      depends_on "datalog-search"
+      priority :normal
+
+      class SlidesTag < Liquid::Tag
+        def render(context)
+          plugin = Datalog::PluginSystem.plugin("datalog-slides")
+          return "" unless plugin
+
+          plugin.render_slides(context)
+        end
+      end
+
+      def initialize(site, config = {})
+        super
+        @defaults = {
+          "cdn" => "https://unpkg.com/reveal.js@5",
+          "width" => "100%",
+          "height" => "600px"
+        }.merge(@config)
+      end
+
+      def before_render(document, _payload = nil)
+        deck = document.data["slides"] || document.data["deck"]
+        return unless deck
+
+        normalized = normalize_deck(deck)
+        return unless normalized
+
+        document.data["datalog_slides"] = normalized
+        document.data["datalog_slides_state"] = storage_key(document)
+        slide_state(storage_key(document))[:deck] = normalized
+      end
+
+      def custom_liquid_tags
+        { "datalog_slides" => SlidesTag }
+      end
+
+      def search_indexing(document)
+        key = storage_key(document)
+        state = @storage&.dig(key, :deck)
+        return {} unless state
+
+        {
+          "slides" => {
+            "src" => state["src"],
+            "title" => state["title"],
+            "theme" => state["theme"]
+          }
+        }
+      end
+
+      def render_slides(context)
+        key = (context.registers[:page] || {})["datalog_slides_state"]
+        deck = @storage&.dig(key, :deck)
+        return "" unless deck
+
+        render_slides_markup(deck)
+      end
+
+      private
+
+      def normalize_deck(deck)
+        attributes = case deck
+                     when String
+                       { "src" => deck }
+                     when Hash
+                       deck.transform_keys(&:to_s)
+                     else
+                       {}
+                     end
+
+        return nil if attributes.empty?
+
+        merged = @defaults.merge(attributes)
+        merged["title"] ||= merged["name"] || merged["src"]
+        merged["notes"] ||= attributes["notes"]
+        merged
+      end
+
+      def render_slides_markup(deck)
+        src = deck["src"]
+        return placeholder_markup unless src
+
+        <<~HTML.strip
+          <div class="datalog-slides-embed" data-provider="reveal">
+            <iframe src="#{src}" title="#{deck['title'] || 'Slide deck'}" loading="lazy" allowfullscreen style="width: #{deck['width']}; height: #{deck['height']};"></iframe>
+            <p class="datalog-slides-actions">
+              <a href="#{src}" target="_blank" rel="noopener">Open slides</a>
+              #{cdn_hint(deck)}
+            </p>
+          </div>
+        HTML
+      end
+
+      def cdn_hint(deck)
+        return "" unless deck["cdn"]
+
+        %(<span class="datalog-slides-cdn">Powered by <code>#{deck['cdn']}</code></span>)
+      end
+
+      def placeholder_markup
+        "<div class=\"datalog-slides-embed datalog-slides-embed--missing\">Slides unavailable</div>"
+      end
+
+      def storage_key(document)
+        document.relative_path || document.path
+      end
+
+      def slide_state(key)
+        @storage ||= {}
+        @storage[key] ||= {}
+      end
+    end
+  end
+end

data/lib/datalog/theme/theme.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "jekyll"
+require_relative "theme/version"
+
+module Datalog
+  module Theme
+    class << self
+      def register
+        Jekyll::Hooks.register :site, :after_init do |_site|
+          Jekyll.logger.info "Datalog Theme:", "Loaded version #{VERSION}"
+        end
+      end
+    end
+  end
+end
+
+Datalog::Theme.register

data/lib/datalog/theme/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Datalog
+  module Theme
+    VERSION = "0.6.0" unless const_defined?(:VERSION)
+  end
+end

data/lib/datalog/warning_filter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Datalog
+  module WarningFilter
+    FILTERS = [
+      /literal string will be frozen/,
+      /already initialized constant Datalog::Theme::VERSION/
+    ].freeze
+
+    def warn(message)
+      return if FILTERS.any? { |pattern| pattern.match?(message) }
+
+      super
+    end
+  end
+end
+
+Warning.singleton_class.prepend(Datalog::WarningFilter) if defined?(Warning)
+
+module Kernel
+  alias __datalog_warn warn
+
+  def warn(message = nil, *args)
+    return if message && Datalog::WarningFilter::FILTERS.any? { |pattern| pattern.match?(message) }
+
+    __datalog_warn(message, *args)
+  end
+end

data/lib/datalog-theme.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "datalog/theme/version"
+
+module Datalog
+  module Theme
+    class << self
+      def root
+        @root ||= File.expand_path("..", __dir__)
+      end
+
+      def assets_path
+        File.join(root, "assets")
+      end
+    end
+  end
+end