jekyll-namespaces 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b18126c3527c30dd23fe45e39414c918bcc046bcc85a9955e43476457298be2
-  data.tar.gz: 0a61c1b500793f8eded07a8a55575b25f7e6e9983dbac9df4a77c0591c0c220c
+  metadata.gz: 6a486b2fb9c89ac6247a8650948f1111e81836bb374afe532cb08e254dccd831
+  data.tar.gz: 94e8c5b5404a1f4550fe2cc6fc06f40df372f61c7ba65a901bda40b4cca6766c
 SHA512:
-  metadata.gz: 5ff7599ba50975db33b0d72f14e41606e5b9c0d21126732271dfbc152a08d4c9c9a9dcc422a22bf671bf864ebc637ce14bc58f25c1cd792174ea22b6f64894e5
-  data.tar.gz: 9f3c5053343f86090eac806c00bcf806034d34fb31ddbb64f17efda9060bd17bf78378482f84f09902bc557b3581bbcc2c2eb2b24ade705bd516136d08e15656
+  metadata.gz: c214a76c788e7fe52bc27ec85977546237f714be562973c433fa94f94764c8c88fdf0202a595f9845b85a43b8549c23b9707b05b33176d2f13014395d0da03cb
+  data.tar.gz: e0a73b6a22a2c80d32f8142152d46da831f32e73989daa0271766c894cd1debe5245bf36d6aa750556a494ec6560248a98b3144af3edccbd4fa1bfec7ee7c962

data/lib/jekyll-namespaces/site.rb

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

data/lib/jekyll-namespaces/tree.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+require "jekyll"
+
+module Jekyll
+
+  class Tree
+    attr_reader :root
+
+    def initialize(root_doc, md_docs)
+      @root = Node.new('root', root_doc.data['id'], root_doc.data['title'], root_doc.url, root_doc)
+
+      md_docs.each do |doc|
+        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
+          self.add_path(doc)
+        end
+      end
+
+      # print_tree(root)
+    end
+
+    # add unique path for the given doc to tree (node-class).
+    def add_path(doc, node=nil, depth=1)
+      node = @root if depth == 1
+      Jekyll.logger.error("Incorrect node in tree.add_path") if node == nil
+      levels = doc.data['slug'].split(/\s|\./)
+      # handle doc if the given node was not root and we are at depth
+      if depth == levels.length
+        cur_nd_namespace = 'root' + '.' + doc.data['slug']
+        cur_nd_id = doc.data['id']
+        cur_nd_title = doc.data['title']
+        cur_nd_url = doc.url
+
+        cur_node = node.children.detect {|c| c.namespace == cur_nd_namespace }
+        # create node if one does not exist
+        if cur_node.nil?
+          new_node = Node.new(cur_nd_namespace, cur_nd_id, cur_nd_title, cur_nd_url, doc)
+          node.children << new_node
+        # fill-in node if one already exists
+        else
+          cur_node.fill(cur_nd_id, cur_nd_title, cur_nd_url, doc)
+        end
+        return
+      # create temp node and recurse
+      else
+        cur_namespace = 'root' + '.' + levels[0..(depth - 1)].join('.')
+        unless node.children.any? { |c| c.namespace == cur_namespace }
+          new_node = Node.new(cur_namespace)
+          node.children << new_node
+        else
+          new_node = node.children.detect { |c| c.namespace == cur_namespace }
+        end
+      end
+      self.add_path(doc, new_node, depth + 1)
+    end
+
+    def get_all_relative_ids(target_node_id, node=@root, ancestors=[], descendents=[], found=false)
+      # found target node, stop adding ancestors and build descendents
+      if target_node_id == node.url || target_node_id == node.namespace || found
+        node.children.each do |child_node|
+          # if the child document is an empty string, it is a missing node
+          if child_node.missing
+            descendents << child_node.namespace
+          else
+            descendents << child_node.doc.url
+          end
+          self.get_all_relative_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.namespace
+        else
+          ancestors << node.doc.url
+        end
+        results = []
+        node.children.each do |child_node|
+          results.concat(self.get_all_relative_ids(target_node_id, child_node, ancestors.clone))
+        end
+        return results.select { |r| !r.nil? }
+      end
+    end
+
+    # find the parent and children of the 'target_doc'.
+    # ('node' as in the current node, which first is root.)
+    def find_doc_immediate_relatives(target_doc, node=nil, ancestors=[])
+      node = @root if ancestors == []
+      Jekyll.logger.error("Incorrect node in tree.find_doc_immediate_relatives") if node == nil
+      if target_doc == node.doc
+        children = []
+        node.children.each do |child|
+          # if the child document is an empty string, it is a missing node
+          if child.missing
+            children << child.namespace
+          else
+            children << child.doc.url
+          end
+        end
+        return ancestors, children
+      else
+        # if the node document is an empty string, it is a missing node
+        if node.missing
+          ancestors << node.namespace
+        else
+          ancestors << node.doc.url
+        end
+        results = []
+        node.children.each do |child_node|
+          results.concat(self.find_doc_immediate_relatives(target_doc, child_node, ancestors.clone))
+        end
+        return results.select { |r| !r.nil? }
+      end
+    end
+
+    # ...for debugging
+    def print_tree(node, ancestors=[])
+      Jekyll.logger.warn "Ancestors: ", ancestors.length
+      Jekyll.logger.warn node
+      Jekyll.logger.warn "Children: ", node.children
+      ancestors.append(node.id)
+      node.children.each do |child_node|
+        self.print_tree(child_node, ancestors.clone)
+      end
+    end
+  end
+
+  class Node
+    attr_accessor :namespace, :id, :title, :children, :url, :doc
+
+    def initialize(namespace, id="", title="", url="", doc="")
+      # mandatory
+      @namespace = namespace
+      # optional
+      @id = id.to_s
+      @title = title
+      @url = url.nil? ? "" : url
+      @doc = doc
+      # auto-init
+      @children = []
+    end
+
+    def fill(id, title, url, doc)
+      @id = id
+      @title = title
+      @url = url
+      @doc = doc
+    end
+
+    def missing
+      return @doc == ""
+    end
+
+    def type
+      return @doc.type
+    end
+
+    def to_s
+      "namespace: #{@namespace}"
+    end
+  end
+
+end

