jekyll-wikirefs 0.0.1 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd19157531219d5251d79f6d9f31be1acd344d4c45c9177deec21612a5e03a0f
-  data.tar.gz: 68fa28e81d81c3e4edb2f403ec8cb3b7a41c1fba41fcd6466956ec6a6de44190
+  metadata.gz: 6ffaf29b4a348e3036a6508d41df6cc915ae3459a2afb250a4c778242f4dff69
+  data.tar.gz: 939fa037711ee9f265ee73edc709f34264188f71dca4f7d7e8f972f97be9eb3b
 SHA512:
-  metadata.gz: ec59939d22628f566605761c3413ee25311b2d5063bb4ab8a2ab95c960918f60ac07a8b196a45b86e5685d65d36320feca6cc0fb80431cf0ebf7544bce98da4e
-  data.tar.gz: 61caaa334cd42d3b0f0718aca5aa02c3c7e6a26516c0dd65fa04f346cf960091cd7619d6533d06c3f7ed0a783bf5c4cee7b2bb3b95a08a93d22b7fa4cd0fda5e
+  metadata.gz: 97d3144acc57f975dfb1fb6799bc90df9c93de66b9b1bca5f2c6cfc34a5fe4b24316830d87410a90e5ba867516f68326dc9e4de688098e879e5cfd50f2ab0e33
+  data.tar.gz: 01c27427d75cb71a22965f91f890deca40fbfa8955560aea6fa01518d02343da53a26c927389624f12d771d574127383af61a7f65255a7111d1d1ef7b3d5b90f

data/lib/jekyll-wikirefs/config.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+require "jekyll"
+
+module Jekyll
+  module WikiRefs
+
+    class PluginConfig
+
+      ATTR_KEY = "attributes"
+      CONFIG_KEY = "wikirefs"
+      ENABLED_KEY = "enabled"
+      EXCLUDE_KEY = "exclude"
+      # css-related
+      CSS_KEY = "css"
+      NAME_KEY = "name"
+      # names
+      ## valid
+      TYPED_KEY = "typed"
+      WEB_KEY = "web"
+      WIKI_KEY = "wiki"
+      ## invalid
+      INV_WIKI_KEY = "invalid_wiki"
+      # INV_WEB_KEY = "invalid_web"
+      ## embed
+      EMBED_WRAPPER_KEY = "embed_wrapper"
+      EMBED_TITLE_KEY = "embed_title"
+      EMBED_CONTENT_KEY = "embed_content"
+      EMBED_LINK_KEY = "embed_wiki_link"
+      EMBED_IMG_WRAPPER_KEY = "embed_image_wrapper"
+      EMBED_IMG_KEY = "embed_image"
+
+      def initialize(config)
+        @config ||= config
+        self.old_config_warn()
+        Jekyll.logger.debug("Jekyll-WikiRefs: Excluded jekyll types: #{option(EXCLUDE_KEY)}") unless disabled?
+      end
+
+      # util
+
+      def css_name(name_key)
+        return option_css_name(name_key) if option_css_name(name_key)
+        return "typed"                   if name_key == TYPED_KEY
+        # valid
+        return "wiki-link"               if name_key == WIKI_KEY
+        # invalid
+        return "invalid-wiki-link"       if name_key == INV_WIKI_KEY
+        # return "invalid-web-link" if name_key == INV_WEB_KEY
+        # embeds
+        return "embed-wrapper"           if name_key == EMBED_WRAPPER_KEY
+        return "embed-title"             if name_key == EMBED_TITLE_KEY
+        return "embed-content"           if name_key == EMBED_CONTENT_KEY
+        return "embed-wiki-link"         if name_key == EMBED_LINK_KEY
+        # img
+        return "embed-image-wrapper"     if name_key == EMBED_IMG_WRAPPER_KEY
+        return "embed-image"             if name_key == EMBED_IMG_KEY
+      end
+
+      def disabled?
+        option(ENABLED_KEY) == false
+      end
+
+      def disabled_attributes?
+        option_attributes(ENABLED_KEY) == false
+      end
+
+      def exclude?(type)
+        return false unless option(EXCLUDE_KEY)
+        return option(EXCLUDE_KEY).include?(type.to_s)
+      end
+
+      def excluded_css_names
+        return self.option_css(EXCLUDE_KEY)
+      end
+
+      # options
+
+      def option(key)
+        @config[CONFIG_KEY] && @config[CONFIG_KEY][key]
+      end
+
+      def option_attributes(key)
+        @config[CONFIG_KEY] && @config[CONFIG_KEY][ATTR_KEY] && @config[CONFIG_KEY][ATTR_KEY][key]
+      end
+
+      def option_css(key)
+        @config[CONFIG_KEY] && @config[CONFIG_KEY][CSS_KEY] && @config[CONFIG_KEY][CSS_KEY][key]
+      end
+
+      def option_css_name(key)
+        option_css(NAME_KEY) && @config[CONFIG_KEY][CSS_KEY][NAME_KEY][key]
+      end
+
+      # !! deprecated !!
+
+      def option_exist?(key)
+        @config[CONFIG_KEY] && @config[CONFIG_KEY].include?(key)
+      end
+
+      def old_config_warn()
+        if @config.include?("wikilinks_collection")
+          Jekyll.logger.warn("Jekyll-WikiRefs: As of 0.0.3, 'wikilinks_collection' is no longer used for configs. Jekyll-WikiRefs will scan all markdown files by default. Check README for details.")
+        end
+        if option_exist?("assets_rel_path")
+          Jekyll.logger.warn("Jekyll-WikiRefs: As of 0.0.5, 'assets_rel_path' is now 'path'.")
+        end
+        if @config.include?("d3_graph_data")
+          Jekyll.logger.warn("Jekyll-WikiRefs: As of 0.0.6, 'd3_graph_data' and graph functionality have been moved to the 'jekyll-graph' plugin.")
+        end
+      end
+    end
+
+  end
+end

data/lib/jekyll-wikirefs/patch/context.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module WikiRefs
+
+    class Context
+      attr_reader :site
+
+      def initialize(site)
+        @site = site
+      end
+
+      def registers
+        { :site => site }
+      end
+    end
+    
+  end
+end

