jekyll-semtree 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44fd1bb2e5b2159e83705c9a4593da991a7e4195379b6f22774d693f481863e1
-  data.tar.gz: 80454edb2aeaee8ee3dbbb590baae6f9c9dfaa7eccf5113f7bf2a87ed35654ba
+  metadata.gz: 45680543ef4121289d217b25451ff65a73c14399018f98275b9d8c08dcf91b22
+  data.tar.gz: 1d99a3e6062a15c75414770ac22e4ca88ff9b9c566b57ca2e2871f1358200495
 SHA512:
-  metadata.gz: 2a0938a421d109591927fd21d166746b4f06b86c5980f606fe0bd12938c3fa5ee0797d64b5ff74e01ab524f1af7b26e135ecdc5aeb80c61c50a7004b56739b3b
-  data.tar.gz: 4a171bf8adfdcebbd61301309eb721ae26840d75c383e9711f3287e5e930efb66423537ef3b7d1ef0b2156750d31fa84ea36fb420c68be371882cb87ef62b04d
+  metadata.gz: e34f0d3b31cc635c6163bca4a7fdfbde0e23c6e98a458cd8310bc4a8d78a07877e26bf6206806d8d63a2a2530fb945350b746e4d0a88e9101f7e4c52dd8c3588
+  data.tar.gz: 646df65358f1ea451c8e597bc74a956e943e32d3bbf5601d229ecabe58d7e4b4d423f47f61477f8729bd3d6baede280fedee93c9144dca5fd54f0b4561edf372

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

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

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+require_relative "../util/regex"
+
+module Jekyll
+  module SemTree
+
+    # note: this is a copy/paste from Jekyll-SemTree;
+    #       if that plugin is installed, this is all redundant code.
+    #
+    # 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-SemTree: 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-SemTree: 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-SemTree: 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-SemTree: 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-SemTree: 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-SemTree: 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
+
+      # todo: wiki headers/blocks
+
+      # def doc_has_header?(doc, header)
+      #   Jekyll.logger.error("Jekyll-SemTree: 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-SemTree: 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-semtree/patch/site.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require "jekyll"
+
+# appending to built-in jekyll site object to pass data to jekyll-d3
+
+module Jekyll
+
+  class Site
+    # 'doc_mngr' only necessary if 'jekyll-wikirefs' not installed
+    attr_accessor :doc_mngr, :tree
+  end
+
+end

data/lib/jekyll-semtree/tree.rb

