jekyll-wikilinks 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5221a2c4f1d84db636f09d707f0d55891b17be4e35946d1bad55ed743083fde1
-  data.tar.gz: c5b64c09bab070d24a6a1e4af2461e3f09b996211cb4fdff89bd2d624ca4d0b5
+  metadata.gz: 9f7349631b7b0ce9484512d06a368ac2808d3d3c64bdf7ccd66e845dc5f41380
+  data.tar.gz: 87c6d80c73e79c260d3b58acb8cc2e3c62dc0c29c2574a9c54bd5f476e70e8cf
 SHA512:
-  metadata.gz: 6732b84944cbe73c21c87bb43dbdf9006929c2110c9980507e1739df270098a8aa1f6c0f80998160189440b5bb7f5df52193cdd0af4b41c7e1e6e6d825379517
-  data.tar.gz: 1718789738c86cdb00094070a470758c60f248af37c6e0c70b34701bc5c331fdc480f64e01a04350ddd4ac6859c59d808e6afa800bb1400357987229c4671330
+  metadata.gz: 05a261827c04023b8072f85a566c88abad259885e6af6fd85909d61f93200849994de360076023b383f2abab7f3ad4d92e4e755f0ea9cd487e1c59692786d3bf
+  data.tar.gz: 3b3862a5e00356d5227e39a346405e238255fe4cc4275c1f095a2ca828e62d7e1f3468035c99278c95dcbe2a340521588dd2ebc64571a9bec963affc19e9328e

data/lib/jekyll-wikilinks.rb

@@ -1,145 +1,133 @@
 # frozen_string_literal: true
 require "jekyll"
+
 require_relative "jekyll-wikilinks/context"
+require_relative "jekyll-wikilinks/doc_manager"
+require_relative "jekyll-wikilinks/link_index"
+require_relative "jekyll-wikilinks/parser"
+
 require_relative "jekyll-wikilinks/filter"
 require_relative "jekyll-wikilinks/version"
 
+Liquid::Template.register_filter(JekyllWikiLinks::TypeFilters)
 
 module JekyllWikiLinks
-	class Generator < Jekyll::Generator
-		attr_accessor :site, :config, :md_docs, :graph_nodes, :graph_links
+  class Generator < Jekyll::Generator
+		attr_accessor :site, :config, :md_docs, :doc_manager, :link_index, :parser, :graph_nodes, :graph_links
 
 		# Use Jekyll's native relative_url filter
 		include Jekyll::Filters::URLFilters
 
-		CONFIG_KEY = "wikilinks"
 		CONVERTER_CLASS = Jekyll::Converters::Markdown
+		# config
+		CONFIG_KEY = "wikilinks"
 		ENABLED_KEY = "enabled"
-		ENABLED_GRAPH_DATA_KEY = "enabled"
 		EXCLUDE_KEY = "exclude"
-		EXCLUDE_GRAPH_KEY = "exclude"
+		# graph config
 		GRAPH_DATA_KEY = "d3_graph_data"
+		ENABLED_GRAPH_DATA_KEY = "enabled"
+		EXCLUDE_GRAPH_KEY = "exclude"
+		GRAPH_ASSETS_LOCATION_KEY = "assets_rel_path"
+
+    # identify missing links in doc via .invalid-wiki-link class and nested doc-text.
+    REGEX_INVALID_WIKI_LINK = /invalid-wiki-link#{REGEX_NOT_GREEDY}\[\[(#{REGEX_NOT_GREEDY})\]\]/i
 
 		def initialize(config)
-			@config = config
+			@config ||= config
+			@testing ||= config['testing'] if config.keys.include?('testing')
 		end
 
 		def generate(site)
 			return if disabled?
+      self.old_config_warn()
 			Jekyll.logger.debug "Excluded jekyll types: ", option(EXCLUDE_KEY)
 			Jekyll.logger.debug "Excluded jekyll types in graph: ", option_graph(EXCLUDE_GRAPH_KEY)
-
+      
+      # setup site
 			@site = site    
