jekyll-wikilinks 0.0.5 → 0.0.9

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

@@ -0,0 +1,169 @@
+require "nokogiri"
+require_relative "regex"
+require_relative "wikilink"
+
+module Jekyll
+  module WikiLinks
+
+    # 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::WikiLinks::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 |wl_match|
+            # init block wikilink
+            wikilink_block = WikiLinkBlock.new(
+              @doc_manager,
+              doc_filename,
+              wl_match[0], # link_type
+              wl_match[2], # bullet_type
+            )
+            # extract + add filenames
+            items = wl_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 |wl_match|
+            @wikilink_inlines << WikiLinkInline.new(
+              @doc_manager,
+              doc_filename,
+              wl_match[0],
+              wl_match[1],
+              wl_match[2],
+              wl_match[3],
+              wl_match[4],
+              wl_match[5],
+            )
+          end
+        end
+        # replace text
+        return if @wikilink_inlines.nil?
+        self.sort_typed_first
+        @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}" : ""
+        
+        inner_txt = wikilink.label_txt if wikilink.labelled?
+        lnk_doc_rel_url = relative_url(linked_doc.url)
+        
+        if (wikilink.level == "file")
+          inner_txt = "#{linked_doc['title'].downcase}" if inner_txt.nil?
+          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 = "#{linked_doc['title'].downcase} > #{wikilink.header_txt.downcase}" if inner_txt.nil?
+        elsif (wikilink.level == "block")
+          lnk_doc_rel_url += "\#" + wikilink.block_id
+          inner_txt = "#{linked_doc['title'].downcase} > ^#{wikilink.block_id}" if inner_txt.nil?
+        else
+          Jekyll.logger.error("Jekyll-Wikilinks: 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_typed_first
+        # sorting inline wikilinks is necessary so when wikilinks are replaced,
+        # 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)
+        temp = @wikilink_inlines.dup
+        @wikilink_inlines.clear()
+        typed_wikilinks = temp.select { |wl| wl.is_typed? }
+        untyped_wikilinks = temp.select { |wl| !wl.is_typed? }
+        @wikilink_inlines = typed_wikilinks.concat(untyped_wikilinks)
+      end
+    end
+
+  end
+end

data/lib/jekyll-wikilinks/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 WikiLinks
+    #  <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-wikilinks/util/wikilink.rb

@@ -0,0 +1,278 @@
+# wiki data structures
+require_relative "regex"
+
+module Jekyll
+  module WikiLinks
+
+    # wikilink classes know everything about the original markdown syntax and its semantic meaning
+
+    class WikiLinkBlock
+      attr_accessor :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-Wikilinks: 'filename' required") if filename.nil? || filename.empty?
+        @filenames << filename
+      end
+
+      # data
+
+      def md_regex
+        if !is_typed? || !has_filenames? 
+          Jekyll.logger.error("Jekyll-Wikilinks: 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-Wikilinks: WikiLinkBlock.bullet_type error: #{@bullet_type}")
+        end
+        return md_regex
+      end
+
+      def md_str
+        if !is_typed? || !has_filenames?
+          Jekyll.logger.error("Jekyll-Wikilinks: 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-Wikilinks: 'bullet_type' invalid: #{@bullet_type}")
+        end
+        return md_str
+      end
+
+      def urls
+        # return @filenames.map { |f| @doc_mngr.get_doc_by_fname(f) }
+        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
+        return {
+          'type' => @link_type,
+          'urls' => self.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
+
+      # 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?
+        return false if !is_typed?
+        return false if !has_filenames?
+        @filenames.each do |f|
+          return false if !@doc_mngr.file_exists?(f)
+        end
+        return true
+      end
+    end
+
+    class WikiLinkInline
+      attr_accessor :context_filename, :embed, :link_type, :filename, :header_txt, :block_id, :label_txt
+
+      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, filename, header_txt, block_id, label_txt)
+        @doc_mngr ||= doc_mngr
+        @context_filename ||= context_filename
+        @embed ||= embed
+        @link_type ||= link_type
+        @filename ||= filename
+        @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{}
+        filename = described?(FILENAME) ? @filename : ""
+        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)
+          Jekyll.logger.error("Jekyll-Wikilinks: WikiLinkInline.md_regex error")
+        end
+        label_ =  labelled? ? %r{#{REGEX_LINK_LABEL}#{label_txt}} : %r{}
+        return %r{#{regex_embed}#{regex_link_type}#{REGEX_LINK_LEFT}#{filename}#{header}#{block}#{label_}#{REGEX_LINK_RIGHT}}
+      end
+
+      def md_str
+        embed = embedded? ? "!" : ""
+        link_type = is_typed? ? "#{@link_type}::" : ""
+        filename = described?(FILENAME) ? @filename : ""
+        if described?(HEADER_TXT)
+          header = "\##{@header_txt}"
+          block = ""
+        elsif described?(BLOCK_ID)
+          header = ""
+          block = "\#\^#{@block_id}"
+        elsif !described?(FILENAME)
+          Jekyll.logger.error("Jekyll-Wikilinks: WikiLinkInline.md_str error")
+        end
+        label_ = labelled? ? "\|#{@label_txt}" : ""
+        return "#{embed}#{link_type}\[\[#{filename}#{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
+        return @doc_mngr.get_doc_by_fname(@filename)
+      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 (!@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-Wikilinks: There is no link level '#{chunk}' in the WikiLink Class")
+      end
+
+      def level
+        return "file" if described?(FILENAME) && !described?(HEADER_TXT) && !described?(BLOCK_ID)
+        return "header" if described?(FILENAME) && described?(HEADER_TXT) && !described?(BLOCK_ID)
+        return "block" if described?(FILENAME) && !described?(HEADER_TXT) && described?(BLOCK_ID)
+        return "invalid"
+      end
+
+      # validation methods
+
+      def is_valid?
+        return false if !@doc_mngr.file_exists?(@filename)
+        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-wikilinks/version.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
-module JekyllWikiLinks
-  VERSION = "0.0.5"
-end
+module Jekyll
+  module WikiLinks
+
+    VERSION = "0.0.9"
+
+  end
+end