@@ -0,0 +1,478 @@
+# frozen_string_literal: true
+require "jekyll"
+
+module Jekyll
+
+  class Tree
+
+    OPEN_BRACKETS = '[['
+    CLOSE_BRACKETS = ']]'
+  
+    MARKDOWN_BULLET_ASTERISK = '* '
+    MARKDOWN_BULLET_DASH = '- '
+    MARKDOWN_BULLET_PLUS = '+ '
+  
+    REGEX = {
+      LEVEL: /^[ \t]*/,  # TODO: link
+      TEXT_WITH_LOC: /([^\\:^|\[\]]+)-(\d+)-(\d+)/i,
+      TEXT_WITH_ID: /([^\\:^|\[\]]+)-\(([A-Za-z0-9]{5})\)/i,
+      WIKITEXT_WITH_ID: /([+*-]) \[\[([^\\:\\^|\[\]]+)-\(([A-Za-z0-9]{5})\)\]\]/i,
+      WHITESPACE: /^\s*$/,
+    }.freeze
+
+    def is_markdown_bullet(text)
+      return [
+        MARKDOWN_BULLET_ASTERISK,
+        MARKDOWN_BULLET_DASH,
+        MARKDOWN_BULLET_PLUS,
+      ].include?(text)
+    end
+
+    attr_accessor :chunk_size    # size of indentation for each tree level (set by the first indentation found)
+    attr_accessor :duplicates    # duplicate node names in the tree
+    attr_accessor :level_max     # 
+    attr_accessor :nodes         # the tree nodes
+    attr_accessor :petiole_map   # a hash where each key is each node in the tree and the value is the index file that contains that node/doc
+    attr_accessor :root          # name of the root node/document
+    attr_accessor :trunk         # list of index doc fnames
+    attr_accessor :virtual_trunk # whether or not the trunk/index documents should be included in the tree data
+
+    def initialize(content, root_doc, virtual_trunk = false)
+      # init
+      # tree properties
+      @chunk_size    = -1
+      @level_max     = -1
+      @duplicates    = []
+      @mkdn_list     = true
+      @virtual_trunk = virtual_trunk
+      # tree nodes
+      @nodes          = []
+      @petiole_map   = {}
+      @root          = ''
+      @trunk         = []
+
+      # go
+      root_fname = File.basename(root_doc.basename, File.extname(root_doc.basename))
+      # tree_data.each do |data|
+      #   if doc != root_doc
+      #     # jekyll pages don't have the slug attribute: https://github.com/jekyll/jekyll/blob/master/lib/jekyll/page.rb#L8
+      #     if doc.type == :pages
+      #       page_basename = File.basename(doc.name, File.extname(doc.name))
+      #       doc.data['slug'] = Jekyll::Utils.slugify(page_basename)
+      #     end
+      #   end
+      # end
+
+      # prep
+      lines = []
+      # single file
+      if content.is_a?(String)
+        lines = content.split("\n")
+        set_units(lines)
+        return build_tree('root', { 'root' => lines })
+      # multiple files
+      elsif content.is_a?(Hash)
+        unless root_fname
+          puts 'Cannot parse multiple files without a "root" defined'
+          return
+        end
+        unless content.keys.include?(root_fname)
+          raise "content hash does not contain: '#{root_fname}'; keys are: #{content.keys.join(', ')}"
+        end
+        lines = content[root_fname].split("\n")
+        set_units(lines)
+        content_hash = {}
+        content.each do |filename, file_content|
+          content_hash[filename] = file_content.split("\n")
+        end
+        self.clear
+        return build_tree(root_fname, deepcopy(content_hash))
+      else
+        raise "content is not a string or hash: #{content}"
+      end
+      # print_tree(root)
+    end
+
+    def build_tree(cur_key, content, ancestors = [], total_level = 0)
+      @trunk = content.keys
+      # if the trunk isn't virtual, handle index/trunk file
+      unless @virtual_trunk
+        node = TreeNode.new(
+          cur_key,
+          ancestors.map { |n| raw_text(n.text) },
+          total_level,
+        )
+        if total_level == 0
+          add_root(cur_key)
+        else
+          add_branch(cur_key, node.ancestors)
+        end
+        ancestors << node
+        total_level += 1
+      end
+      # handle file...
+      lines = content[cur_key]
+      lines.each_with_index do |line, i|
+        text = line.gsub(REGEX[:LEVEL], '')
+        next if text.nil? || text.empty?
+        if @nodes.map(&:text).include?(raw_text(text))
+          @duplicates << raw_text(text)
+          next
+        end
+        # calculate numbers
+        line_num = i + 1
+        level_match = line.match(REGEX[:LEVEL])
+        # number of spaces
+        next if level_match.nil?
+        size = get_whitespace_size(level_match[0])
+        level = get_level(size) + total_level
+        @chunk_size = 2 if @chunk_size < 0
+        # root
+        if total_level == 0 && i == 0
+          node = TreeNode.new(
+            text,
+            [],
+            level,
+            line_num,
+          )
+          add_root(raw_text(node.text))
+          ancestors << node
+        # node
+        else
+          # connect subtree via 'virtual' semantic-tree node
+          # TODO: if cur_key == raw_text(text), print a warning: don't do that.
+          if cur_key != raw_text(text) && content.keys.include?(raw_text(text))
+            # virtual_levels += @chunk_size  # This line is commented out as in the original TypeScript
+            ancestors = calc_ancestry(level, ancestors)
+            build_tree(raw_text(text), content, deepcopy(ancestors), get_level(size))
+            next
+          end
+          node = TreeNode.new(
+            text,
+            [],
+            level,
+            line_num,
+          )
+          node.text = raw_text(node.text)
+          ancestors = calc_ancestry(level, ancestors)
+          node.ancestors = ancestors.map { |p| raw_text(p.text) }
+          ancestors << node
+          add_branch(node.text, node.ancestors, cur_key)
+        end
+      end
+      content.delete(cur_key)
+      if content.any? && total_level == 0
+        return "Some files were not processed: #{content.keys.join(', ')}"
+      end
+      if content.empty?
+        if @duplicates.any?
+          duplicates = @duplicates.uniq
+          error_msg = "Tree did not build, duplicate nodes found:\n\n"
+          error_msg += duplicates.join(', ') + "\n\n"
+          clear
+          return error_msg
+        end
+        return @nodes.dup
+      end
+    end
+
+    # helper methods
+
+    def add_root(text)
+      @root = text
+      @nodes << TreeNode.new(text)
+      @petiole_map[text] = text
+    end
+
+    def add_branch(text, ancestry_titles, trnk_fname = nil)
+      trnk_fname ||= text
+      ancestry_titles.each_with_index do |ancestry_title, i|
+        if i < (ancestry_titles.length - 1)
+          node = @nodes.find { |n| n.text == ancestry_title }
+          if node && !node.children.include?(ancestry_titles[i + 1])
+            node.children << ancestry_titles[i + 1]
+          end
+        else
+          node = @nodes.find { |n| n.text == ancestry_title }
+          if node && !node.children.include?(text)
+            node.children << text
+          end
+        end
+      end
+      @nodes << TreeNode.new(text, ancestry_titles)
+      @petiole_map[text] = trnk_fname
+    end
+
+    def calc_ancestry(level, ancestors)
+      parent = ancestors.last
+      is_child = (parent.level == (level - 1))
+      is_sibling = (parent.level == level)
+      # child:
+      # - [[parent]]
+      #   - [[child]]
+      if is_child
+        # continue...
+      # sibling:
+      # - [[sibling]]
+      # - [[sibling]]
+      elsif is_sibling
+        # we can safely throw away the last node name because
+        # it can't have children if we've already decreased the level
+        ancestors.pop
+      # unrelated (great+) (grand)parent:
+      #     - [[descendent]]
+      # - [[great-grandparent]]
+      else  # (parent.level < level)
+        level_diff = parent.level - level
+        (1..(level_diff + 1)).each do
+          ancestors.pop
+        end
+      end
+      return ancestors
+    end
+
+    # util methods
+
+    def raw_text(full_text)
+      # strip markdown list marker if it exists
+      if @mkdn_list && is_markdown_bullet(full_text[0..1])
+        full_text = full_text[2..-1]
+      end
+      # strip wikistring special chars and line breaks
+      # using gsub to replace substrings in Ruby
+      full_text.gsub!(OPEN_BRACKETS, '')
+      full_text.gsub!(CLOSE_BRACKETS, '')
+      full_text.gsub!(/\r?\n|\r/, '')
+      return full_text
+    end
+
+    def define_level_size(whitespace)
+      if whitespace[0] == ' '
+        return whitespace.length
+      elsif whitespace[0] == "\t"
+        tab_size = 4
+        return tab_size
+      else
+        # puts "defineLevelSize: unknown whitespace: #{whitespace}"
+        return -1
+      end
+    end
+
+    def get_whitespace_size(whitespace)
+      if whitespace.include?(' ')
+        return whitespace.length
+      elsif whitespace.include?("\t")
+        tab_size = 4
+        return whitespace.length * tab_size
+      else
+        # puts "getWhitespaceSize: unknown whitespace: #{whitespace}"
+        return whitespace.length
+      end
+    end
+
+    def get_level(size)
+      (size / @chunk_size) + 1
+    end
+
+    def clear
+      @root = ''
+      @nodes = []
+      @petiole_map = {}
+      @duplicates = []
+    end
+
+    def deepcopy(obj)
+      Marshal.load(Marshal.dump(obj))
+    end
+
+    def set_units(lines)
+      # calculate number of spaces per level and size of deepest level
+      lines.each do |line|
+        level_match = line.match(REGEX[:LEVEL])
+        # calculates number of spaces
+        if level_match
+          if @chunk_size < 0
+            @chunk_size = define_level_size(level_match[0])
+          end
+          level = get_level(level_match[0].length)
+        else
+          next
+        end
+        @level_max = level > @level_max ? level : @level_max
+      end
+    end
+
+    # metadata methods
+
+    def get_all_lineage_ids(target_node_id, node=@nodes.detect { |n| n.text == @root }, ancestors=[], descendents=[], found=false)
+      # found target node, stop adding ancestors and build descendents
+      if target_node_id == node.id || target_node_id == node.text || found
+        node.children.each do |child|
+          child_node = @nodes.detect { |n| n.text == child }
+          # if the child document is an empty string, it is a missing node
+          if child_node.missing
+            descendents << child_node.text
+          else
+            descendents << child_node.id
+          end
+          self.get_all_lineage_ids(target_node_id, child_node, ancestors.clone, descendents, found=true)
+        end
+        return ancestors, descendents
+      # target node not yet found, build ancestors
+      else
+        # if the node document is an empty string, it is a missing node
+        if node.missing
+          ancestors << node.text
+        else
+          ancestors << node.id
+        end
+        results = []
+        node.children.each do |child|
+          child_node = @nodes.detect { |n| n.text == child }
+          results.concat(self.get_all_lineage_ids(target_node_id, child_node, ancestors.clone))
+        end
+        return results.select { |r| !r.nil? }
+      end
+    end
+
+    def get_sibling_ids(target_node_id, node=@nodes.detect { |n| n.text == @root }, parent=nil)
+      return [] if node.text === @root
+      # found target node
+      if target_node_id == node.id || target_node_id == node.text
+        return parent.children.select { |c| c.id }
+      # target node not yet found
+      else
+        node.children.each do |child|
+          child_node = @nodes.detect { |n| n.text == child }
+          self.get_sibling_ids(target_node_id, child_node, node)
+        end
+      end
+    end
+
+    # find the parent and children of the 'target_doc'.
+    def find_doc_ancestors_and_children_metadata(target_doc)
+      fname = File.basename(target_doc.basename, File.extname(target_doc.basename))
+      node = @nodes.detect { |n| n.text == fname }
+      return node.ancestors, node.children
+    end
+
+    def in_tree?(fname)
+      return @nodes.map(&:text).include?(fname)
+    end
+
+    # ...for debugging
+
+    def to_s
+      puts build_tree_str
+    end
+
+    def print_nodes
+      puts "# Tree Nodes: "
+      @nodes.each do |node|
+        puts "# #{node.to_s}"
+      end
+    end
+
+    def build_tree_str(cur_node_name = @root, prefix = '')
+      output = "#{cur_node_name}\n"
+      node = @nodes.find { |n| n.text == cur_node_name }
+      if node.nil?
+        puts `SemTree.build_tree_str: error: nil node for name '#{cur_node_name}'`
+        return output
+      end
+      node.children.each_with_index do |child, index|
+        is_last_child = index == node.children.length - 1
+        child_prefix = prefix + (is_last_child ? '└── ' : '├── ')
+        grandchild_prefix = prefix + (is_last_child ? '    ' : '|   ')
+        subtree = build_tree_str(child, grandchild_prefix)
+        output += "#{child_prefix}#{subtree}"
+      end
+      return output
+    end
+  end
+
+  # class TreeNode
+  #   attr_accessor :ancestors  # array of strings for the text of each node from root to current (leaf)
+  #   attr_accessor :children   # array of strings for the text of each child node
+  #   attr_accessor :doc        # the associated jekyll document
+  #   attr_accessor :text       # text of the node -- used for primary identification in tree and must be uniquely named
+  #   attr_accessor :url        # jekyll blog url for the given node/page
+
+  #   def initialize(text, ancestors=[], children=[], url="", doc="")
+  #     @text = text
+  #     @ancestors = ancestors
+  #     # optional
+  #     @children = children
+  #     @url = url.nil? ? "" : url
+  #     @doc = doc
+  #   end
+
+  #   def missing
+  #     return @doc == ""
+  #   end
+
+  #   def type
+  #     return @doc.type
+  #   end
+
+  #   def to_s
+  #     "<Node text: '#{@text}', ancestors: #{@ancestors}, children: #{@children}"
+  #   end
+  # end
+
+  class TreeNode
+    attr_accessor :id         # node id -- should be unique
+    attr_accessor :ancestors  # array of strings for the text of each node from root to current (leaf)
+    attr_accessor :children   # array of strings for the text of each child node
+    attr_accessor :doc        # the associated jekyll document
+    attr_accessor :level      # level in the tree
+    attr_accessor :line       # line of the index file content
+                              # does not include stripped content (e.g. yaml);
+                              # value for index docs is -1
+    attr_accessor :text       # text of the node -- used for primary identification in tree and must be uniquely named
+    attr_accessor :url        # jekyll blog url for the given node/page
+
+    def initialize(text, ancestors=[], level=-1, line=-1, children=[], doc="")
+      # mandatory
+      @text = text
+      @ancestors = ancestors
+      # optional
+      @children = children
+      @level = level
+      @line = line
+      @doc = doc
+    end
+
+    def missing
+      return @doc == ''
+      # return (@doc.nil? || (@doc.class == String))
+    end
+
+    def to_s
+      "<Node text: '#{@text}', ancestors: #{@ancestors}, children: #{@children}"
+    end
+
+    # doc properties
+
+    def id
+      return (self.missing) ? @text : @doc.url
+    end
+
+    def url
+      return (self.missing) ? @text : @doc.url
+    end
+
+    def title
+      return (self.missing) ? @text : @doc.data['title']
+    end
+
+    def type
+      return (self.missing) ? 'zombie' : @doc.type
+    end
+
+    # for legacy 'jekyll-namespaces' calls
+    def namespace
+      return false
+    end
+  end
+end