-			@context = context
-
-			documents = []
-			documents += site.pages if !exclude?(:pages)
-			included_docs = site.docs_to_write.filter { |d| !exclude?(d.type) }
-			documents += included_docs
-			@md_docs = documents.select {|doc| markdown_extension?(doc.extname) }
-
-			old_config_warn()
-
-			# build links
-			md_docs.each do |document|
-				parse_wiki_links(document)
-			end
-
-			# backlinks data handling
+			@context ||= JekyllWikiLinks::Context.new(site)
+      
+      # setup markdown docs
+			docs = []
+			docs += site.pages if !exclude?(:pages)
+			docs += site.docs_to_write.filter { |d| !exclude?(d.type) }
+			@md_docs = docs.filter {|doc| markdown_extension?(doc.extname) }
+      
+      # setup helper classes
+      @doc_manager = DocManager.new(@md_docs, @site.static_files)
+      @parser = Parser.new(@context, @markdown_converter, @doc_manager)
+      @link_index = LinkIndex.new(@site, @doc_manager)
+      
+      # parse + populate index
+      @md_docs.each do |doc|
+        @parser.parse(doc.content)
+        @link_index.populate_attributes(doc, @parser.typed_link_blocks)
+      end
+      @link_index.process
+      
+      # handle graph data
 			@graph_nodes, @graph_links = [], []
-			md_docs.each do |document|
-				document.data['backlinks'] = get_backlinks(document)
-				if !disabled_graph_data? && !exclude_graph?(document.type)
-					generate_graph_data(document) 
+			@md_docs.each do |doc|
+				if !disabled_graph_data? && !self.excluded_in_graph?(doc.type)
+					self.generate_graph_data(doc) 
 				end
 			end
-
 			if !disabled_graph_data?
-				write_graph_data()
+				self.write_graph_data()
 			end
 		end
 
-		def old_config_warn()
-			if config.include?("wikilinks_collection")
-				Jekyll.logger.warn "Deprecated: As of 0.0.3, 'wikilinks_collection' is no longer used for configs. jekyll-wikilinks will scan all markdown files by default. Check README for details: https://shorty25h0r7.github.io/jekyll-wikilinks/"
-			end
+		# config helpers
+
+		def disabled?
+			option(ENABLED_KEY) == false
+		end
+
+		def exclude?(type)
+			return false unless option(EXCLUDE_KEY)
+			return option(EXCLUDE_KEY).include?(type.to_s)
 		end
 
-		def parse_wiki_links(note)
-			# Convert all Wiki/Roam-style double-bracket link syntax to plain HTML
-			# anchor tag elements (<a>) with "wiki-link" CSS class
-			md_docs.each do |note_potentially_linked_to|
-				title_from_filename = File.basename(
-					note_potentially_linked_to.basename,
-					File.extname(note_potentially_linked_to.basename)
-				)
-				
-				note_url = relative_url(note_potentially_linked_to.url) if note_potentially_linked_to&.url
+		def has_custom_assets_path?
+			return !!option_graph(GRAPH_ASSETS_LOCATION_KEY)
+		end
 
-				# Replace double-bracketed links using note title
-				# [[feline.cats]]
-				regex_wl, cap_gr = regex_wiki_link(title_from_filename)
-				render_txt = note_potentially_linked_to.data['title'].downcase
-				note.content = note.content.gsub(
-					regex_wl,
-					"<a class='wiki-link' href='#{note_url}'>#{render_txt}</a>"
-				)
+		def markdown_extension?(extension)
+			markdown_converter.matches(extension)
+		end
 
-				# Replace double-bracketed links with alias (right)
-				# [[feline.cats|this is a link to the note about cats]]
-				regex_wl, cap_gr = regex_wiki_link_w_alias_right(title_from_filename)
-				note.content = note.content.gsub(
-					regex_wl,
-					"<a class='wiki-link' href='#{note_url}'>#{cap_gr}</a>"
-				)
+		def markdown_converter
+			@markdown_converter ||= site.find_converter_instance(CONVERTER_CLASS)
+		end
 
-				# Replace double-bracketed links with alias (left)
-				# [[this is a link to the note about cats|feline.cats]]
-				regex_wl, cap_gr = regex_wiki_link_w_alias_left(title_from_filename)
-				note.content = note.content.gsub(
-					regex_wl,
-					"<a class='wiki-link' href='#{note_url}'>#{cap_gr}</a>"
-				)
-			end
+		def option(key)
+			config[CONFIG_KEY] && config[CONFIG_KEY][key]
+		end
+
+		# graph config helpers
 
