jekyll_plugin_template 0.1.3

data/lib/dumpers.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+# Methods to display Jekyll variable contents
+module Dumpers
+  # See https://github.com/jekyll/jekyll/blob/master/lib/jekyll/collection.rb
+  #   attr_reader :site, :label, :metadata
+  #   attr_writer :docs
+  #   Metadata is a hash with at least these keys: output[Boolean], permalink[String]
+  #   selected methods: collection_dir, directory, entries, exists?, files, filtered_entries, relative_directory
+  def collection_as_string(collection, indent_spaces)
+    indent = " " * indent_spaces
+    result = <<~END_COLLECTION
+      '#{collection.label}' collection within '#{collection.relative_directory}' subdirectory
+        #{indent}Directory: #{collection.directory}
+        #{indent}Does the directory exist and is it not a symlink if in safe mode? #{collection.exists?}
+        #{indent}Collection_dir: #{collection.collection_dir}
+        #{indent}Metadata: #{collection.metadata}
+        #{indent}Static files: #{collection.files}
+        #{indent}Filtered entries: #{collection.filtered_entries}
+    END_COLLECTION
+    result.chomp
+  end
+
+  def count_lines(string)
+    return string.split("\n").length if string
+
+    0
+  end
+
+  # Calling value.to_s blows up when a Jekyll::Excerpt
+  # Error message is unrelated to the problem, makes it hard to track down
+  # Be careful when converting values to string!
+  def safe_to_s(value)
+    return value.content if value.is_a? Jekyll::Excerpt
+
+    value.to_s
+  rescue StandardError => e
+    e.message
+  end
+
+  # @param msg[String]
+  # @param document[Jekyll:Document] https://github.com/jekyll/jekyll/blob/master/lib/jekyll/document.rb
+  #   attr_reader :path, :extname, :collection, :type; :site is too big to dump here, we already have it anyway
+  #   Selected methods: date
+  def dump_document(logger, msg, document)
+    attributes = attributes_as_string(document, [:@path, :@extname, :@type])
+    data = document.data.map { |k, v| "    #{k} = #{safe_to_s(v)}" }
+    logger.info do
+      <<~END_DOC
+        #{msg}
+          document dated #{document.date.to_date}:
+            relative_path: #{document.relative_path}:
+        #{attributes.join("\n")}
+            Is it a draft? #{document.draft?}
+            collection = #{collection_as_string(document.collection, 4)}
+            content not dumped because it would likely be too long
+            site not dumped also
+            data:
+          #{data.join("\n  ").rstrip.chomp}
+      END_DOC
+    end
+  end
+
+  # @param msg[String]
+  # @param page[Jekyll:Page] https://github.com/jekyll/jekyll/blob/master/lib/jekyll/page.rb
+  #   attr_accessor :basename, :content, :data, :ext, :name, :output, :pager, :site
+  #   Selected methods: dir, excerpt, path, permalink, url
+  def dump_page(logger, msg, page)
+    attributes = attributes_as_string(page, [:@basename, :@ext, :@name])
+    # site = page.site available if you need it
+    data = page.data.map { |k, v| "    #{k} = #{v}" }
+    logger.info do
+      <<~END_PAGE
+        #{msg}\n  page at #{page.dir}:
+        #{attributes.join("\n")}
+            Is it HTML? #{page.html?}; is it an index? #{page.index?}
+            Permalink: #{page.permalink}
+            URL: #{page.url}
+            content not dumped because it would likely be too long
+            site not dumped also
+            Excerpt: "#{page.excerpt}"
+          data:
+        #{data.join("\n")}
+      END_PAGE
+    end
+  end
+
+  # @param msg[String]
+  # @param payload[Jekyll::Drops::UnifiedPayloadDrop] See https://github.com/jekyll/jekyll/blob/master/lib/jekyll/drops/unified_payload_drop.rb
+  #    This is a mutable class.
+  #    attr_accessor :content, :page, :layout, :paginator, :highlighter_prefix, :highlighter_suffix
+  # payload.page is a Jekyll::Drops::DocumentDrop, which contains this payload,
+  # see https://github.com/jekyll/jekyll/blob/master/lib/jekyll/drops/document_drop.rb
+  def dump_payload(logger, msg, payload)
+    result = <<~END_INFO
+      #{msg} payload:
+        content contains #{count_lines(payload.content)} lines.#{first_5_lines(payload.content)}
+        layout = #{payload.layout}
+        highlighter_prefix = #{payload.highlighter_prefix}
+        paginator and site not dumped.
+    END_INFO
+    logger.info { result.chomp }
+  end
+
+  def first_5_lines(string)
+    lines = string ? string.split("\n")[0..4] : []
+    return "\n    first 5 lines:\n    #{lines.join("\n    ")}\n" if lines.length.positive?
+
+    ""
+  end
+
+  # @param msg[String]
+  # @param site[Jekyll::Site] https://github.com/jekyll/jekyll/blob/master/lib/jekyll/site.rb
+  #   attr_accessor :baseurl, :converters, :data, :drafts, :exclude,
+  #     :file_read_opts, :future, :gems, :generators, :highlighter,
+  #     :include, :inclusions, :keep_files, :layouts, :limit_posts,
+  #     :lsi, :pages, :permalink_style, :plugin_manager, :plugins,
+  #     :reader, :safe, :show_drafts, :static_files, :theme, :time,
+  #     :unpublished
+  #   attr_reader :cache_dir, :config, :dest, :filter_cache, :includes_load_paths,
+  #     :liquid_renderer, :profiler, :regenerator, :source
+  def dump_site(logger, msg, site) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    logger.info do
+      <<~END_INFO
+        #{msg} site
+        site is of type #{site.class}
+        site.time = #{site.time}
+      END_INFO
+    end
+    env = site.config['env']
+    if env
+      mode = env['JEKYLL_ENV']
+      logger.info { "site.config['env']['JEKYLL_ENV'] = #{mode}" }
+    else
+      logger.info { "site.config['env'] is undefined" }
+    end
+    site.collections.each do |key, _|
+      logger.info { "site.collections.#{key}" }
+    end
+
+    # key env contains all environment variables, quite verbose so output is reduced to just the "env" key
+    logger.info { "site.config has #{site.config.length} entries:" }
+    site.config.sort.each { |key, value| logger.info { "  site.config.#{key} = '#{value}'" unless key == "env" } }
+
+    logger.info { "site.data has #{site.data.length} entries:" }
+    site.data.sort.each { |key, value| logger.info { "  site.data.#{key} = '#{value}'" } }
+
+    logger.info { "site.documents has #{site.documents.length} entries." }
+    site.documents.each { |key, _value| logger.info "site.documents.#{key}" }
+
+    logger.info do
+      <<~END_INFO
+        site.keep_files has #{site.keep_files.length} entries.
+        site.keep_files: #{site.keep_files.sort}
+        site.pages has #{site.pages.length} entries.
+      END_INFO
+    end
+
+    site.pages.each { |key, _value| logger.info "site.pages.#{key}" }
+
+    logger.info { "site.posts has #{site.posts.docs.length} entries." }
+    site.posts.docs.each { |key, _value| logger.info "site.posts.docs.#{key}" }
+
+    logger.info { "site.tags has #{site.tags.length} entries." }
+    site.tags.sort.each { |key, value| logger.info { "site.tags.#{key} = '#{value}'" } }
+  end
+
+  def attributes_as_string(object, attrs)
+    attrs.map { |attr| "    #{attr.to_s.delete_prefix("@")} = #{object.instance_variable_get(attr)}" }
+  end
+
+  module_function :attributes_as_string, :collection_as_string, :count_lines, :dump_document, :dump_page,
+                  :dump_payload, :dump_site, :first_5_lines, :safe_to_s
+end