data/lib/jekyll-semtree/version.rb

@@ -3,7 +3,7 @@
 module Jekyll
   module SemTree
 
-    VERSION = "0.0.1"
+    VERSION = "0.0.3"
 
   end
 end

data/lib/jekyll-semtree.rb

@@ -1,10 +1,170 @@
 # frozen_string_literal: true
+require "jekyll"
 
+require_relative "jekyll-semtree/patch/context"
+require_relative "jekyll-semtree/patch/site"
+require_relative "jekyll-semtree/tree"
 require_relative "jekyll-semtree/version"
 
+
 module Jekyll
   module SemTree
-    class Error < StandardError; end
-    # Your code goes here...
+
+    class Generator < Jekyll::Generator
+      # for testing
+      attr_reader :config
+
+      CONVERTER_CLASS = Jekyll::Converters::Markdown
+      # config keys
+      CONFIG_KEY        = "semtree"
+      ENABLED_KEY       = "enabled"
+      EXCLUDE_KEY       = "exclude"
+      DOCTYPE_KEY       = "doctype"
+      PAGE_KEY          = "map"
+      ROOT_KEY          = "root"
+      VIRTUAL_TRUNK_KEY = "virtual_trunk"
+
+      def initialize(config)
+        @config ||= config
+      end
+
+      def generate(site)
+        return if disabled?
+
+        # setup site
+        @site = site
+        @context ||= Context.new(site)
+
+        # setup docs (based on configs)
+        # unless @site.keys.include('doc_mngr') # may have been installed by jekyll-wikirefs or jekyll-wikilinks already
+        #   require_relative "jekyll-semtree/patch/doc_manager"
+        #   Jekyll::Hooks.register :site, :post_read do |site|
+        #     if !self.disabled?
+        #       site.doc_mngr = Jekyll::SemTree::DocManager.new(site)
+        #     end
+        #   end
+        # end
+
+        # setup markdown docs
+        docs = []
+        docs += site.pages # if !$wiki_conf.exclude?(:pages)
+        docs += site.docs_to_write.filter { |d| !self.excluded?(d.type) }
+        @md_docs = docs.filter { |doc| self.markdown_extension?(doc.extname) }
+        if @md_docs.empty?
+          Jekyll.logger.warn("Jekyll-SemTree: No semtree files to process.")
+        end
+
+        # tree setup
+        # root
+        root_doc = @md_docs.detect { |d| d.data['slug'] == self.option_root_name }
+        if root_doc.nil?
+          Jekyll.logger.error("Jekyll-SemTree: No root doc detected.")
+        end
+        # trunk / index docs
+        index_docs = @site.docs_to_write.filter { |d| d.type.to_s == self.option_doctype_name }
+        if index_docs.empty?
+          Jekyll.logger.error("Jekyll-SemTree: No trunk (index docs) detected.")
+        end
+        # tree content hash
+        tree_hash = build_tree_hash(@site.collections[self.option_doctype_name])
+        if tree_hash.empty?
+          Jekyll.logger.error("Jekyll-SemTree: No trunk (index docs) detected.")
+        end
+        if root_doc.nil? || index_docs.empty? || tree_hash.empty?
+          Jekyll.logger.error("Jekyll-SemTree: Unable to build semantic tree.")
+          return
+        end
+        # build tree
+        @site.tree = Tree.new(tree_hash, root_doc, option_virtual_trunk)
+
+        # generate metadata
+        @site.tree.nodes.each do |n|
+          doc = @md_docs.detect { |d| n.text == File.basename(d.basename, File.extname(d.basename)) }
+          if !doc.nil?
+            n.doc = doc
+            ancestorNames, childrenNames = @site.tree.find_doc_ancestors_and_children_metadata(doc)
+            doc.data['ancestors'] = fnames_to_urls(ancestorNames)
+            doc.data['children'] = fnames_to_urls(childrenNames)
+          end
+        end
+        map_doc = @md_docs.detect { |d| option_page == File.basename(d.basename, File.extname(d.basename)) }
+        # root_node = @site.tree.nodes.detect { |n| n.text == @site.tree.root }
+        map_doc.data['nodes'] = @site.tree.nodes.map { |n| {
+          'text' => n.text,
+          'url' => n.url,
+          'ancestors' => n.ancestors,
+          'children' => n.children,
+          }
+        }
+        dangling_entries = []
+        @site.collections['entries'].each do |d|
+          fname = File.basename(d.basename, File.extname(d.basename))
+          if !@site.tree.in_tree?(fname)
+            dangling_entries << fname
+          end
+        end
+        Jekyll.logger.warn("Jekyll-SemTree: entries not listed in the tree: #{dangling_entries}")
+      end
+
+      def fnames_to_urls(fnames)
+        docs = []
+        fnames.each do |fname|
+          doc = @md_docs.detect { |d| fname == File.basename(d.basename, File.extname(d.basename)) }
+          docs << (doc.nil? ? fname : doc.url)
+        end
+        return docs
+      end
+
+      def build_tree_hash(collection_doc)
+        tree_data = {}
+        collection_doc.each do |d|
+          if d.type.to_s == self.option_doctype_name
+            fname = File.basename(d.basename, File.extname(d.basename))
+            tree_data[fname] = d.content
+          end
+        end
+        return tree_data
+      end
+
+      # config helpers
+
+      def disabled?
+        option(ENABLED_KEY) == false
+      end
+
+      def excluded?(type)
+        return false unless option(EXCLUDE_KEY)
+        return option(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_root_name
+        return option(ROOT_KEY) ? @config[CONFIG_KEY][ROOT_KEY] : 'i.bonsai'
+      end
+
+      def option_doctype_name
+        return option(DOCTYPE_KEY) ? @config[CONFIG_KEY][DOCTYPE_KEY] : 'index'
+      end
+
+      def option_virtual_trunk
+        return option(VIRTUAL_TRUNK_KEY) ? @config[CONFIG_KEY][VIRTUAL_TRUNK_KEY] : false
+      end
+
+      def option_page
+        return option(PAGE_KEY) ? @config[CONFIG_KEY][PAGE_KEY] : 'map'
+      end
+
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-semtree
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 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
@@ -32,14 +32,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/jekyll-semtree.rb
+- lib/jekyll-semtree/patch/context.rb
+- lib/jekyll-semtree/patch/doc_manager.rb
+- lib/jekyll-semtree/patch/site.rb
+- lib/jekyll-semtree/tree.rb
 - lib/jekyll-semtree/version.rb
-homepage: https://github.com/manunamz/jekyll-semtree
+homepage: https://github.com/wikibonsai/jekyll-semtree
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/manunamz/jekyll-semtree
-  source_code_uri: https://github.com/manunamz/jekyll-semtree
-  changelog_uri: https://github.com/manunamz/jekyll-semtree/blob/main/CHANGELOG.md
+  homepage_uri: https://github.com/wikibonsai/jekyll-semtree
+  source_code_uri: https://github.com/wikibonsai/jekyll-semtree
+  changelog_uri: https://github.com/wikibonsai/jekyll-semtree/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -55,8 +59,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 jekyll support for a semantic tree (in markdown).
 test_files: []