data/lib/jekyll-wikirefs/patch/doc_manager.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+require_relative "../util/regex"
+
+module Jekyll
+  module WikiRefs
+
+    # todo: move these methods to the 'WikiRef' classes...?
+    #
+    # this class is responsible for answering any questions
+    # related to jekyll markdown documents
+    # that are meant to be processed by the wikirefs plugin.
+    #
+    # the following methods are specifically to address two things:
+    #  1. ruby's 'find' / 'detect' function does not throw errors if 
+    #     there are multiple matches. fail fast, i want to know if there
+    #     are duplicates. 
+    #     (not using sets because i don't want to clobber existing documents)
+    #  2. handle all jekyll documents in one place. i don't want to
+    #     have to filter all documents for target markdown documents 
+    #     every time i need to check if a file exists.
+    # 
+    # there is probably a better way to do this...i would prefer to have
+    # a plugin-wide function that just wraps all of this and can be called
+    # from anywhere in the plugin...but ruby is not a functional language...
+    # gotta have classes...
+    # 
+    class DocManager
+      CONVERTER_CLASS = Jekyll::Converters::Markdown
+
+      def initialize(site)
+        return if $wiki_conf.disabled?
+
+        markdown_converter = site.find_converter_instance(CONVERTER_CLASS)
+        # filter docs based on configs
+        docs = []
+        docs += site.pages if !$wiki_conf.exclude?(:pages)
+        docs += site.docs_to_write.filter { |d| !$wiki_conf.exclude?(d.type) }
+        @md_docs = docs.filter { |doc| markdown_converter.matches(doc.extname) }
+        if @md_docs.nil? || @md_docs.empty?
+          Jekyll.logger.warn("Jekyll-WikiRefs: No documents to process.")
+        end
+
+        @static_files ||= site.static_files
+      end
+
+      # accessors
+
+      def all
+        return @md_docs
+      end
+
+      def get_doc_by_fname(filename)
+        Jekyll.logger.error("Jekyll-WikiRefs: Must provide a 'filename'") if filename.nil? || filename.empty?
+        docs = @md_docs.select{ |d| File.basename(d.basename, File.extname(d.basename)) == filename }
+        return nil if docs.nil? || docs.empty? || docs.size > 1
+        return docs[0]
+      end
+
+      def get_doc_by_fpath(file_path)
+        Jekyll.logger.error("Jekyll-WikiRefs: Must provide a 'file_path'") if file_path.nil? || file_path.empty?
+        docs = @md_docs.select{ |d| d.relative_path == (file_path + ".md") }
+        return nil if docs.nil? || docs.empty? || docs.size > 1
+        return docs[0]
+      end
+
+      def get_doc_by_url(url)
+        Jekyll.logger.error("Jekyll-WikiRefs: Must provide a 'url'") if url.nil? || url.empty?
+        docs = @md_docs.select{ |d| d.url == url }
+        return nil if docs.nil? || docs.empty? || docs.size > 1
+        return docs[0]
+      end
+
+      def get_doc_content(filename)
+        doc = self.get_doc_by_fname(filename)
+        return nil if docs.nil?
+        return doc.content
+      end
+
+      def get_image_by_fname(filename)
+        Jekyll.logger.error("Jekyll-WikiRefs: Must provide a 'filename'") if filename.nil? || filename.empty?
+        return nil if @static_files.size == 0 || !SUPPORTED_IMG_FORMATS.any?{ |ext| ext == File.extname(filename).downcase }
+        docs = @static_files.select{ |d| File.basename(d.relative_path) == filename }
+        return nil if docs.nil? || docs.empty? || docs.size > 1
+        return docs[0]
+      end
+
+      # validators
+
+      def file_exists?(filename, file_path=nil)
+        Jekyll.logger.error("Jekyll-WikiRefs: Must provide a 'filename'") if filename.nil? || filename.empty?
+        if file_path.nil?
+          return false if get_doc_by_fname(filename).nil? && get_image_by_fname(filename).nil?
+          return true
+        else
+          return false if get_doc_by_fpath(file_path).nil?
+          return true
+        end
+      end
+
+      def doc_has_header?(doc, header)
+        Jekyll.logger.error("Jekyll-WikiRefs: Must provide a 'header'") if header.nil? || header.empty?
+        # leading + trailing whitespace is ignored when matching headers
+        header_results = doc.content.scan(REGEX_ATX_HEADER).flatten.map { |htxt| htxt.downcase.strip }
+        setext_header_results = doc.content.scan(REGEX_SETEXT_HEADER).flatten.map { |htxt| htxt.downcase.strip }
+        return header_results.include?(header.downcase.strip) || setext_header_results.include?(header.downcase.strip)
+      end
+
+      def doc_has_block_id?(doc, block_id)
+        Jekyll.logger.error("Jekyll-WikiRefs: Must provide a 'block_id'") if block_id.nil? || block_id.empty?
+        # leading + trailing whitespace is ignored when matching blocks
+        block_id_results = doc.content.scan(REGEX_BLOCK).flatten.map { |bid| bid.strip }
+        return block_id_results.include?(block_id)
+      end
+    end
+
+  end
+end

data/lib/jekyll-wikirefs/patch/site.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require "jekyll"
+
+# appending to built-in jekyll site object to pass data to jekyll-graph
+
+module Jekyll
+
+  class Site
+    attr_accessor :doc_mngr, :link_index, :wiki_parser
+  end
+
+end

data/lib/jekyll-wikirefs/plugins/converter.rb