data/lib/jekyll_block_tag_plugin.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "jekyll_plugin_logger"
+require "key_value_parser"
+require "shellwords"
+
+module JekyllPluginBlockTagTemplate
+  PLUGIN_NAME = "block_tag_template"
+end
+
+# This is the module-level description.
+#
+# @example Heading for this example
+#   Describe what this example does
+#   {% block_tag_template "parameter" %}
+#     Hello, world!
+#   {% endblock_tag_template %}
+#
+# The Jekyll log level defaults to :info, which means all the Jekyll.logger statements below will not generate output.
+# You can control the log level when you start Jekyll.
+# To set the log level to :debug, write an entery into _config.yml, like this:
+# plugin_loggers:
+#   MyBlock: debug
+
+module JekyllBlockTagPlugin
+  # This class implements the Jekyll block tag functionality
+  class MyBlock < Liquid::Block
+    # See https://github.com/Shopify/liquid/wiki/Liquid-for-Programmers#create-your-own-tags
+    # @param tag_name [String] the name of the tag, which we already know.
+    # @param argument_string [String] the arguments from the tag, as a single string.
+    # @param _parse_context [Liquid::ParseContext] hash that stores Liquid options.
+    #        By default it has two keys: :locale and :line_numbers, the first is a Liquid::I18n object, and the second,
+    #        a boolean parameter that determines if error messages should display the line number the error occurred.
+    #        This argument is used mostly to display localized error messages on Liquid built-in Tags and Filters.
+    #        See https://github.com/Shopify/liquid/wiki/Liquid-for-Programmers#create-your-own-tags
+    # @return [void]
+    def initialize(tag_name, argument_string, parse_context) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      super
+      @logger = PluginMetaLogger.instance.new_logger(self, PluginMetaLogger.instance.config)
+
+      @argument_string = argument_string
+
+      argv = Shellwords.split(argument_string) # Scans name/value arguments
+      params = KeyValueParser.new.parse(argv) # Extracts key/value pairs, default value for non-existant keys is nil
+      @param1 = params[:param1] # Obtain the value of parameter param1
+      @param2 = params[:param2]
+      @param3 = params[:param3]
+      @param4 = params[:param4]
+      @param5 = params[:param5]
+      @param_x = params[:not_present] # The value of parameters that are present is nil, but displays as the empty string
+
+      @logger.debug do
+        <<~HEREDOC
+          tag_name = '#{tag_name}'
+          argument_string = '#{argument_string}'
+          @param1 = '#{@param1}'
+          @param2 = '#{@param2}'
+          @param3 = '#{@param3}'
+          @param4 = '#{@param4}'
+          @param5 = '#{@param5}'
+          @param_x = '#{@param_x}'
+          params =
+            #{params.map { |k, v| "#{k} = #{v}" }.join("\n  ")}
+        HEREDOC
+      end
+    end
+
+    REJECTED_ATTRIBUTES = %w[content excerpt next previous].freeze
+
+    # Method prescribed by the Jekyll plugin lifecycle.
+    # @param liquid_context [Liquid::Context]
+    # @return [String]
+    def render(liquid_context) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      content = super # This underdocumented assignment returns the text within the block.
+
+      @site = liquid_context.registers[:site]
+      @config = @site.config
+      @mode = @config.dig("env", "JEKYLL_ENV") || "development"
+
+      # variables defined in pages are stored as hash values in liquid_context
+      _assigned_page_variable = liquid_context['assigned_page_variable']
+
+      # The names of front matter variables are hash keys for @page
+      @page = liquid_context.registers[:page] # @page is a Jekyll::Drops::DocumentDrop
+      # layout = @page['layout']
+
+      @envs = liquid_context.environments.first
+      @layout_hash = @envs['layout']
+
+      @logger.debug do
+        <<~HEREDOC
+          liquid_context.scopes=#{liquid_context.scopes}
+          mode="#{@mode}"
+          page attributes:
+            #{@page.sort
+                   .reject { |k, _| REJECTED_ATTRIBUTES.include? k }
+                   .map { |k, v| "#{k}=#{v}" }
+                   .join("\n  ")}
+        HEREDOC
+      end
+
+      # Compute the return value of this Jekyll tag
+      <<~HEREDOC
+        <p style="color: green; background-color: yellow; padding: 1em; border: solid thin grey;">
+          #{content} #{@param1}
+        </p>
+      HEREDOC
+    end
+  end
+end
+
+PluginMetaLogger.instance.info { "Loaded #{JekyllPluginBlockTagTemplate::PLUGIN_NAME} v#{JekyllPluginTemplateVersion::VERSION} plugin." }
+Liquid::Template.register_tag(JekyllPluginBlockTagTemplate::PLUGIN_NAME, JekyllBlockTagPlugin::MyBlock)