-			# At this point, all remaining double-bracket-wrapped words are
-			# pointing to non-existing pages, so let's turn them into disabled
-			# links by greying them out and changing the cursor
-			# vanilla wiki-links
-			regex_wl, cap_gr = regex_wiki_link()
-			note.content = note.content.gsub(
-				regex_wl,
-				"<span title='There is no note that matches this link.' class='invalid-wiki-link'>[[#{cap_gr}]]</span>"
-			)
-			# aliases -- both kinds
-			regex_wl, cap_gr = regex_wiki_link_w_alias()      
-			note.content = note.content.gsub(
-				regex_wl,
-				"<span title='There is no note that matches this link.' class='invalid-wiki-link'>[[#{cap_gr}]]</span>"
-			)
+		def disabled_graph_data?
+			option_graph(ENABLED_GRAPH_DATA_KEY) == false
 		end
 
-		def get_backlinks(doc)
-			backlinks = []
-			md_docs.each do |backlinked_doc|
-				if backlinked_doc.content.include?(doc.url)
-					backlinks << backlinked_doc
-				end
-			end
-			return backlinks
+		def excluded_in_graph?(type)
+			return false unless option_graph(EXCLUDE_KEY)
+			return option_graph(EXCLUDE_KEY).include?(type.to_s)
 		end
 
-		def invalid_wiki_links(doc)
-			regex, _ = regex_invalid_wiki_link()
-			return doc.content.scan(regex)[0]
+		def option_graph(key)
+			config[GRAPH_DATA_KEY] && config[GRAPH_DATA_KEY][key]
 		end
 
+		# graph helpers
+
 		def generate_graph_data(doc)
 			Jekyll.logger.debug "Processing graph nodes for doc: ", doc.data['title']
 			# missing nodes
-			missing_node_names = invalid_wiki_links(doc)
+			missing_node_names = doc.content.scan(REGEX_INVALID_WIKI_LINK)
 			if !missing_node_names.nil?
-				missing_node_names.each do |missing_node_name| 
+				missing_node_names.each do |missing_node_name_captures| 
+					missing_node_name = missing_node_name_captures[0]
 					if graph_nodes.none? { |node| node[:id] == missing_node_name }
 						Jekyll.logger.warn "Net-Web node missing: ", missing_node_name
 						Jekyll.logger.warn " in: ", doc.data['slug']  
@@ -161,10 +149,13 @@ module JekyllWikiLinks
 				url: relative_url(doc.url),
 				label: doc.data['title'],
 			}
-			get_backlinks(doc).each do |b|
-				if !exclude_graph?(b.type)
+			# TODO: this link calculation ends up with duplicates -- re-visit this later.
+			all_links = doc.data['attributes'] + doc.data['backlinks']
+			all_links.each do |link|
+        linked_doc = link['doc']
+				if !excluded_in_graph?(linked_doc.type)
 					graph_links << {
-						source: relative_url(b.url),
+						source: relative_url(linked_doc.url),
 						target: relative_url(doc.url),
 					}
 				end
@@ -172,100 +163,30 @@ module JekyllWikiLinks
 		end
 
 		def write_graph_data()
+			assets_path = has_custom_assets_path? ? option_graph(GRAPH_ASSETS_LOCATION_KEY) : "/assets"
+			if !File.directory?(File.join(site.source, assets_path))
+				Jekyll.logger.error "Assets location does not exist, please create required directories for path: ", assets_path
+			end
 			# from: https://github.com/jekyll/jekyll/issues/7195#issuecomment-415696200
-			static_file = Jekyll::StaticFile.new(site, site.source, "/assets", "graph-net-web.json")
+			static_file = Jekyll::StaticFile.new(site, site.source, assets_path, "graph-net-web.json")
+			# TODO: make write file location more flexible -- requiring a write location configuration feels messy...
 			File.write(@site.source + static_file.relative_path, JSON.dump({
 				links: graph_links,
 				nodes: graph_nodes,
 			}))
