jekyll-page-asset 0.1.0

data/_lib/page_asset/fountain_renderer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Jekyll
+  module PageAsset
+    class FountainRenderer < Renderer
+      register_type 'fountain'
+
+      def render(context)
+        include_vars = build_include_vars(
+          "script_text" => File.read(@target_asset_path)
+        )
+        render_template(context, include_vars)
+      end
+    end
+  end
+end

data/_lib/page_asset/gallery_renderer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Jekyll
+  module PageAsset
+    class GalleryRenderer < Renderer
+      register_type 'gallery'
+
+      SUPPORTED_IMAGE_EXTENSIONS = %w[.jpg .jpeg .png .webp .avif .gif].freeze
+
+      def render(context)
+        return "" if @target_asset_paths.empty?
+
+        gallery_asset_root = @asset_path_arg
+        images = discover_images(@target_asset_paths)
+        gallery_template = render_template(context, {})
+
+        if images.empty?
+          return empty_state_html(@asset_path_arg) + gallery_template
+        end
+
+        thumbnails = images.each_with_index.map do |filename, index|
+          asset_path = File.join(gallery_asset_root, filename)
+          src = "/#{asset_path}"
+          alt = alt_text_for(filename, index)
+          picture_tag = render_thumbnail(context, asset_path)
+
+          <<~HTML
+            <button
+              class="gallery-thumb"
+              type="button"
+              data-gallery-thumb="true"
+              data-gallery-id="#{html_escape(@asset_path_arg)}"
+              data-gallery-index="#{index}"
+              data-gallery-src="#{html_escape(src)}"
+              data-gallery-alt="#{html_escape(alt)}"
+              aria-label="Open image #{index + 1}">
+              #{picture_tag}
+            </button>
+          HTML
+        end
+
+        <<~HTML + gallery_template
+          <section class="project-gallery" data-gallery="#{html_escape(@asset_path_arg)}" aria-label="Image gallery">
+            <div class="project-gallery-grid">
+              #{thumbnails.join("\n")}
+            </div>
+          </section>
+        HTML
+      end
+
+      private
+
+      def discover_images(paths)
+        paths.select { |entry| SUPPORTED_IMAGE_EXTENSIONS.include?(File.extname(entry).downcase) }
+           .sort_by(&:downcase)
+      end
+
+      def render_thumbnail(context, path)
+        escaped_path = path.gsub('"', '\\"')
+        liquid = "{% picture \"#{escaped_path}\" alt=\"thumbnail\" %}"
+        Liquid::Template.parse(liquid).render(context)
+      end
+
+      def alt_text_for(filename, index)
+        stem = File.basename(filename, File.extname(filename)).tr("_-", " ").strip
+        return "Gallery image #{index + 1}" if stem.empty?
+
+        stem.gsub(/\s+/, " ")
+      end
+
+      def empty_state_html(gallery_id)
+        <<~HTML
+          <section class="project-gallery" data-gallery="#{html_escape(gallery_id)}" aria-label="Image gallery">
+            <p class="project-gallery-empty">No gallery images found.</p>
+          </section>
+        HTML
+      end
+
+      def html_escape(value)
+        CGI.escape_html(value.to_s)
+      end
+    end
+  end
+end
+

data/_lib/page_asset/image_renderer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "base64"
+
+module Jekyll
+  module PageAsset
+    class ImageRenderer < Renderer
+      register_type 'image'
+
+      def render(context)
+        augmented_liquid = "{% picture #{@target_asset_path} #{@rest} %}"
+        Liquid::Template.parse(augmented_liquid).render(context)
+      end
+    end
+  end
+end
+