@@ -0,0 +1,53 @@
+require "jekyll"
+require "nokogiri"
+
+module Jekyll
+  module WikiRefs
+
+    class WebLinkConverter < Jekyll::Converter
+      priority :low
+
+      # config
+      CSS_KEY = "css"
+      CONFIG_KEY = "wikirefs"
+      EXCLUDE_KEY = "exclude"
+      # link types
+      # WEB_KEY = "web"
+      # WIKIL_KEY = "wiki"
+      # INVALID_KEY = "invalid"
+      # WIKI_EMBED_KEY = "wiki_embed"
+
+      def matches(ext)
+        ext =~ /^\.md$/i
+      end
+
+      def output_ext(ext)
+        ".html"
+      end
+
+      # add 'web-link' css class to links that aren't
+      # - wikilinks
+      # - contain an excluded css class
+      def convert(content)
+        excluded_classes = option_css(EXCLUDE_KEY)
+        if excluded_classes.nil? || excluded_classes.empty?
+          css_def = "a:not(.#{$wiki_conf.css_name("wiki")}):not(.#{$wiki_conf.css_name("embed_wiki_link")})"
+        else
+          css_def = "a:not(.#{$wiki_conf.css_name("wiki")}):not(.#{$wiki_conf.css_name("embed_wiki_link")}):not(.#{excluded_classes.join("):not(.")})"
+        end
+        parsed_content = Nokogiri::HTML::fragment(content)
+        parsed_content.css(css_def).each do |link|
+          link.add_class('web-link')
+        end
+        content = parsed_content.to_html
+      end
+
+      # config helpers
+
+      def option_css(key)
+        @config[CONFIG_KEY] && @config[CONFIG_KEY][CSS_KEY] && @config[CONFIG_KEY][CSS_KEY][key]
+      end
+    end
+
+  end
+end

data/lib/jekyll-wikirefs/plugins/filter.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module WikiRefs
+
+    module TypeFilters
+      # 'links' accepts untyped links, typed links, and attributes; fore and back.
+      # why: these filters are useful when you want to list backlinks of certain type(s) and don't want type mismatches to display as "missing"
+
+      # usage: {% assign note_links = page.links | doc_type: "notes" %}
+      def doc_type(links, doc_type)
+        Jekyll.logger.error("Jekyll-WikiRefs: 'links' invalid") if links.nil?
+        Jekyll.logger.error("Jekyll-WikiRefs: 'doc_type' invalid") if doc_type.nil? || doc_type.empty?
+        return [] if links.empty?
+
+        site = @context.registers[:site]
+
+        links_of_type = []
+        links.each do |l|
+          # links
+          if l.keys.include?('url')
+            docs = site.documents.select{ |d| d.url == l['url'] && d.type.to_s == doc_type.to_s }
+            if !docs.nil? && docs.size == 1
+              links_of_type << l
+            end
+          # attributes
+          elsif l.keys.include?('urls')
+            l['urls'].each do |lurl|
+              docs = site.documents.select{ |d| d.url == lurl && d.type.to_s == doc_type.to_s }
+              if !docs.nil? && docs.size == 1
+                links_of_type << l
+              end
+            end
+          else
+            Jekyll.logger.error("Jekyll-WikiRefs: In 'doc_type' filter, 'links' do not have 'url' or 'urls'")
+          end
+        end
+        return links_of_type.uniq
+      end
+
+      # usage: {% assign author_links = page.links | link_type: "author" %}
+      def link_type(links, link_type)
+        Jekyll.logger.error("Jekyll-WikiRefs: 'links' invalid") if links.nil?
+        Jekyll.logger.error("Jekyll-WikiRefs: 'link_type' invalid") if link_type.nil?
+        return [] if links.empty?
+
+        site = @context.registers[:site]
+
+        links_of_type = []
+        links.each do |l|
+          if l['type'].to_s == link_type.to_s
+            # links
+            if l.keys.include?('url')
+              docs = site.documents.select{ |d| d.url == l['url'] }
+              if !doc.nil? && docs.size != 1
+                links_of_type << l
+              end
+            # attributes
+            elsif l.keys.include?('urls')
+              all_docs_exist = true
+              l['urls'].each do |lurl|
+                docs = site.documents.select{ |d| d.url == lurl }
+                if !docs.nil? && docs.size != 1
+                  all_docs_exist = false
+                end
+              end
+              if all_docs_exist
+                links_of_type << l
+              end
+            else
+              Jekyll.logge.error("Jekyll-WikiRefs: In 'link_type' filter, 'links' do not have 'url' or 'urls'")
+            end
+          end
+        end
+        return links_of_type.uniq
+      end
+
+    end
+
+  end
+end

data/lib/jekyll-wikirefs/plugins/generator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+require "jekyll"
+
+require_relative "../patch/context"
+require_relative "../patch/doc_manager"
+require_relative "../patch/site"
+require_relative "../util/link_index"
+require_relative "../util/parser"
+
+module Jekyll
+  module WikiRefs
+
+    class Generator < Jekyll::Generator
+
+      def generate(site)
+        return if $wiki_conf.disabled?
+
+        @site ||= site
+        @context ||= Jekyll::WikiRefs::Context.new(site)
+
+        # setup helper classes
+        @parser = Parser.new(@site)
+        @site.link_index = LinkIndex.new(@site)
+
+        @site.doc_mngr.all.each do |doc|
+          filename = File.basename(doc.basename, File.extname(doc.basename))
+          @parser.parse(filename, doc.content)
+          @site.link_index.populate(doc, @parser.wikilink_blocks, @parser.wikilink_inlines)
+        end
+        # wait until all docs are processed before assigning backward facing metadata,
+        # this ensures all attributed/backlinks are collected for assignment
+        @site.doc_mngr.all.each do |doc|
+          # populate frontmatter metadata from (wiki)link index
+          @site.link_index.assign_metadata(doc)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/jekyll-wikirefs/util/link_index.rb

@@ -0,0 +1,99 @@
+require_relative 'regex'
+
+module Jekyll
+  module WikiRefs
+
+    class LinkIndex
+      attr_reader :index
+
+      def initialize(site)
+        @baseurl = site.baseurl
+        @index = {}
+        site.doc_mngr.all.each do |doc|
+          @index[doc.url] = DocLinks.new()
+        end
+      end
+
+      def assign_metadata(doc)
+        doc.data['attributed'] = @index[doc.url].attributed.uniq
+        doc.data['attributes'] = @index[doc.url].attributes.uniq
+        doc.data['backlinks']  = @index[doc.url].backlinks.uniq
+        doc.data['forelinks']  = @index[doc.url].forelinks.uniq
+        doc.data['missing']    = @index[doc.url].missing.uniq
+      end
+
+      def populate(doc, wikilink_blocks, wikilink_inlines)
+        #        #
+        # blocks #
+        #        #
+        wikilink_blocks.each do |wlbl|
+          if wlbl.is_valid?
+            #
+            # attributes
+            #
+            target_attr = @index[doc.url].attributes.detect { |atr| atr['type'] == wlbl.link_type }
+            # create
+            if target_attr.nil?
+              @index[doc.url].attributes << wlbl.linked_fm_data
+            # append
+            else
+              target_attr['urls'] += wlbl.urls 
+            end
+            ## append missing docs
+            @index[doc.url].missing += wlbl.missing_doc_filenames 
+            #
+            # attributed
+            #
+            wlbl.linked_docs.each do |linked_doc|
+              target_attr = @index[linked_doc.url].attributed.detect { |atr| atr['type'] == wlbl.link_type }
+              # create
+              if target_attr.nil?
+                @index[linked_doc.url].attributed << wlbl.context_fm_data
+              # append
+              else
+                target_attr['urls'] << doc.url
+              end
+            end
+          else
+            #
+            # invalid || empty
+            #
+            @index[doc.url].missing += wlbl.missing_doc_filenames
+          end
+        end
+        #         #
+        # inlines #
+        #         #
+        wikilink_inlines.each do |wlil|
+          return if wlil.is_img?
+          if wlil.is_valid?
+            # forelink
+            @index[doc.url].forelinks << wlil.linked_fm_data
+            # backlink
+            @index[wlil.linked_doc.url].backlinks << wlil.context_fm_data
+          else
+            @index[doc.url].missing << wlil.filename
+          end
+        end
+      end
+
+      # def remove_baseurl(url)
+      #   return url.gsub(@baseurl, '') if !@baseurl.nil?
+      #   return url
+      # end
+
+      class DocLinks
+        attr_accessor :attributes, :attributed, :backlinks, :forelinks, :missing
+
+        def initialize
+          @attributed = [] # block typed backlinks;            { 'type' => str, 'urls' => [ str ] }
+          @attributes = [] # block typed forelinks;            { 'type' => str, 'urls' => [ str ] }
+          @backlinks  = [] # inline typed and basic backlinks; { 'type' => str, 'url'  => str }
+          @forelinks  = [] # inline typed and basic forelinks; { 'type' => str, 'url'  => str }
+          @missing    = [] # missing forelinks + attributes;   ( built from (missing) filenames )
+        end
+      end
+    end
+
+  end
+end

data/lib/jekyll-wikirefs/util/parser.rb

@@ -0,0 +1,182 @@
+require "nokogiri"
+require_relative "regex"
+require_relative "wikiref"
+
+module Jekyll
+  module WikiRefs
+
+    # more of a "parser" than a parser
+    class Parser
+      attr_accessor :doc_manager, :markdown_converter, :wikilink_inlines, :wikilink_blocks
+
+      # Use Jekyll's native relative_url filter
+      include Jekyll::Filters::URLFilters
+
+      CONVERTER_CLASS = Jekyll::Converters::Markdown
+
+      def initialize(site)
+        @context ||= Jekyll::WikiRefs::Context.new(site)
+        # do not use @dm in parser -- it is only meant to be passed down into wikilink classes. 
+        @doc_manager ||= site.doc_mngr
+        @markdown_converter ||= site.find_converter_instance(CONVERTER_CLASS)
+        @wikilink_blocks, @wikilink_inlines = [], []
+      end
+
+      # parsing
+
+      def parse(doc_filename, doc_content)
+        @wikilink_blocks, @wikilink_inlines = [], []
+        if !$wiki_conf.disabled_attributes?
+          self.parse_blocks(doc_filename, doc_content)
+        end
+        self.parse_inlines(doc_filename, doc_content)
+      end
+
+      def parse_blocks(doc_filename, doc_content)
+        block_matches = doc_content.scan(REGEX_WIKI_LINK_BLOCKS)
+        if !block_matches.nil? && block_matches.size != 0
+          block_matches.each do |w_match|
+            # init block wikilink
+            wikilink_block = WikiLinkBlock.new(
+              @doc_manager,
+              doc_filename,
+              w_match[0], # link_type
+              w_match[2], # bullet_type
+            )
+            # extract + add filenames
+            items = w_match[1]
+            filename_matches = items.scan(/#{REGEX_LINK_LEFT}#{REGEX_FILENAME}#{REGEX_LINK_RIGHT}/i)
+            filename_matches.each do |match|
+              match.each do |fname|
+                wikilink_block.add_item(fname)
+              end
+            end
+            # replace text
+            doc_content.gsub!(wikilink_block.md_regex, "\n")
+            @wikilink_blocks << wikilink_block
+          end
+        end
+      end
+
+      def parse_inlines(doc_filename, doc_content)
+        inline_matches = doc_content.scan(REGEX_WIKI_LINK_INLINES)
+        if !inline_matches.nil? && inline_matches.size != 0
+          inline_matches.each do |w_match|
+            @wikilink_inlines << WikiLinkInline.new(
+              @doc_manager,
+              doc_filename,
+              w_match[0],
+              w_match[1],
+              w_match[2],
+              w_match[3],
+              w_match[4],
+              w_match[5],
+            )
+          end
+        end
+        # replace text
+        return if @wikilink_inlines.nil?
+        # process typed wikilinks first so we don't accidentally 
+        # overwrite them when handling untyped wikilinks
+        self.sort_for_replacement
+        @wikilink_inlines.each do |wikilink|
+          doc_content.gsub!(
+            wikilink.md_regex,
+            self.build_html(wikilink)
+          )
+        end
+      end
+
+      # building/converting
+
+      def build_html_embed(title, content, url)
+        # multi-line for readability
+        return [
+          "<div class=\"#{$wiki_conf.css_name("embed_wrapper")}\">",
+            "<div class=\"#{$wiki_conf.css_name("embed_title")}\">",
+              "#{title}",
+            "</div>",
+            "<div class=\"#{$wiki_conf.css_name("embed_content")}\">",
+              "#{@markdown_converter.convert(content)}",
+            "</div>",
+            "<a class=\"#{$wiki_conf.css_name("embed_wiki_link")}\" href=\"#{url}\"></a>",
+          "</div>",
+        ].join("\n").gsub!("\n", "")
+      end
+
+      def build_html_img_embed(static_doc, is_svg=false)
+        svg_content = ""
+        if is_svg
+          File.open(static_doc.path, "r") do |svg_img|
+            svg_content = svg_img.read
+          end
+          return "<p><span class=\"#{$wiki_conf.css_name("embed_image_wrapper")}\">#{svg_content}</span></p>"
+        else
+          return "<p><span class=\"#{$wiki_conf.css_name("embed_image_wrapper")}\"><img class=\"#{$wiki_conf.css_name("embed_image")}\" src=\"#{relative_url(static_doc.relative_path)}\"></span></p>"
+        end
+      end
+
+  		def build_html(wikilink)
+        if !wikilink.is_valid?
+          return '<span class="' + $wiki_conf.css_name("invalid_wiki") + '">' + wikilink.md_str + '</span>'
+        end
+        # image processing
+        if wikilink.embedded? && wikilink.is_img?
+          return build_html_img_embed(wikilink.linked_img, is_svg=wikilink.is_img_svg?)
+        end
+        # markdown file processing
+        linked_doc = wikilink.linked_doc
+        link_type_txt = wikilink.is_typed? ? " #{$wiki_conf.css_name("typed")} #{wikilink.link_type}" : ""
+        lnk_doc_rel_url = relative_url(linked_doc.url)
+        if wikilink.labelled?
+          inner_txt = wikilink.label_txt
+        elsif linked_doc.data.keys.include?('title')
+          inner_txt = linked_doc.data['title'].downcase
+        # in case there is no 'title' frontmatter attribute 
+        # (i'm seeing deprecation warnings, but there might 
+        #  be bugs caused by not using this...)
+        elsif linked_doc.respond_to?(:title)
+          inner_txt = linked_doc.title.downcase
+        # pages don't have automatically generated titles
+        else
+          inner_txt = Jekyll::Utils.slugify(linked_doc.basename)
+        end
+        # level-specific
+        if (wikilink.level == "file_path" || wikilink.level == "filename")
+          return build_html_embed(
+            linked_doc.title,
+            linked_doc.content,
+            lnk_doc_rel_url
+          ) if wikilink.embedded?
+        elsif (wikilink.level == "header")
+          # from: https://github.com/jekyll/jekyll/blob/6855200ebda6c0e33f487da69e4e02ec3d8286b7/Rakefile#L74
+          lnk_doc_rel_url += "\#" + Jekyll::Utils.slugify(wikilink.header_txt)
+          inner_txt += " > #{wikilink.header_txt.downcase}" if !wikilink.labelled?
+        elsif (wikilink.level == "block")
+          lnk_doc_rel_url += "\#" + wikilink.block_id
+          inner_txt += " > ^#{wikilink.block_id}" if !wikilink.labelled?
+        else
+          Jekyll.logger.error("Jekyll-WikiRefs: Invalid wikilink level")
+        end
+        return '<a class="' + $wiki_conf.css_name("wiki") + link_type_txt + '" href="' + lnk_doc_rel_url + '">' + inner_txt + '</a>'
+      end
+
+      # helpers
+
+      def sort_for_replacement
+        # sorting inline wikilinks is necessary so when wikilinks are replaced,
+        # !embeds and longer strings are replaced first so as not to accidentally overwrite 
+        # substrings
+        # (this is especially likely if there is a matching wikilink that 
+        #  appears as both untyped and typed in a document or in a regular link and embed)
+        temp = @wikilink_inlines.dup
+        @wikilink_inlines.clear()
+        embeds = temp.select { |w| w.embedded? }
+        typed_wikilinks = temp.select { |w| w.is_typed? }
+        untyped_wikilinks = temp.select { |w| !w.is_typed? }
+        @wikilink_inlines = embeds.concat(typed_wikilinks.concat(untyped_wikilinks))
+      end
+    end
+
+  end
+end

data/lib/jekyll-wikirefs/util/regex.rb

@@ -0,0 +1,72 @@
+# regex.rb
+# regex constants defining supported file types and valid names for files, variables, or text
+#
+
+module Jekyll
+  module WikiRefs
+    #  <regex_variables> only work with 'match' function, not with 'scan' function. :/
+    #  oh well...they are there for easier debugging...
+
+    # supported image formats
+    # from: https://docs.github.com/en/github/managing-files-in-a-repository/working-with-non-code-files/rendering-and-diffing-images
+    SUPPORTED_IMG_FORMATS = Set.new(['.png', '.jpg', '.gif', '.psd', '.svg'])
+
+    # wikilink constants
+    REGEX_LINK_LEFT       = /\[\[/
+    REGEX_LINK_RIGHT      = /\]\]/
+    REGEX_LINK_EMBED      = /(?<embed>\!)/
+    REGEX_LINK_TYPE       = /\s*::\s*/
+    REGEX_LINK_HEADER     = /\#/
+    REGEX_LINK_BLOCK      = /\#\^/
+    REGEX_LINK_LABEL      = /\|/
+
+    # wikitext usable char requirements
+    REGEX_LINK_TYPE_CHARS = /[^\n\s\!\#\^\|\]]+/i
+    REGEX_FILENAME_CHARS  = /[^\\:\#\^\|\[\]]+/i
+    REGEX_HEADER_CHARS    = /[^\!\#\^\|\[\]]+/i
+    REGEX_BLOCK_ID_CHARS  = /[^\\\/:\!\#\^\|\[\]^\n]+/i
+    REGEX_LABEL_CHARS     = /(.+?)(?=\]{2}[^\]])/i
+
+    # capture groups
+    REGEX_LINK_TYPE_TXT   = /(?<link-type-txt>#{REGEX_LINK_TYPE_CHARS})/i
+    REGEX_FILENAME        = /(?<filename>#{REGEX_FILENAME_CHARS})/i
+    REGEX_HEADER_TXT      = /(?<header-txt>#{REGEX_HEADER_CHARS})/i
+    REGEX_BLOCK_ID_TXT    = /(?<block-id>#{REGEX_BLOCK_ID_CHARS})/i
+    REGEX_LABEL_TXT       = /(?<label-txt>#{REGEX_LABEL_CHARS})/i
+
+    # target markdown text (headers, lists, and blocks)
+    ## kramdown regexes
+    ### atx header: https://github.com/gettalong/kramdown/blob/master/lib/kramdown/parser/kramdown/header.rb#L29
+    REGEX_ATX_HEADER      = /^\#{1,6}[\t ]*([^ \t].*)\n/i
+    ### setext header: https://github.com/gettalong/kramdown/blob/master/lib/kramdown/parser/kramdown/header.rb#L17
+    REGEX_SETEXT_HEADER   = /^\s{0,3}([^ \t].*)\n[-=][-=]*[ \t\r\f\v]*\n/i
+    ## list item: https://github.com/gettalong/kramdown/blob/master/lib/kramdown/parser/kramdown/list.rb#L49
+    REGEX_BULLET          = /(?<bullet>[+*-])/i
+    ## markdown-style block-reference
+    REGEX_BLOCK           = /.*\s\^#{REGEX_BLOCK_ID_TXT}/i
+
+    # wikilinks
+
+    ## inline
+    REGEX_WIKI_LINK_INLINES = %r{                     # capture indeces
+      (#{REGEX_LINK_EMBED})?                          # 0
+      (#{REGEX_LINK_TYPE_TXT}#{REGEX_LINK_TYPE})?     # 1
+      #{REGEX_LINK_LEFT}
+        #{REGEX_FILENAME}                             # 2
+        (#{REGEX_LINK_HEADER}#{REGEX_HEADER_TXT})?    # 3
+        (#{REGEX_LINK_BLOCK}#{REGEX_BLOCK_ID_TXT})?   # 4
+        (#{REGEX_LINK_LABEL}#{REGEX_LABEL_TXT})?      # 5
+      #{REGEX_LINK_RIGHT}
+    }x
+
+    ## block
+    ### single
+    REGEX_SINGLE           = /#{REGEX_LINK_LEFT}#{REGEX_FILENAME_CHARS}#{REGEX_LINK_RIGHT}/i
+    ### list (comma is responsible for catching the single case)
+    REGEX_LIST_COMMA       = /((?:\s*#{REGEX_SINGLE}\s*)(?:,\s*#{REGEX_SINGLE}\s*)*)/i
+    REGEX_LIST_MKDN        = /((?<=\n)\s{0,3}#{REGEX_BULLET}\s#{REGEX_SINGLE}\s*)+/i # (see REGEX_LIST_ITEM)
+    ### process
+    REGEX_BLOCK_TYPES      = /((?<!\n)(?:#{REGEX_LIST_COMMA})|#{REGEX_LIST_MKDN})/i
+    REGEX_WIKI_LINK_BLOCKS = /^\s{0,3}#{REGEX_LINK_TYPE_TXT}#{REGEX_LINK_TYPE}(?:\s*|\G)(?<items>#{REGEX_BLOCK_TYPES})\n/i
+  end
+end

data/lib/jekyll-wikirefs/util/wikiref.rb

@@ -0,0 +1,312 @@
+# wiki data structures
+require_relative "regex"
+
+module Jekyll
+  module WikiRefs
+
+    # wikilink classes know everything about the original markdown syntax and its semantic meaning
+
+    class WikiLinkBlock
+      attr_reader :link_type, :filenames
+
+      # parameters ordered by appearance in regex
+      def initialize(doc_mngr, context_filename, link_type, bullet_type=nil)
+        @doc_mngr ||= doc_mngr
+        @context_filename ||= context_filename
+        @link_type ||= link_type
+        @bullet_type ||= bullet_type
+        @filenames = []
+      end
+
+      def add_item(filename)
+        Jekyll.logger.error("Jekyll-WikiRefs: 'filename' required") if filename.nil? || filename.empty?
+        @filenames << filename
+      end
+
+      # data
+
+      def md_regex
+        if !is_typed? || !has_filenames? 
+          Jekyll.logger.error("Jekyll-WikiRefs: WikiLinkBlock.md_regex error -- type: #{@link_type}, fnames: #{@filenames.inspect}, for: #{@context_filename}")
+        end
+        # comma (including singles)
+        if @bullet_type.nil?
+          link_type = /#{@link_type}#{REGEX_LINK_TYPE}/i
+          tmp_filenames = @filenames.dup
+          first_filename = /\s*#{REGEX_LINK_LEFT}#{tmp_filenames.shift()}#{REGEX_LINK_RIGHT}\s*/i
+          filename_strs = tmp_filenames.map { |f| /,\s*#{REGEX_LINK_LEFT}#{f}#{REGEX_LINK_RIGHT}\s*/i }
+          md_regex = /#{link_type}#{first_filename}#{filename_strs.join('')}\n/i
+        # mkdn
+        elsif !@bullet_type.match(REGEX_BULLET).nil?
+          link_type = /#{@link_type}#{REGEX_LINK_TYPE}\n/i
+          filename_strs = @filenames.map { |f| /\s{0,3}#{Regexp.escape(@bullet_type)}\s#{REGEX_LINK_LEFT}#{f}#{REGEX_LINK_RIGHT}\n/i }
+          md_regex = /#{link_type}#{filename_strs.join("")}/i
+        else
+          Jekyll.logger.error("Jekyll-WikiRefs: WikiLinkBlock.bullet_type error: #{@bullet_type}")
+        end
+        return md_regex
+      end
+
+      def md_str
+        if !is_typed? || !has_filenames?
+          Jekyll.logger.error("Jekyll-WikiRefs: WikiLinkBlockList.md_str error -- type: #{@link_type}, fnames: #{@filenames.inspect}, for: #{@context_filename}")
+        end
+        # comma (including singles)
+        if @bullet_type.nil?
+          link_type = "#{@link_type}::"
+          filename_strs = @filenames.map { |f| "\[\[#{f}\]\]," }
+          md_str = (link_type + filename_strs.join('')).delete_suffix(",")
+        # mkdn
+        elsif !@bullet_type.match(REGEX_BULLET).nil?
+          link_type = "#{@link_type}::\n"
+          filename_strs = @filenames.map { |f| li[0] + " \[\[#{li[1]}\]\]\n" }
+          md_str = link_type + filename_strs.join('')
+        else
+          Jekyll.logger.error("Jekyll-WikiRefs: 'bullet_type' invalid: #{@bullet_type}")
+        end
+        return md_str
+      end
+
+      def urls
+        # return @filenames.map { |f| @doc_mngr.get_doc_by_fname(f).url }.compact()
+        urls = []
+        @filenames.each do |f|
+          doc = @doc_mngr.get_doc_by_fname(f)
+          urls << doc.url if !doc.nil?
+        end
+        return urls
+      end
+      
+      # 'fm' -> frontmatter
+
+      def context_fm_data
+        return {
+          'type' => @link_type,
+          'urls' => [self.context_doc.url],
+        }
+      end
+
+      def linked_fm_data
+        valid_urls = self.urls.select{ |url| @doc_mngr.get_doc_by_url(url) }
+        return {
+          'type' => @link_type,
+          'urls' => valid_urls,
+        }
+      end
+
+      def context_doc
+        return @doc_mngr.get_doc_by_fname(@context_filename)
+      end
+
+      def linked_docs
+        docs = [] 
+        @filenames.each do |f|
+          doc = @doc_mngr.get_doc_by_fname(f)
+          docs << doc if !doc.nil?
+        end
+        return docs
+      end
+
+      def missing_doc_filenames
+        missing_doc_fnames = [] 
+        @filenames.each do |f|
+          doc = @doc_mngr.get_doc_by_fname(f)
+          missing_doc_fnames << f if doc.nil?
+        end
+        return missing_doc_fnames
+      end
+
+      # descriptor methods
+
+      def has_filenames?
+        return !@filenames.nil? && !@filenames.empty?
+      end
+
+      def is_typed?
+        return !@link_type.nil? && !@link_type.empty?
+      end
+
+      # validation methods
+
+      def is_valid?
+        all_filenames_missing = linked_docs.empty?
+        return false if !is_typed? || !has_filenames? || all_filenames_missing
+        return true
+      end
+    end
+
+    class WikiLinkInline
+      attr_reader :link_type, :filename, :header_txt, :block_id
+
+      FILE_PATH = "file_path"
+      FILENAME = "filename"
+      HEADER_TXT = "header_txt"
+      BLOCK_ID = "block_id"
+
+      # parameters ordered by appearance in regex
+      def initialize(doc_mngr, context_filename, embed, link_type, file_string, header_txt, block_id, label_txt)
+        if file_string.include?('/') && file_string[0] == '/'
+          @path_type = "absolute"
+          @file_path ||= file_string[1...] # remove leading '/' to match `jekyll_collection_doc.relative_path`
+          @filename ||= file_string.split('/').last
+        elsif file_string.include?('/') && file_string[0] != '/'
+          Jekyll.logger.error("Jekyll-WikiRefs: Relative file paths are not yet supported, please use absolute file paths that start with '/' for #{file_string}")
+          # todo:
+          # @path_type = "relative"
+        else
+          @filename ||= file_string
+        end
+        @doc_mngr ||= doc_mngr
+        @context_filename ||= context_filename
+        @embed ||= embed
+        @link_type ||= link_type
+        @header_txt ||= header_txt
+        @block_id ||= block_id
+        @label_txt ||= label_txt
+      end
+
+      # escape square brackets if they appear in label text
+      def label_txt
+        return @label_txt.sub("[", "\\[").sub("]", "\\]")
+      end
+
+      # data
+
+      def md_regex
+        regex_embed = embedded? ? REGEX_LINK_EMBED : %r{}
+        regex_link_type = is_typed? ? %r{#{@link_type}#{REGEX_LINK_TYPE}} : %r{}
+        if !@file_path.nil?
+          file_string = described?(FILE_PATH) ? @file_path : ""
+          file_string = '/' + file_string if @path_type == "absolute"
+        else
+          file_string = described?(FILENAME) ? @filename : ""
+        end
+        if described?(HEADER_TXT)
+          header = %r{#{REGEX_LINK_HEADER}#{@header_txt}}
+          block = %r{}
+        elsif described?(BLOCK_ID)
+          header = %r{}
+          block = %r{#{REGEX_LINK_BLOCK}#{@block_id}}
+        elsif !described?(FILENAME) && !described?(FILE_PATH)
+          Jekyll.logger.error("Jekyll-WikiRefs: WikiLinkInline.md_regex error")
+        end
+        label_ =  labelled? ? %r{#{REGEX_LINK_LABEL}#{label_txt}} : %r{}
+        return %r{#{regex_embed}#{regex_link_type}#{REGEX_LINK_LEFT}#{file_string}#{header}#{block}#{label_}#{REGEX_LINK_RIGHT}}
+      end
+
+      def md_str
+        embed = embedded? ? "!" : ""
+        link_type = is_typed? ? "#{@link_type}::" : ""
+        if !@file_path.nil?
+          file_string = described?(FILE_PATH) ? @file_path : ""
+          file_string = '/' + file_string if @path_type == "absolute"
+        else
+          file_string = described?(FILENAME) ? @filename : ""
+        end
+        if described?(HEADER_TXT)
+          header = "\##{@header_txt}"
+          block = ""
+        elsif described?(BLOCK_ID)
+          header = ""
+          block = "\#\^#{@block_id}"
+        elsif !described?(FILENAME) && !described?(FILE_PATH)
+          Jekyll.logger.error("Jekyll-WikiRefs: WikiLinkInline.md_str error")
+        end
+        label_ = labelled? ? "\|#{@label_txt}" : ""
+        return "#{embed}#{link_type}\[\[#{file_string}#{header}#{block}#{label_}\]\]"
+      end
+
+      # 'fm' -> frontmatter
+
+      def context_fm_data
+        return {
+          'type' => @link_type,
+          'url' => self.context_doc.url,
+        }
+      end
+
+      def linked_fm_data
+        return {
+          'type' => @link_type,
+          'url' => self.linked_doc.url,
+        }
+      end
+
+      def context_doc
+        return @doc_mngr.get_doc_by_fname(@context_filename)
+      end
+
+      def linked_doc
+        # by file path
+        return @doc_mngr.get_doc_by_fpath(@file_path) if !@file_path.nil?
+        # by filename
+        return @doc_mngr.get_doc_by_fname(@filename) if @file_path.nil?
+        return nil
+      end
+
+      def linked_img
+        return @doc_mngr.get_image_by_fname(@filename) if self.is_img?
+        return nil
+      end
+
+      # descriptor methods
+
+      # def describe
+      #   return {
+      #     'level' => level,
+      #     'labelled' => labelled?,
+      #     'embedded' => embedded?,
+      #     'typed_link' => is_typed?,
+      #   }
+      # end
+
+      def labelled?
+        return !@label_txt.nil? && !@label_txt.empty?
+      end
+
+      def is_typed?
+        return !@link_type.nil? && !@link_type.empty?
+      end
+
+      def embedded?
+        return !@embed.nil? && @embed == "!"
+      end
+
+      def is_img?
+        # github supported image formats: https://docs.github.com/en/github/managing-files-in-a-repository/working-with-non-code-files/rendering-and-diffing-images
+        return SUPPORTED_IMG_FORMATS.any?{ |ext| ext == File.extname(@filename).downcase }
+      end
+
+      def is_img_svg?
+        return File.extname(@filename).downcase == ".svg"
+      end
+
+      # this method helps to make the 'WikiLinkInline.level' code read like a clean truth table.
+      def described?(chunk)
+        return (!@file_path.nil? && !@file_path.empty?) if chunk == FILE_PATH
+        return (!@filename.nil? && !@filename.empty?) if chunk == FILENAME
+        return (!@header_txt.nil? && !@header_txt.empty?) if chunk == HEADER_TXT
+        return (!@block_id.nil? && !@block_id.empty?) if chunk == BLOCK_ID
+        Jekyll.logger.error("Jekyll-WikiRefs: There is no link level '#{chunk}' in the WikiLink Class")
+      end
+
+      def level
+        return "file_path" if described?(FILE_PATH) && described?(FILENAME) && !described?(HEADER_TXT) && !described?(BLOCK_ID)
+        return "filename"  if !described?(FILE_PATH) && described?(FILENAME) && !described?(HEADER_TXT) && !described?(BLOCK_ID)
+        return "header"    if (described?(FILE_PATH) || described?(FILENAME)) && described?(HEADER_TXT) && !described?(BLOCK_ID)
+        return "block"     if (described?(FILE_PATH) || described?(FILENAME)) && !described?(HEADER_TXT) && described?(BLOCK_ID)
+        return "invalid"
+      end
+
+      # validation methods
+
+      def is_valid?
+        return false if !@doc_mngr.file_exists?(@filename, @file_path)
+        return false if (self.level == "header") && !@doc_mngr.doc_has_header?(self.linked_doc, @header_txt)
+        return false if (self.level == "block") && !@doc_mngr.doc_has_block_id?(self.linked_doc, @block_id)
+        return true
+      end
+    end
+
+  end
+end

data/lib/jekyll-wikirefs/version.rb

@@ -3,7 +3,7 @@
 module Jekyll
   module WikiRefs
 
-    VERSION = "0.0.1"
+    VERSION = "0.0.14"
 
   end
 end

data/lib/jekyll-wikirefs.rb

@@ -2,9 +2,29 @@
 
 require_relative "jekyll-wikirefs/version"
 
-module Jekyll
-  module WikiRefs
-    class Error < StandardError; end
-    # Your code goes here...
+# setup config
+require_relative "jekyll-wikirefs/config"
+Jekyll::Hooks.register :site, :after_init do |site|
+  # global '$wiki_conf' to ensure that all local jekyll plugins
+  # are reading from the same configuration
+  # (global var is not ideal, but is DRY)
+  $wiki_conf = Jekyll::WikiRefs::PluginConfig.new(site.config)
+end
+
+# setup docs (based on configs)
+require_relative "jekyll-wikirefs/patch/doc_manager"
+Jekyll::Hooks.register :site, :post_read do |site|
+  if !$wiki_conf.disabled?
+    site.doc_mngr = Jekyll::WikiRefs::DocManager.new(site)
   end
 end
+
+# parse wikilinks / generate metadata
+require_relative "jekyll-wikirefs/plugins/generator"
+
+# convert weblinks
+require_relative "jekyll-wikirefs/plugins/converter"
+
+# hook up liquid filters
+require_relative "jekyll-wikirefs/plugins/filter"
+Liquid::Template.register_filter(Jekyll::WikiRefs::TypeFilters)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-wikirefs
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.14
 platform: ruby
 authors:
 - manunamz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-02 00:00:00.000000000 Z
+date: 2023-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.3
 description:
 email:
 - manunamz@pm.me
@@ -32,14 +46,25 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/jekyll-wikirefs.rb
+- lib/jekyll-wikirefs/config.rb
+- lib/jekyll-wikirefs/patch/context.rb
+- lib/jekyll-wikirefs/patch/doc_manager.rb
+- lib/jekyll-wikirefs/patch/site.rb
+- lib/jekyll-wikirefs/plugins/converter.rb
+- lib/jekyll-wikirefs/plugins/filter.rb
+- lib/jekyll-wikirefs/plugins/generator.rb
+- lib/jekyll-wikirefs/util/link_index.rb
+- lib/jekyll-wikirefs/util/parser.rb
+- lib/jekyll-wikirefs/util/regex.rb
+- lib/jekyll-wikirefs/util/wikiref.rb
 - lib/jekyll-wikirefs/version.rb
-homepage: https://github.com/manunamz/jekyll-wikirefs
+homepage: https://github.com/wikibonsai/jekyll-wikirefs
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/manunamz/jekyll-wikirefs
-  source_code_uri: https://github.com/manunamz/jekyll-wikirefs
-  changelog_uri: https://github.com/manunamz/jekyll-wikirefs/blob/main/CHANGELOG.md
+  homepage_uri: https://github.com/wikibonsai/jekyll-wikirefs
+  source_code_uri: https://github.com/wikibonsai/jekyll-wikirefs
+  changelog_uri: https://github.com/wikibonsai/jekyll-wikirefs/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -55,8 +80,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
-summary: "You thought there was something in here, didn't you? \U0001F609"
+summary: Add [[wikirefs]] support (in markdown files) for jekyll.
 test_files: []