-		end
-
-		def context
-			@context ||= JekyllWikiLinks::Context.new(site)
-		end
-
-
-		def exclude?(type)
-			return false unless option(EXCLUDE_KEY)
-			return option(EXCLUDE_KEY).include?(type.to_s)
-		end
-
-		def exclude_graph?(type)
-			return false unless option_graph(EXCLUDE_KEY)
-			return option_graph(EXCLUDE_KEY).include?(type.to_s)
-		end
-
-		def markdown_extension?(extension)
-			markdown_converter.matches(extension)
-		end
-
-		def markdown_converter
-			@markdown_converter ||= site.find_converter_instance(CONVERTER_CLASS)
-		end
-
-		def option(key)
-			config[CONFIG_KEY] && config[CONFIG_KEY][key]
-		end
-
-		def option_graph(key)
-			config[GRAPH_DATA_KEY] && config[GRAPH_DATA_KEY][key]
-		end
-
-		def disabled?
-			option(ENABLED_KEY) == false
-		end
-
-		def disabled_graph_data?
-			option_graph(ENABLED_GRAPH_DATA_KEY) == false
-		end
-
-		# regex
-		# returns two items: regex and a target capture group (text to be rendered)
-		# using functions instead of constants because of the need to access 'wiki_link_text'
-		#   -- esp. when aliasing.
-
-		def regex_invalid_wiki_link()
-			# identify missing links in note via .invalid-wiki-link class and nested note-name.
-			regex = /invalid-wiki-link[^\]]+\[\[([^\]]+)\]\]/i
-			cap_gr = "\\1" # this is mostly just to remain consistent with other regex functions
-			return regex, cap_gr
-		end
-
-		def regex_wiki_link(wiki_link_text='')
-			if wiki_link_text.empty?
-				regex = /(\[\[)([^\|\]]+)(\]\])/i
-				cap_gr = "\\2" 
-				return regex, cap_gr
-			else 
-				regex = /\[\[#{wiki_link_text}\]\]/i
-				cap_gr = wiki_link_text
-				return regex, cap_gr
+			# tests fail without manually adding the static file, but actual site builds seem to do ok
+			# ...although there does seem to be a race condition which causes a rebuild to be necessary in order to detect the graph data file
+			if @testing
+				@site.static_files << static_file if !@site.static_files.include?(static_file)
 			end
 		end
 
-		def regex_wiki_link_w_alias()
-			regex = /(\[\[)([^\]\|]+)(\|)([^\]]+)(\]\])/i
-			cap_gr = "\\2|\\4"
-			return regex, cap_gr 
-		end
-
-		def regex_wiki_link_w_alias_left(wiki_link_text)
-			raise ArgumentError.new(
-				"Expected a value for 'wiki_link_text'"
-			) if wiki_link_text.nil?
-			regex = /(\[\[)([^\]\|]+)(\|)(#{wiki_link_text})(\]\])/i
-			cap_gr = "\\2"
-			return regex, cap_gr
-		end
-
-		def regex_wiki_link_w_alias_right(wiki_link_text)
-			raise ArgumentError.new(
-				"Expected a value for 'wiki_link_text'"
-			) if wiki_link_text.nil?
-			regex = /(\[\[)(#{wiki_link_text})(\|)([^\]]+)(\]\])/i
-			cap_gr = "\\4"
-			return regex, cap_gr
-		end
+    # !! deprecated !!
 
+    def old_config_warn()
+      if config.include?("wikilinks_collection")
+        Jekyll.logger.warn "As of 0.0.3, 'wikilinks_collection' is no longer used for configs. jekyll-wikilinks will scan all markdown files by default. Check README for details."
+      end
+    end
 	end
-end
+end

data/lib/jekyll-wikilinks/doc_manager.rb

@@ -0,0 +1,68 @@
+require_relative "naming_const"
+
+module JekyllWikiLinks
+  class DocManager
+		attr_accessor :md_docs, :static_files
+
+		# kramdown header 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 = /^ {0,3}([^ \t].*)\n[-=][-=]*[ \t\r\f\v]*\n/i
+		# obsidian-style
+		REGEX_BLOCK = /.*\s\^#{REGEX_BLOCK_ID_TXT}^\n/i
+
+		def initialize(md_docs, static_files)
+			@md_docs ||= md_docs
+			@static_files ||= static_files
+		end
+
+		def all
+			return @md_docs
+		end
+
+		def get_doc_by_fname(filename)
+      return nil if filename.nil? || @md_docs.size == 0
+			docs = @md_docs.select{ |d| File.basename(d.basename, File.extname(d.basename)) == filename }
+			return nil if docs.nil? || docs.size > 1
+			return docs[0]
+		end
+
+		def get_doc_by_url(url)
+      return nil if url.nil? || @md_docs.size == 0
+			docs = @md_docs.select{ |d| d.url == url }
+			return nil if docs.nil? || docs.size > 1
+			return docs[0]
+		end
+
+    def get_doc_content(filename)
+      return nil if filename.nil? || @md_docs.size == 0
+      docs = @md_docs.select{ |d| File.basename(d.basename, File.extname(d.basename)) == filename }
+      return docs[0].content if docs.size == 1
+      return nil
+    end
+
+		# 'bname' -> 'basename' (filename with extension)
+		def get_image_by_bname(filename)
+			return nil if filename.nil? || @static_files.size == 0 || !SUPPORTED_IMG_FORMATS.any?{ |ext| ext == File.extname(filename).downcase }
+			docs = @static_files.select{ |d| d.basename == filename[...-4] }
+			return nil if docs.nil? || docs.size > 1
+			return docs[0]
+		end
+
+		def self.doc_has_header?(doc, header)
+			return nil if header.nil?
+			# leading + trailing whitespace is ignored when matching headers
+			header_results = doc.content.scan(REGEX_ATX_HEADER).flatten.map { |htxt| htxt.strip } 
+			setext_header_results = doc.content.scan(REGEX_SETEXT_HEADER).flatten.map { |htxt| htxt.strip } 
+			return header_results.include?(header.strip) || setext_header_results.include?(header.strip)
+		end
+
+		def self.doc_has_block_id?(doc, block_id)
+      return nil if block_id.nil?
+			# 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

data/lib/jekyll-wikilinks/filter.rb

@@ -1,16 +1,29 @@
 # frozen_string_literal: true
 
 module JekyllWikiLinks
-  module BackLinkTypeFilters
-    # usage:
-    # {% assign note_backlinks = page.backlinks | backlink_type = "notes" %}
-    def backlink_type(backlinks, type)
-      return if backlinks.nil?
-      target_backlinks = []
-      backlinks.each do |bl|
-        target_backlinks << bl if self.to_string(bl.type) == type
+  module TypeFilters
+    # 'links' accepts both untyped links, typed links, and attributes; fore and back.
+
+    # usage: {% assign note_links = page.links | doc_type = "notes" %}
+    # "doc_type" is the jekyll type ("pages", "posts", "<collection-name>")
+    def doc_type(links, doc_type)
+      return if links.nil?
+      target_links = []
+      links.each do |l|
+        target_links << l if self.to_string(l['doc'].type) == doc_type.to_str
       end
-      return target_backlinks
+      return target_links.uniq
+    end
+
+    # usage: {% assign author_links = page.links | link_type = "author" %}
+    # "link_type" is the wikilink's type, the string that appears before the link in `link-type::[[wikilink]]`.
+    def link_type(links, link_type)
+      return if links.nil?
+      target_links = []
+      link.each do |l|
+        target_links << l if self.to_string(l['type'].to_str) == link_type.to_str
+      end
+      return target_links.uniq
     end
 
     def to_string(type)
@@ -24,5 +37,3 @@ module JekyllWikiLinks
     end
   end
 end
-
-Liquid::Template.register_filter(JekyllWikiLinks::BackLinkTypeFilters)

data/lib/jekyll-wikilinks/jekyll_patch.rb

@@ -0,0 +1,24 @@
+# TODO: Would be nice to put LinkIndex-related data into real objects as opposed to sticking tons and tons of data into frontmatter...I think...
+
+# modelling off of 'related_posts': https://github.com/jekyll/jekyll/blob/6855200ebda6c0e33f487da69e4e02ec3d8286b7/lib/jekyll/document.rb#L402
+# module LinkLogic
+#   attr_accessor :attributed, :attributes, :backlinks, :forelinks
+
+#   # 'links' 'type' is 'nil' for untyped links.
+#   # 'attributes' are block-level typed forelinks; their 'type' may not be 'nil'.
+#   # 'attributed' are block-level typed backlinks; their 'type' may not be 'nil'.
+#   # [{ 'type': str, 'doc': doc }, ...]
+# end
+
+# module Jekyll
+#   class Page
+#     # it would be nice if these would only exist if the page is guaranteed to be a markdown file.
+#     include LinkLogic
+#   end
+# end
+
+# module Jekyll
+#   class Document
+#     include LinkLogic
+#   end
+# end

data/lib/jekyll-wikilinks/link_index.rb

@@ -0,0 +1,81 @@
+module JekyllWikiLinks
+  class LinkIndex
+    attr_accessor :index
+
+    # Use Jekyll's native relative_url filter
+    include Jekyll::Filters::URLFilters
+
+    REGEX_LINK_TYPE = /<a\sclass="wiki-link(\slink-type\s(?<link-type>([^"]+)))?"\shref="(?<link-url>([^"]+))">/i
+
+    def initialize(site, doc_manager)
+      @context ||= JekyllWikiLinks::Context.new(site)
+      @doc_manager ||= doc_manager
+      @index = {}
+      @doc_manager.all.each do |doc|
+        @index[doc.url] = LinksInfo.new()
+      end
+    end
+
+    def process
+      self.populate_links()
+      # apply index info to each document
+      @doc_manager.all.each do |doc|
+        doc.data['attributed'] = @index[doc.url].attributed
+        doc.data['backlinks'] = @index[doc.url].backlinks
+        doc.data['attributes'] = @index[doc.url].attributes
+        doc.data['forelinks'] = @index[doc.url].forelinks
+      end
+    end
+
+    def populate_attributes(doc, typed_link_blocks)
+      typed_link_blocks.each do |tl|
+        attr_doc = @doc_manager.get_doc_by_fname(tl.filename)
+        @index[doc.url].attributes << {
+          'type' => tl.link_type, 
+          'doc' => attr_doc,
+        }
+        @index[attr_doc.url].attributed << {
+          'type' => tl.link_type,
+          'doc' => doc,
+        }
+      end
+    end
+
+    def populate_links()
+      # for each document...
+      @doc_manager.all.each do |doc|
+        # ...process its forelinks
+        doc.content.scan(REGEX_LINK_TYPE).each do |m|
+          ltype, lurl = m[0], m[1]
+          @index[doc.url].forelinks << {
+            'type' => ltype, 
+            'doc' => @doc_manager.get_doc_by_url(lurl),
+          }
+        end
+        # ...process its backlinks
+        @doc_manager.all.each do |doc_to_backlink|
+          doc_to_backlink.content.scan(REGEX_LINK_TYPE).each do |m|
+            ltype, lurl = m[0], m[1]
+            if lurl == relative_url(doc.url)
+              @index[doc.url].backlinks << {
+                'type' => ltype, 
+                'doc' => doc_to_backlink,
+              }
+            end
+          end
+        end
+      end
+    end
+
+    class LinksInfo
+      attr_accessor :attributed, :attributes, :backlinks, :forelinks
+
+      def initialize
+        @attributed = [] # (block-level typed forelinks)
+        @attributes = [] # (block-level typed backlinks)
+        @backlinks = []
+        @forelinks = []
+      end
+    end
+  end
+end

data/lib/jekyll-wikilinks/naming_const.rb

@@ -0,0 +1,21 @@
+# naming_const.rb
+# regex constants defining supported file types and valid names for files, variables, or text
+# 
+
+module JekyllWikiLinks
+  # TODO: Fix REGEX_NOT_GREEDY
+  # REGEX_NOT_GREEDY = /[^(?!\]\])]+/i
+  # REGEX_NOT_GREEDY = /(?!\]\]).*/i
+  REGEX_NOT_GREEDY = /[^\]]+/i
+  # <variables> only work with 'match' function, not with 'scan' function. :/ 
+  # oh well...they are there for easier debugging...
+  # valid naming conventions                                       # capture indeces for WikiLinks class (0 is 'embed')
+  REGEX_LINK_TYPE_TXT = /(?<link-type-txt>([^\n\s\!\#\^\|\]]+))/i  # 1
+  REGEX_FILENAME = /(?<filename>([^\\\/:\#\^\|\[\]]+))/i           # 2
+  REGEX_HEADER_TXT = /(?<header-txt>([^\!\#\^\|\[\]]+))/i          # 3
+  REGEX_BLOCK_ID_TXT = /(?<block-id>([^\\\/:\!\#\^\|\[\]]+))/i     # 4
+  REGEX_LABEL_TXT = /(?<label-txt>(#{REGEX_NOT_GREEDY}))/i         # 5
+  
+  # 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'])
+end

data/lib/jekyll-wikilinks/parser.rb

@@ -0,0 +1,236 @@
+require_relative "naming_const"
+
+module JekyllWikiLinks
+  REGEX_LINK_EMBED = /(?<embed>(\!))/i                           # 0 (capture index for WikiLinks class)
+  REGEX_LINK_TYPE = /::/
+  REGEX_LINK_HEADER = /\#/
+  REGEX_LINK_BLOCK = /\#\^/
+  REGEX_LINK_LABEL = /\|/
+  REGEX_WIKI_LINKS = %r{
+    (#{REGEX_LINK_EMBED})?
+    (#{REGEX_LINK_TYPE_TXT}#{REGEX_LINK_TYPE})?
+    \[\[
+      #{REGEX_FILENAME}
+      (#{REGEX_LINK_HEADER}#{REGEX_HEADER_TXT})?
+      (#{REGEX_LINK_BLOCK}#{REGEX_BLOCK_ID_TXT})?
+      (#{REGEX_LINK_LABEL}#{REGEX_LABEL_TXT})?
+    \]\]
+  }x
+  REGEX_TYPED_LINK_BLOCK = /#{REGEX_LINK_TYPE_TXT}#{REGEX_LINK_TYPE}\[\[#{REGEX_FILENAME}\]\]\n/i
+
+  # more of a "parser" than a parser
+  class Parser
+    attr_accessor :doc_manager, :markdown_converter, :wikilinks, :typed_link_blocks
+
+    # Use Jekyll's native relative_url filter
+    include Jekyll::Filters::URLFilters
+
+    def initialize(context, markdown_converter, doc_manager)
+      @context ||= context
+      @doc_manager ||= doc_manager
+      @markdown_converter ||= markdown_converter
+      @wikilinks, @typed_link_blocks = [], []
+    end
+
+    def parse(doc_content)
+      @typed_link_blocks, @wikilinks = [], []
+      # process blocks
+      typed_link_block_matches = doc_content.scan(REGEX_TYPED_LINK_BLOCK)
+      if !typed_link_block_matches.nil? && typed_link_block_matches.size != 0
+        typed_link_block_matches.each do |wl_match|
+          typed_link_block_wikilink = WikiLink.new(
+            nil,
+            wl_match[0],
+            wl_match[1],
+            nil,
+            nil,
+            nil,
+          )
+          doc_content.gsub!(typed_link_block_wikilink.md_link_str, "")
+          @typed_link_blocks << typed_link_block_wikilink
+        end
+      end
+      # process inlines
+      wikilink_matches = doc_content.scan(REGEX_WIKI_LINKS)
+      if !wikilink_matches.nil? && wikilink_matches.size != 0
+        wikilink_matches.each do |wl_match|
+          @wikilinks << WikiLink.new(
+            wl_match[0],
+            wl_match[1],
+            wl_match[2],
+            wl_match[3],
+            wl_match[4],
+            wl_match[5],
+          )
+        end
+      end
+      # replace text
+      return if @wikilinks.nil?
+      @wikilinks.each do |wikilink|
+        doc_content.sub!(
+          wikilink.md_link_regex,
+          self.build_html(wikilink)
+        )
+      end
+    end
+
+    def build_html_embed(title, content, url)
+      # multi-line for readability
+      return [
+        "<div class=\"wiki-link-embed\">",
+          "<div class=\"wiki-link-embed-title\">",
+            "#{title}",
+          "</div>",
+          "<div class=\"wiki-link-embed-content\">",
+            "#{@markdown_converter.convert(content)}",
+          "</div>",
+          "<a class=\"wiki-link-embed-link\" href=\"#{url}\"></a>",
+        "</div>",
+      ].join("\n").gsub!("\n", "")
+    end
+
+    def build_html_img_embed(img_file)
+      "<p><span class=\"wiki-link-embed-image\"><img class=\"wiki-link-img\" src=\"#{relative_url(img_file.relative_path)}\"/></span></p>"
+    end
+
+		def build_html(wikilink)
+      if wikilink.is_img?
+			  linked_doc = @doc_manager.get_image_by_bname(wikilink.filename)
+        if wikilink.embedded? && wikilink.is_img?
+          return build_html_img_embed(linked_doc)
+        end
+      end
+      linked_doc = @doc_manager.get_doc_by_fname(wikilink.filename)
+			if !linked_doc.nil?
+        link_type = wikilink.typed? ? " link-type #{wikilink.link_type}" : ""
+
+				# label
+				wikilink_inner_txt = wikilink.clean_label_txt if wikilink.labelled?
+
+				lnk_doc_rel_url = relative_url(linked_doc.url) if linked_doc&.url
+        # TODO not sure about downcase
+				fname_inner_txt = linked_doc['title'].downcase if wikilink_inner_txt.nil?
+				
+        link_lvl = wikilink.describe['level']
+				if (link_lvl == "file")
+					wikilink_inner_txt = "#{fname_inner_txt}" if wikilink_inner_txt.nil?
+          return build_html_embed(
+            linked_doc['title'],
+            @doc_manager.get_doc_content(wikilink.filename),
+            lnk_doc_rel_url
+          ) if wikilink.embedded?
+				elsif (link_lvl == "header" && DocManager.doc_has_header?(linked_doc, wikilink.header_txt))
+					lnk_doc_rel_url += "\#" + wikilink.header_txt.downcase
+					wikilink_inner_txt = "#{fname_inner_txt} > #{wikilink.header_txt}" if wikilink_inner_txt.nil?
+				elsif (link_lvl == "block" && DocManager.doc_has_block_id?(linked_doc, wikilink.block_id))
+					lnk_doc_rel_url += "\#" + wikilink.block_id.downcase
+					wikilink_inner_txt = "#{fname_inner_txt} > ^#{wikilink.block_id}" if wikilink_inner_txt.nil?
+				else
+					return '<span title="Content not found." class="invalid-wiki-link">' + wikilink.md_link_str + '</span>'
+				end
+				return '<a class="wiki-link' + link_type + '" href="' + lnk_doc_rel_url + '">' + wikilink_inner_txt + '</a>'
+			else
+				return '<span title="Content not found." class="invalid-wiki-link">' + wikilink.md_link_str + '</span>'
+			end
+		end
+  end
+  
+  # the wikilink class knows everything about the original markdown syntax and its semantic meaning
+  class WikiLink
+    attr_accessor :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(embed, link_type, filename, header_txt, block_id, label_txt)
+      # super(embed, link_type, filename, header_txt, block_id, label_txt)
+      @embed ||= embed
+      @link_type ||= link_type
+      @filename ||= filename
+      @header_txt ||= header_txt
+      @block_id ||= block_id
+      @label_txt ||= label_txt
+    end
+
+    # labeles are really flexible, so we need to handle them with a bit more care
+    def clean_label_txt
+      return @label_txt.sub("[", "\\[").sub("]", "\\]")
+    end
+
+    def md_link_str
+      embed = embedded? ? "!" : ""
+      link_type = 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 "Invalid link level in 'md_link_str'. See WikiLink's 'md_link_str' for details"
+      end
+      label_ = labelled? ? "\|#{@label_txt}" : ""
+      return "#{embed}#{link_type}\[\[#{filename}#{header}#{block}#{label_}\]\]"
+    end
+
+    def md_link_regex
+      regex_embed = embedded? ? REGEX_LINK_EMBED : %r{}
+      regex_link_type = 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 "Invalid link level in regex. See WikiLink's 'md_link_regex' for details"
+      end
+      label_ =  labelled? ? %r{#{REGEX_LINK_LABEL}#{clean_label_txt}} : %r{}
+      return %r{#{regex_embed}#{regex_link_type}\[\[#{filename}#{header}#{block}#{label_}\]\]}
+    end
+
+    def describe
+      return {
+        'level' => level,
+        'labelled' => labelled?,
+        'embedded' => embedded?,
+        'typed_link' => typed?,
+      }
+    end
+
+    def labelled?
+      return !@label_txt.nil? && !@label_txt.empty?
+    end
+
+    def 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 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 "There is no link level '#{chunk}' in WikiLink Struct"
+    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
+  end
+end

data/lib/jekyll-wikilinks/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JekyllWikiLinks
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,32 +1,37 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-wikilinks
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
-- shorty25h0r7
+- manunamz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-05-21 00:00:00.000000000 Z
+date: 2021-06-25 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
-- short2thingz@gmail.com
+- manunamz@pm.me
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/jekyll-wikilinks.rb
 - lib/jekyll-wikilinks/context.rb
+- lib/jekyll-wikilinks/doc_manager.rb
 - lib/jekyll-wikilinks/filter.rb
+- lib/jekyll-wikilinks/jekyll_patch.rb
+- lib/jekyll-wikilinks/link_index.rb
+- lib/jekyll-wikilinks/naming_const.rb
+- lib/jekyll-wikilinks/parser.rb
 - lib/jekyll-wikilinks/version.rb
-homepage: https://github.com/shorty25h0r7/jekyll-wikilinks
+homepage: https://github.com/manunamz/jekyll-wikilinks
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/shorty25h0r7/jekyll-wikilinks
-  source_code_uri: https://github.com/shorty25h0r7/jekyll-wikilinks
+  homepage_uri: https://github.com/manunamz/jekyll-wikilinks
+  source_code_uri: https://github.com/manunamz/jekyll-wikilinks
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -45,5 +50,5 @@ requirements: []
 rubygems_version: 3.2.17
 signing_key:
 specification_version: 4
-summary: Add support for [[wikilinks]] (in markdown).
+summary: Add jekyll support for [[wikilinks]] (in markdown).
 test_files: []