data/_lib/page_asset/renderer.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module PageAsset
+    class Renderer
+      class << self
+        attr_reader :type
+
+        def type_renderers
+          @type_renderers ||= {}
+        end
+
+        def inherited(subclass)
+          unregistered_subclasses << subclass
+        end
+
+        def unregistered_subclasses
+          @unregistered_subclasses ||= []
+        end
+
+        def register_type(value)
+          @type = value.to_s.strip
+          raise "Render helper #{name} has no registered type" if @type.empty?
+
+          Renderer.type_renderers[@type] = self
+          Renderer.unregistered_subclasses.delete(self)
+        end
+
+        def assert_all_registered!
+          missing = unregistered_subclasses.reject { |klass| klass == self }
+          return if missing.empty?
+
+          names = missing.map { |klass| klass.name || klass.to_s }.sort.join(", ")
+          raise "PageAsset helpers need to register a type. Check subclass(es): #{names}"
+        end
+
+        def new_by_type(type:, asset_path_arg:, rest:, params:)
+          renderer = type_renderers[type.to_s] || self
+          renderer.new(
+            type: type,
+            asset_path_arg: asset_path_arg,
+            rest: rest,
+            params: params
+          )
+        end
+      end
+
+      def initialize(type:, asset_path_arg:, rest:, params: )
+        @type = type.to_s
+        @asset_path_arg = asset_path_arg
+        @target_asset_paths = target_asset_paths(asset_path_arg)
+        @target_asset_path = @target_asset_paths[0]
+        @rest = rest.to_s
+        @params = params || {}
+      end
+
+      def render(context)
+        include_vars = build_include_vars
+        render_template(context, include_vars)
+      end
+
+      protected
+
+
+      def target_asset_paths(target)
+        if File.file?(target)
+          [target]
+        elsif File.directory?(target)
+          Dir.children(target)
+           .select { |entry| File.file?(File.join(target, entry)) }
+           .sort_by(&:downcase)
+        else
+          # assume the path includes a tag and pass it. This may cause issues
+          raise 'target page_asset file not found'
+        end
+      end
+
+      def build_include_vars(extra={})
+        {
+          "asset_paths" => @target_asset_paths,
+          "asset_path" => @target_asset_path,
+          "rest" => @rest,
+          "params" => @params,
+      }.merge(extra)
+      end
+
+      def load_template(context)
+        site = context.registers[:site]
+        include_path = File.join(site.source, "_includes", "page_asset", "#{@type}.html")
+
+        unless File.exist?(include_path)
+          gem_include_path = File.expand_path("../../_includes/page_asset/#{@type}.html", __dir__)
+          include_path = gem_include_path if File.exist?(gem_include_path)
+        end
+
+        unless File.exist?(include_path)
+          raise IOError, "page_asset: include file not found at #{include_path}"
+        end
+
+        Liquid::Template.parse(File.read(include_path))
+      end
+
+      def render_template(context, include_vars)
+        template = load_template(context)
+        context.stack do
+          context["include"] = include_vars
+          template.render(context)
+        end
+      end
+
+    end
+  end
+end

data/_lib/page_asset/scroll_scrub_video_renderer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module PageAsset
+    class ScrollScrubVideoRenderer < Renderer
+      register_type 'scroll_scrub_video'
+
+      DEFAULTS = {
+        "pixels_per_second" => 50,
+        "sticky_top" => 120
+      }.freeze
+
+      def render(context)
+        include_vars = build_include_vars({
+          "video_path"        => @target_asset_path,
+          "pixels_per_second" => (@params["pixels_per_second"] || DEFAULTS["pixels_per_second"]).to_i,
+          "sticky_top"        => (@params["sticky_top"] || DEFAULTS["sticky_top"]).to_i
+        })
+
+        render_template(context, include_vars)
+      end
+    end
+  end
+end