data/lib/jekyll_filter_template.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "jekyll_plugin_logger"
+
+# @author Copyright 2020 {https://www.mslinn.com Michael Slinn}
+# Template for Jekyll filters.
+module JekyllFilterTemplate
+  class << self
+    attr_accessor :logger
+  end
+  self.logger = PluginMetaLogger.instance.new_logger(self, PluginMetaLogger.instance.config)
+
+  # This Jekyll filter returns the URL to search Google for the contents of the input string.
+  # @param input_string [String].
+  # @return [String] empty string if input_string has no contents except whitespace.
+  # @example Use.
+  #   {{ "joy" | my_filter_template }} => <a href='https://www.google.com/search?q=joy' target='_blank' rel='nofollow'>joy</a>
+  def my_filter_template(input_string)
+    # @context[Liquid::Context] is available here to look up variables defined in front matter, templates, page, etc.
+
+    JekyllFilterTemplate.logger.debug do
+      "Defined filters are: " + self.class # rubocop:disable Style/StringConcatenation
+                                    .class_variable_get('@@global_strainer')
+                                    .filter_methods.instance_variable_get('@hash')
+                                    .map { |k, _v| k }
+                                    .sort
+    end
+
+    input_string.strip!
+    JekyllFilterTemplate.logger.debug "input_string=#{input_string}"
+    if input_string.empty?
+      ""
+    else
+      "<a href='https://www.google.com/search?q=#{input_string}' target='_blank' rel='nofollow'>#{input_string}</a>"
+    end
+  end
+
+  PluginMetaLogger.instance.logger.info { "Loaded JekyllFilterTemplate v#{JekyllPluginTemplateVersion::VERSION} plugin." }
+end
+
+Liquid::Template.register_filter(JekyllFilterTemplate)