data/lib/jekyll-namespaces/version.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
-module JekyllNamespaces
-  VERSION = "0.0.1"
+module Jekyll
+  module Namespaces
+
+    VERSION = "0.0.2"
+    
+  end
 end

data/lib/jekyll-namespaces.rb

@@ -2,237 +2,97 @@
 require "jekyll"
 
 require_relative "jekyll-namespaces/context"
-require_relative "jekyll-namespaces/node"
+require_relative "jekyll-namespaces/site"
+require_relative "jekyll-namespaces/tree"
 require_relative "jekyll-namespaces/version"
 
-module JekyllNamespaces
-  class Generator < Jekyll::Generator
-    attr_accessor :site, :config
-
-    # Use Jekyll's native relative_url filter
-    include Jekyll::Filters::URLFilters
-
-    CONVERTER_CLASS = Jekyll::Converters::Markdown
-    # config
-    CONFIG_KEY = "namespaces"
-    ENABLED_KEY = "enabled"
-    INCLUDE_KEY = "include"
-    # graph config
-    GRAPH_DATA_KEY = "d3_graph_data"
-    ENABLED_GRAPH_DATA_KEY = "enabled"
-    EXCLUDE_GRAPH_KEY = "exclude"
-    GRAPH_ASSETS_LOCATION_KEY = "path"
-
-    def initialize(config)
-      @config ||= config
-      @testing ||= config['testing'] if config.keys.include?('testing')
-    end
-
-    def generate(site)
-      return if disabled?
-      
-      # setup site
-      @site = site
-      @context ||= Context.new(site)
-
-      # setup markdown docs
-      docs = []
-      docs += site.pages if include?(:pages)
-      docs += site.docs_to_write.filter { |d| include?(d.type) }
-      @md_docs = docs.filter {|doc| markdown_extension?(doc.extname) }
-      
-      # setup tree
-      root_doc = @md_docs.detect {|doc| doc.data['slug'] == 'root' }
-      root = Node.new(root_doc.data['id'], 'root', root_doc.data['title'], root_doc)
-      # build tree
-      @md_docs.each do |cur_doc|
-        # add path to tree
-        if !cur_doc.data['slug'].nil? and cur_doc.data['slug'] != 'root'
-          self.add_path(root, cur_doc)
-        end
-      end
-      
-      # print_tree(root)
-      
-      # generate tree metadata
-      @md_docs.each do |cur_doc|
-        if !excluded_in_graph?(cur_doc)
-          # TODO: cur_doc.data['namespace'] = cur_doc.basename_without_ext
-          cur_doc.data['namespace'] = cur_doc.basename[0...-3]
-          cur_doc.data['ancestors'], cur_doc.data['children'] = self.find_doc_immediate_relatives(cur_doc, root)
-        end
-      end
-      # graph
-      if !disabled_graph_data?
-        self.write_graph(root)
-      end
-    end
-
-    # config helpers
-
-    def disabled?
-      option(ENABLED_KEY) == false
-    end
+module Jekyll
+  module Namespaces
 