data/_lib/page_asset/video_renderer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Jekyll
+  module PageAsset
+    class VideoRenderer < Renderer
+      register_type "video"
+
+      DISPLAY_BACKGROUND = "background"
+      DISPLAY_FOREGROUND = "foreground"
+
+      def render(context)
+        video_path =  @target_asset_path
+
+        display = normalized_display(@params["display"])
+        classes = display == DISPLAY_BACKGROUND ? "background-video" : "foreground-video"
+        playback_attrs = display == DISPLAY_BACKGROUND ? "autoplay muted loop playsinline" : "controls playsinline"
+
+        <<~HTML
+          <video #{playback_attrs} preload="auto" class="#{classes}">
+            <source src="/#{html_escape(video_path)}" type="#{html_escape(mime_type_for(video_path))}">
+            Your browser does not support the video tag.
+          </video>
+        HTML
+      end
+
+      private
+
+      def normalized_display(value)
+        normalized = value.to_s.strip.downcase
+        return DISPLAY_BACKGROUND if normalized == DISPLAY_BACKGROUND
+
+        DISPLAY_FOREGROUND
+      end
+
+      def mime_type_for(path)
+        case File.extname(path).downcase
+        when ".webm"
+          "video/webm"
+        when ".ogv"
+          "video/ogg"
+        else
+          "video/mp4"
+        end
+      end
+
+      def html_escape(value)
+        CGI.escape_html(value.to_s)
+      end
+    end
+  end
+end

data/_plugins/page_asset.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "../_lib/page_asset/renderer"
+
+Dir[File.join(__dir__, "../_lib","page_asset", "*_renderer.rb")].sort.each do |renderer_file|
+  require renderer_file
+end
+
+Jekyll::PageAsset::Renderer.assert_all_registered!
+
+module Jekyll
+  module PageAsset
+    module TagHelpers
+      private
+
+      def parse_tag_markup(markup, context)
+        normalized_markup = markup.to_s.strip
+        return [nil, nil, "", {}] if normalized_markup.empty?
+
+        # expand {{tags}}
+        normalized_markup = normalized_markup.gsub(/\{\{\s*([^}]+)\s*\}\}/) do
+          variable_path = $1.strip
+          # Dynamically lookup the variable in Jekyll's context hierarchy
+          context[variable_path].to_s
+        end
+
+        type, target, rest = normalized_markup.split(/\s+/, 3)
+        rest ||= ""
+
+        params = {}
+        rest.scan(/(\w+)=(?:'([^']*)'|"([^"]*)"|(\S+))/) do |key, sq, dq, bare|
+          params[key] = sq || dq || bare
+        end
+
+        [type, target, rest, params]
+      end
+
+      def tag_site(context)
+        context.registers[:site]
+      end
+
+      def tag_page(context)
+        context.registers[:page]
+      end
+
+      def project_slug_from_context(context)
+        page = tag_page(context)
+        page_url = page["url"] || page.url
+        page_url.to_s.split("/").reject(&:empty?).last
+      end
+
+      def page_asset_root
+        Jekyll.configuration.dig("page_asset", "asset_root") || "assets/project_media"
+      end
+
+      def page_asset_relative_path(context, *segments)
+        project_slug = project_slug_from_context(context)
+        return nil if project_slug.nil? || project_slug.empty?
+
+        File.join(page_asset_root, project_slug, *segments.compact)
+      end
+
+      def page_asset_source_path(context, *segments)
+        relative_path = page_asset_relative_path(context, *segments)
+        return nil if relative_path.nil?
+
+        File.join(tag_site(context).source, relative_path)
+      end
+    end
+
+    class PageAssetTag < Liquid::Tag
+      include TagHelpers
+
+      def initialize(tag_name, markup, options)
+        super
+        @markup = markup
+      end
+
+      def render(context)
+        # Split the markup into file name and opts.
+        @type, @target, @rest, @params = parse_tag_markup(@markup, context)
+        full_target_path = page_asset_relative_path(context, @target)
+        return "" if full_target_path.nil? || full_target_path.empty?
+
+        renderer = PageAsset::Renderer.new_by_type(
+          type: @type,
+          asset_path_arg: full_target_path,
+          rest: @rest,
+          params: @params
+        )
+        ren = renderer.render(context)
+
+        <<~HTML
+          <div class="page-asset-container">
+            #{ren}
+          </div>
+        HTML
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag("page_asset", Jekyll::PageAsset::PageAssetTag)