data/lib/jekyll_hook_examples.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/inflector"
+require 'confidential_info_redactor'
+require "nokogiri"
+require "talk_like_a_pirate"
+
+# Sample Jekyll Hook plugins
+module JekyllHookExamples
+  def modify_output
+    proc do |webpage|
+      webpage.output.gsub!('Jekyll', 'Awesome Jekyll')
+    end
+  end
+
+  def pirate_translator
+    proc do |webpage|
+      next unless webpage.data['pirate_talk']
+
+      html = Nokogiri.HTML(webpage.output)
+      html.css("p").each do |node|
+        node.content = TalkLikeAPirate.translate(node.content)
+      end
+      webpage.output = html
+    end
+  end
+
+  def redact
+    proc do |webpage|
+      next unless webpage.data['redact']
+
+      webpage.content = redact_all webpage.content
+    end
+  end
+
+  def wrap(text)
+    "<span style='background-color: black; color: white; padding: 3pt;'>redacted#{text}</span>"
+  end
+
+  # See https://github.com/diasks2/confidential_info_redactor
+  # Does not handle HTML markeup properly.
+  def redact_all(content)
+    tokens = ConfidentialInfoRedactor::Extractor.new.extract(content)
+    ConfidentialInfoRedactor::Redactor.new(
+      number_text: wrap(" number"), # This redactor is over-eager
+      date_text: wrap(" date"),
+      token_text: wrap(""),
+      tokens: tokens
+    ).redact(content)
+  end
+
+  module_function :modify_output, :pirate_translator, :redact, :redact_all, :wrap
+
+  # Uncomment the following lines, rebuild the plugin and view http://localhost:4444/
+  # to see these hooks in action:
+  #
+  # Convert "Jekyll" to "Awesome Jekyll"
+  # Jekyll::Hooks.register(:documents, :post_render, &modify_output)
+  # Jekyll::Hooks.register(:pages, :post_render, &modify_output)
+
+  # Convert "English" to "Pirate Talk"
+  Jekyll::Hooks.register(:documents, :post_render, &pirate_translator)
+  Jekyll::Hooks.register(:pages, :post_render, &pirate_translator)
+
+  # Automatically redacts potentially sensitive information in selected pages
+  # See https://github.com/diasks2/confidential_info_redactor
+  Jekyll::Hooks.register(:documents, :pre_render, &redact)
+  Jekyll::Hooks.register(:pages, :pre_render, &redact)
+
+  PluginMetaLogger.instance.logger.info { "Loaded JekyllHookExamples v#{JekyllPluginTemplateVersion::VERSION} plugin." }
+end