-    def include?(type)
-      return false unless option(INCLUDE_KEY)
-      return option(INCLUDE_KEY).include?(type.to_s)
-    end
+    class Generator < Jekyll::Generator
+      # for testing
+      attr_reader :config
 
-    def markdown_extension?(extension)
-      markdown_converter.matches(extension)
-    end
-
-    def markdown_converter
-      @markdown_converter ||= @site.find_converter_instance(CONVERTER_CLASS)
-    end
+      CONVERTER_CLASS = Jekyll::Converters::Markdown
+      # config
+      CONFIG_KEY = "namespaces"
+      ENABLED_KEY = "enabled"
+      EXCLUDE_KEY = "exclude"
 
-    def option(key)
-      config[CONFIG_KEY] && config[CONFIG_KEY][key]
-    end
+      def initialize(config)
+        @config ||= config
+      end
 
-    # graph config helpers
+      def generate(site)
+        return if disabled?
+        self.old_config_warn()
+
+        # setup site
+        @site = site
+        @context ||= Context.new(site)
+
+        # setup markdown docs
+        docs = []
+        docs += @site.pages if !excluded?(:pages)
+        docs += @site.docs_to_write.filter { |d| !excluded?(d.type) }
+        @md_docs = docs.filter { |doc| markdown_extension?(doc.extname) }
+        if @md_docs.empty?
+          Jekyll.logger.debug("No documents to process.")
+        end
 
-    def disabled_graph_data?
-      option_graph(ENABLED_GRAPH_DATA_KEY) == false
-    end
+        # tree setup
+        root_doc = @md_docs.detect { |d| d.data['slug'] == 'root' }
+        if root_doc.nil?
+          Jekyll.logger.debug("No root.md detected.")
+        end
+        @site.tree = Tree.new(root_doc, @md_docs)
 
-    def excluded_in_graph?(type)
-      return false unless option_graph(EXCLUDE_GRAPH_KEY)
-      return option_graph(EXCLUDE_GRAPH_KEY).include?(type.to_s)
-    end
+        # generate metadata
+        @md_docs.each do |doc|
+          doc.data['namespace'] = doc.data['slug']
+          doc.data['ancestors'], doc.data['children'] = @site.tree.find_doc_immediate_relatives(doc)
+        end
 
-    def has_custom_assets_path?
-      return !!option_graph(GRAPH_ASSETS_LOCATION_KEY)
-    end
+      end
 
-    def option_graph(key)
-      config[GRAPH_DATA_KEY] && config[GRAPH_DATA_KEY][key]
-    end
+      # config helpers
 
-    # helpers
-
-    # add unique path for the given doc to tree (node-class).
-    def add_path(node, doc, depth=1)
-      chunked_namespace = doc.data['slug'].split(/\s|\./)
-      # handle doc if the given node was not root and we are at depth
-      if depth == chunked_namespace.length
-        cur_nd_namespace = 'root' + '.' + doc.data['slug']
-        cur_nd_id = doc.data['id']
-        cur_nd_title = doc.data['title']
-        # create node if one does not exist
-        unless node.children.any?{ |c| c.namespace == cur_nd_namespace }
-          new_node = Node.new(cur_nd_id, cur_nd_namespace, cur_nd_title, doc)
-          node.children << new_node
-        # fill-in node if one already exists
-        else
-          cur_node = node.children.detect {|c| c.namespace == cur_nd_namespace }
-          cur_node.id = cur_nd_id
-          cur_node.title = cur_nd_title
-          cur_node.doc = doc
-        end
-        return
-      # create temp node and recurse
-      else
-        cur_namespace = 'root' + '.' + chunked_namespace[0..(depth - 1)].join('.')
-        unless node.children.any?{ |c| c.namespace == cur_namespace }
-          new_node = Node.new('', cur_namespace, '', '')
-          node.children << new_node
-        else
-          new_node = node.children.detect {|c| c.namespace == cur_namespace }
-        end
+      def disabled?
+        option(ENABLED_KEY) == false
       end
-      self.add_path(new_node, doc, depth + 1)
-    end
 