data/lib/jekyll_hooks.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "jekyll_plugin_logger"
+require_relative "jekyll_plugin_template/version"
+require_relative "dumpers"
+
+module JekyllPluginHooksName
+  PLUGIN_NAME = "jekyll_plugin_hooks"
+end
+
+# The Jekyll processing steps are described in https://jekyllrb.com/tutorials/orderofinterpretation/
+#
+# The Jekyll log level defaults to :info, which means all the Jekyll.logger statements below will not generate output.
+# You can control the log level when you start Jekyll.
+# To set the log level to :debug, write an entery into _config.yml, like this:
+# plugin_loggers:
+#   JekyllPluginHooks: debug
+#
+# Jekyll::Hooks.register accepts an optional parameter:
+#   :priority determines the load order for the hook plugins.
+#     Valid values are: :lowest, :low, :normal, :high, and :highest.
+#     Highest priority matches are applied first, lowest priority are applied last.
+#     The default value is :normal
+#
+# Each hook, except the clean hook, can set a boolean flag, called `site.safe`, that informs Jekyll if this plugin may be safely executed in an environment
+# where arbitrary code execution is not allowed. This is used by GitHub Pages to determine which
+# core plugins may be used, and which are unsafe to run. If your plugin does not allow for arbitrary
+# code execution, set this to true. GitHub Pages still will not load your plugin, but if you submit it
+# for inclusion in core, it is best for this to be correct!
+# Default value is false.
+# The hooks for pages, posts and documents access safe via pages.site.safe, posts.site.safe and documents.site.safe, respectively.
+module JekyllPluginHooks
+  ########## :site hooks
+  # These hooks influence the entire site
+
+  # Called just after the site resets during regeneration
+  # This is the first hook called, so you might think that this is the best place to define loggers.
+  # However, this hook will not be called unless safe mode is OFF, so define loggers in the :site :after_init hook instead
+  Jekyll::Hooks.register(:site, :after_reset, priority: :normal) do |site|
+    @log_site ||= PluginMetaLogger.instance.new_logger(:SiteHooks, PluginMetaLogger.instance.config)
+    @log_site.info { "Jekyll::Hooks.register(:site, :after_reset) invoked." }
+    Dumpers.dump_site(@log_site, "Jekyll::Hooks.register(:site, :after_reset)", site)
+  end
+
+  # This hook is called just after the site initializes.
+  # It is a good place to modify the configuration of the site.
+  # This hook is triggered once per build / serve session.
+  Jekyll::Hooks.register(:site, :after_init, priority: :normal) do |site|
+    @log_clean = PluginMetaLogger.instance.new_logger(:CleanHook,     PluginMetaLogger.instance.config)
+    @log_docs  = PluginMetaLogger.instance.new_logger(:DocumentHooks, PluginMetaLogger.instance.config)
+    @log_pages = PluginMetaLogger.instance.new_logger(:PageHooks,     PluginMetaLogger.instance.config)
+    @log_posts = PluginMetaLogger.instance.new_logger(:PostHooks,     PluginMetaLogger.instance.config)
+    @log_site  ||= PluginMetaLogger.instance.new_logger(:SiteHooks,   PluginMetaLogger.instance.config)
+
+    @log_site.info { "Loaded #{JekyllPluginHooksName::PLUGIN_NAME} v#{JekyllPluginTemplate::VERSION} plugin." }
+    @log_site.info { "Jekyll::Hooks.register(:site, :after_init) invoked." }
+    Dumpers.dump_site(@log_site, "Jekyll::Hooks.register(:site, :after_init)", site)
+  end
+
+  # Called after all source files have been read and loaded from disk.
+  # This is a good hook for enriching posts;
+  # for example, adding links to author pages or adding posts to author pages.
+  Jekyll::Hooks.register(:site, :post_read, priority: :normal) do |site|
+    @log_site.info { "Jekyll::Hooks.register(:site, :post_read) invoked." }
+    Dumpers.dump_site(@log_site, "Jekyll::Hooks.register(:site, :post_read)", site)
+  end
+
+  # Called before rendering the whole site
+  # This is the first hook in the site generation sequence where site['env'] has a value.
+  # Consequently, this is the first hook that defines mode (production, development or test),
+  # because it is derived from site['env']['JEKYLL_ENV']
+  # @param payload [Hash] according to the docs, payload is a hash containing the variables available during rendering; the hash can be modified here.
+  # However, the debugger shows payload has type Jekyll::UnifiedPayloadDrop
+  Jekyll::Hooks.register(:site, :pre_render, priority: :normal) do |site, payload|
+    @log_site.info { "Jekyll::Hooks.register(:site, :pre_render) invoked." }
+    @log_site.debug { dump(":site, :pre_render payload", payload) }
+    Dumpers.dump_site(@log_site, "Jekyll::Hooks.register(:site, :pre_render)", site)
+    Dumpers.dump_payload(@log_site, "Jekyll::Hooks.register(:site, :pre_render)", payload)
+  end
+
+  # Called after rendering the whole site, but before writing any files.
+  # Functionally, this hook is exactly the same as a Jekyll generator.
+  # This hook is also similar to invoking the same method on the :post_render hooks for :documents and :pages:
+  #   Jekyll::Hooks.register(:documents, :post_render, &my_method)
+  #   Jekyll::Hooks.register(:pages, :post_render, &my_method)
+  # ... with the difference that this hook will be called only once, for the entire site, so you will have to iterate over all of the
+  # :documents and :pages, whereas the :pages and :documents hooks are called once for each page and document.
+  # @param payload [Hash] contains final values of variables after rendering the entire site (useful for sitemaps, feeds, etc).
+  Jekyll::Hooks.register(:site, :post_render, priority: :normal) do |site, payload|
+    @log_site.info { "Jekyll::Hooks.register(:site, :post_render) invoked." }
+    @log_site.debug { dump(":site, :post_render payload", payload) }
+    Dumpers.dump_site(@log_site, "Jekyll::Hooks.register(:site, :post_render)", site)
+    Dumpers.dump_payload(@log_site, "Jekyll::Hooks.register(:site, :post_render)", payload)
+  end
+
+  # Called after writing all of the rendered files to disk
+  Jekyll::Hooks.register(:site, :post_write, priority: :normal) do |site|
+    @log_site.info { "Jekyll::Hooks.register(:site, :post_write) invoked." }
+    Dumpers.dump_site(@log_site, "Jekyll::Hooks.register(:site, :post_write)", site)
+  end
+
+  ########## :pages hooks
+  # Pages are web pages that do not belong to a collection, such as posts or drafts.
+  # These hooks provide fine-grained control over all pages in the site.
+
+  # Called whenever a page is initialized
+  Jekyll::Hooks.register(:pages, :post_init, priority: :normal) do |page|
+    @log_pages.info { "Jekyll::Hooks.register(:pages, :post_init) invoked." }
+    Dumpers.dump_page(@log_pages, "Jekyll::Hooks.register(:pages, :post_init)", page)
+  end
+
+  # Called just before rendering a page
+  Jekyll::Hooks.register(:pages, :pre_render, priority: :normal) do |page, payload|
+    @log_pages.info { "Jekyll::Hooks.register(:pages, :pre_render) invoked." }
+    Dumpers.dump_page(@log_pages, "Jekyll::Hooks.register(:pages, :pre_render)", page)
+    Dumpers.dump_payload(@log_pages, ":pages, :pre_render payload", payload)
+  end
+
+  # Called after converting the page content, but before rendering the page layout
+  Jekyll::Hooks.register(:pages, :post_convert, priority: :normal) do |page|
+    @log_pages.info { "Jekyll::Hooks.register(:pages, :post_convert) invoked." }
+    Dumpers.dump_page(@log_pages, "Jekyll::Hooks.register(:pages, :post_convert)", page)
+  end
+
+  # Called after rendering a page, but before writing it to disk
+  Jekyll::Hooks.register(:pages, :post_render, priority: :normal) do |page|
+    page.site.safe = true
+    @log_pages.info { "Jekyll::Hooks.register(:pages, :post_render) invoked." }
+    Dumpers.dump_page(@log_pages, "Jekyll::Hooks.register(:pages, :post_render)", page)
+  end
+
+  # Called after writing a page to disk
+  Jekyll::Hooks.register(:pages, :post_write, priority: :normal) do |page|
+    @log_pages.info { "Jekyll::Hooks.register(:pages, :post_write) invoked." }
+    Dumpers.dump_page(@log_pages, "Jekyll::Hooks.register(:pages, :post_write)", page)
+  end
+
+  ########## :documents hooks
+  # Documents are web pages that belong to a collection, for example posts, drafts and custom collections.
+  # These hooks provide fine-grained control over all documents in the site.
+  # If you want to inspect or process all collections in the same way, use these hooks.
+  # If you just want to process a custom collection, use these hooks and filter out the documents
+  # that do not belong to that collection.
+
+  # Called whenever any document is initialized.
+  # Front matter data will not have been assigned yet to documents when this hook is invoked, for example:
+  #   categories, description, last_modified_at, tags, title, and slug;
+  # other document attributes that are not yet ready when this hook is invoked include
+  # excerpt and ext (file extension).
+  # The collection attribute will be set properly for this hook.
+  Jekyll::Hooks.register(:documents, :post_init, priority: :normal) do |document|
+    @log_docs.info { "Jekyll::Hooks.register(:documents, :post_init) invoked." }
+    Dumpers.dump_document(@log_docs, "Jekyll::Hooks.register(:documents, :post_init)", document)
+    "stop"
+  end
+
+  # Called just before rendering a document.
+  # Front matter data will have been assigned when this hook is invoked.
+  # Liquid variables are still embedded in the content.
+  # If the document contains markdown (or some other markup),
+  # it will not have been converted to HTML (or whatever the target format is) yet.
+  Jekyll::Hooks.register(:documents, :pre_render, priority: :normal) do |document, payload|
+    @log_docs.info { "Jekyll::Hooks.register(:documents, :pre_render) invoked." }
+    Dumpers.dump_document(@log_docs, "Jekyll::Hooks.register(:documents, :pre_render)", document)
+    Dumpers.dump_payload(@log_docs, ":documents, :pre_render payload", payload)
+  end
+
+  # Called after converting the document content to HTML (or whatever),
+  # but before rendering the document using the layout.
+  Jekyll::Hooks.register(:documents, :post_convert, priority: :normal) do |document|
+    @log_docs.info { "Jekyll::Hooks.register(:documents, :post_convert) invoked." }
+    Dumpers.dump_document(@log_docs, "Jekyll::Hooks.register(:documents, :post_convert)", document)
+  end
+
+  # Called after rendering a document using the layout, but before writing it to disk.
+  # This is your last chance to modify the content.
+  Jekyll::Hooks.register(:documents, :post_render, priority: :normal) do |document|
+    @log_docs.info { "Jekyll::Hooks.register(:documents, :post_render) invoked." }
+    Dumpers.dump_document(@log_docs, "Jekyll::Hooks.register(:documents, :post_render)", document)
+  end
+
+  # Called after writing a document to disk.
+  # Useful for statistics regarding completed renderings.
+  Jekyll::Hooks.register(:documents, :post_write, priority: :normal) do |document|
+    @log_docs.info { "Jekyll::Hooks.register(:documents, :post_write) invoked." }
+    Dumpers.dump_document(@log_docs, "Jekyll::Hooks.register(:documents, :post_write)", document)
+  end
+
+  ########## :posts hooks
+  # These hooks provide fine-grained control over all posts **and drafts** in the site without affecting
+  # documents in user-defined collections
+
+  # Called whenever any post is initialized
+  Jekyll::Hooks.register(:posts, :post_init, priority: :normal) do |post|
+    @log_posts.info { "Jekyll::Hooks.register(:posts, :post_init) invoked." }
+    Dumpers.dump_document(@log_posts, "Jekyll::Hooks.register(:posts, :post_init)", post)
+  end
+
+  # Called just before rendering a post
+  Jekyll::Hooks.register(:posts, :pre_render, priority: :normal) do |post, payload|
+    # post is a Jekyll::Document
+    @log_posts.info { "Jekyll::Hooks.register(:posts, :pre_render) invoked." }
+    Dumpers.dump_document(@log_posts, "Jekyll::Hooks.register(:posts, :pre_render)", post)
+    Dumpers.dump_payload(@log_posts, ":posts, :pre_render payload", payload)
+  end
+
+  # Called after converting the post content, but before rendering the post layout.
+  # This hook can be used to make edits to rendered pages,
+  # regardless of whether they were originally written in markdown or HTML.
+  #
+  # Changes must modify post.output, as shown in this example:
+  #   Jekyll::Hooks.register(:posts, :post_convert) do |post|
+  #     post.output.gsub!('programming PHP', 'banging rocks together')
+  #   end
+  Jekyll::Hooks.register(:posts, :post_convert, priority: :normal) do |post|
+    @log_posts.info { "Jekyll::Hooks.register(:posts, :post_convert) invoked." }
+    Dumpers.dump_document(@log_posts, "Jekyll::Hooks.register(:posts, :post_convert)", post)
+  end
+
+  # Called after rendering a post, but before writing it to disk.
+  # Changing `post.conent` has no effect on visible output.
+  Jekyll::Hooks.register(:posts, :post_render, priority: :normal) do |post|
+    @log_posts.info { "Jekyll::Hooks.register(:posts, :post_render) invoked." }
+    Dumpers.dump_document(@log_posts, "Jekyll::Hooks.register(:posts, :post_render)", post)
+  end
+
+  # Called after writing a post to disk
+  Jekyll::Hooks.register(:posts, :post_write, priority: :normal) do |post|
+    @log_posts.info { "Jekyll::Hooks.register(:posts, :post_write) invoked." }
+    Dumpers.dump_document(@log_posts, "Jekyll::Hooks.register(:posts, :post_write)", post)
+  end
+
+  ########## :clean hooks
+  # These hooks provide fine-grained control on the list of obsolete files determined
+  # to be deleted during the site's cleanup phase.
+
+  # Called during the cleanup of a site's destination, before the site is built
+  Jekyll::Hooks.register(:clean, :on_obsolete, priority: :normal) do |files|
+    # files has type Array[String]
+    @log_clean.info { "Jekyll::Hooks.register(:clean, :on_obsolete) invoked for #{files}." }
+  end
+end

data/lib/jekyll_plugin_template/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JekyllPluginTemplateVersion
+  VERSION = "0.1.3"
+end

data/lib/jekyll_plugin_template.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "jekyll"
+require "jekyll_plugin_logger"
+require_relative "jekyll_plugin_template/version"
+require_relative "jekyll_block_tag_plugin"
+require_relative "jekyll_filter_template"
+require_relative "jekyll_tag_plugin"
+require_relative "jekyll_hooks"
+require_relative "jekyll_hook_examples"
+require_relative "category_index_generator"
+require_relative "category_combiner"
+
+module JekyllPluginTemplate
+  include JekyllBlockTagPlugin
+  include JekyllFilterTemplate
+  include JekyllTagPlugin
+  include JekyllPluginHooks
+  include JekyllHookExamples
+  include CategoryIndexGenerator
+  include CategoryCombiner
+end