-    # find the parent and children of the 'target_doc'.
-    # ('node' as in the current node, which first is root.)
-    def find_doc_immediate_relatives(target_doc, node, ancestors=[])
-      if target_doc.data['id'] == node.id
-        children = []
-        node.children.each do |child|
-          if child.id == ''
-            children << { 
-              'id' => '',
-              'title' => child.namespace.match('([^.]*$)')[0].gsub('-', ' ')
-            }
-          else
-            children << child.doc
-          end
-        end
-        return ancestors, children
-      else
-        if node.id == ''
-          ancestors << { 
-            'id' => '',
-            'title' => node.namespace.match('([^.]*$)')[0].gsub('-', ' ')
-          }
-        else
-          ancestors << node.doc
-        end
-        results = []
-        node.children.each do |child_node|
-          results.concat self.find_doc_immediate_relatives(target_doc, child_node, ancestors.clone)
-        end
-        return results.select { |r| !r.nil? }
+      def excluded?(type)
+        return false unless option(EXCLUDE_KEY)
+        return option(EXCLUDE_KEY).include?(type.to_s)
       end
-    end
 
-    # ...for debugging
-    def print_tree(node, ancestors=[])
-      Jekyll.logger.warn "Ancestors: ", ancestors.length
-      Jekyll.logger.warn node
-      Jekyll.logger.warn "Children: ", node.children
-      ancestors.append(node.id)
-      node.children.each do |child_node|
-        self.print_tree(child_node, ancestors.clone)
+      def markdown_extension?(extension)
+        markdown_converter.matches(extension)
       end
-    end
 
-    # graph helpers
-
-    # convert tree (node-class) to json
-    def tree_to_json(baseurl, node, json_node={})
-      if node.id.empty?
-        Jekyll.logger.warn "Tree node missing: ", node.namespace
-        label = node.namespace.match('([^.]*$)')[0].gsub('-', ' ')
-        node_url = ''
-      else
-        label = node.title
-        node_url = relative_url(node.doc.url)
+      def markdown_converter
+        @markdown_converter ||= @site.find_converter_instance(CONVERTER_CLASS)
       end
-      json_children = []
-      node.children.each do |child|
-        new_child = self.tree_to_json(baseurl, child)
-        json_children.append(new_child)
+
+      def option(key)
+        @config[CONFIG_KEY] && @config[CONFIG_KEY][key]
       end
-      json_node = {
-        # "id": node.id,
-        "id": node_url,
-        "namespace": node.namespace,
-        "label": label,
-        "children": json_children,
-        "url": node_url,
-      }
-      return json_node
-    end
 
-    def write_graph(root)
-      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
+      # !! deprecated !!
+
+      def option_exist?(key)
+        @config[CONFIG_KEY] && @config[CONFIG_KEY].include?(key)
       end
-      # from: https://github.com/jekyll/jekyll/issues/7195#issuecomment-415696200
-      static_file = Jekyll::StaticFile.new(site, site.source, assets_path, "graph-tree.json")
-      json_formatted_tree = self.tree_to_json(@site.baseurl, root)
-      File.write(@site.source + static_file.relative_path, JSON.dump(
-        json_formatted_tree
-      ))
-      # 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)
+
+      def old_config_warn()
+        if @config.include?("d3_graph_data")
+          Jekyll.logger.warn "As of 0.0.2, 'd3_graph_data' should now be 'd3' and requires the 'jekyll-d3' plugin."
+        end
+        if option_exist?("include")
+          Jekyll.logger.warn "As of 0.0.2, all markdown files are processed by default. Use 'exclude' config to exclude document types."
+        end
       end
     end
+
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-namespaces
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - manunamz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-23 00:00:00.000000000 Z
+date: 2021-09-17 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -19,11 +19,12 @@ extra_rdoc_files: []
 files:
 - lib/jekyll-namespaces.rb
 - lib/jekyll-namespaces/context.rb
-- lib/jekyll-namespaces/node.rb
+- lib/jekyll-namespaces/site.rb
+- lib/jekyll-namespaces/tree.rb
 - lib/jekyll-namespaces/version.rb
 homepage: https://github.com/manunamz/jekyll-namespaces
 licenses:
-- MIT
+- GPL3
 metadata:
   homepage_uri: https://github.com/manunamz/jekyll-namespaces
   source_code_uri: https://github.com/manunamz/jekyll-namespaces

data/lib/jekyll-namespaces/node.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-# helper class for tree-building.
-class Node
-  attr_accessor :id, :namespace, :title, :children, :doc
-
-  def initialize(id, namespace, title, doc)
-    @id = id
-    @children = []
-    @namespace = namespace
-    @title = title
-    @doc = doc
-  end
-
-  def type
-    return doc.type
-  end
-
-  def to_s
-    "namespace: #{@namespace}"
-  end
-end