jekyll-rpg 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dbaff86bfac3c1c821e36321851b94f3cc5e7dfa293543dc49809dfa3f331b1
-  data.tar.gz: e45e59b1260ae0b3f7c853e1780e436d123df64e604fdefbeac1f75bd1b036d1
+  metadata.gz: 16f14fd9c3d40e94808552f1b4a38813cb1f75e97a50ab5f69acbd57026dadb2
+  data.tar.gz: 770ce2e9837de58c045cf32a2b20272f65b237420f3c733ade1081d6aee6d7b4
 SHA512:
-  metadata.gz: cf357ffe093de9d47beb3f7d9eb26ebe555c6ae312e10d54f397b81e7c6b0628cb083ef8f5f97bee46997970380531eb1ba7ae5c64411cd8b64cbd9d478f0442
-  data.tar.gz: 645a38316b3b70083c0783c2591f9565fbeca5c81fee926ceba3cbb6c3d6d785a595de74b2a0e74eb5155d62fc9eb50a5a519f303ec2e353435782d2d2c529b7
+  metadata.gz: 3e0dd4929f15a759ead437924a0ed5efc49e336a1cdb14474b5b008e060af0300f693c8280e8e7e9f921c8a40eaad10070b7acac786cbcadc0bc5a86ba198018
+  data.tar.gz: 620e850bb614a48458c7b78326af3d3a45f47c620b597d8a4aef217f9ded8106a2be791cb7278224f0f35d892f79c7b72b0fce1a279fa6fefebdeefcbd8f8aad

data/lib/collection_document.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module JekyllRPG
+  # Represents a document that may be in a Jekyll collection
+  class CollectionDocument
+    attr_accessor :name, :collection, :slug, :written
+
+    def extract_doc(doc)
+      @name = doc.data['name']
+      @collection = doc.collection.label
+      @slug = doc.data['slug']
+      @written = true
+      self
+    end
+
+    # extracts link text, collection and slug
+    # [@name](/@collection/@slug)
+    def extract_markdown(site, link)
+      @collection = link[%r{(?<=/).*(?=/)}]
+      @slug = link[%r{(?<=/)(?:(?!/).)*?(?=\))}]
+      @written = document_exists(site)
+      @name = @written ? find_document(site).data['name'] : link[/(?<=\[).*?(?=\])/]
+      self
+    end
+
+    # Checks whether document exists in a site
+    def document_exists(site)
+      !site.collections[@collection].nil? && !find_document(site).nil?
+    end
+
+    # Find a document based on its collection and slug
+    def find_document(site)
+      site.collections[@collection].docs.find { |doc| doc.data['slug'] == @slug }
+    end
+
+    def markdown_link
+      "[#{@name}](/#{@collection}/#{@slug})"
+    end
+
+    def hash
+      {
+        'name' => @name,
+        'collection' => @collection,
+        'slug' => @slug,
+        'link' => markdown_link
+      }
+    end
+  end
+end

data/lib/edge.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module JekyllRPG
+  # Edge between two documents
+  class Edge
+    attr_accessor :reference, :referent
+
+    def initialize(referent, reference)
+      @referent = referent
+      @reference = reference
+    end
+
+    def hash
+      {
+        'reference' => reference.hash,
+        'referent' => referent.hash
+      }
+    end
+  end
+end

data/lib/graph.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module JekyllRPG
+  # Graph of relationships between CollectionDocuments
+  class Graph
+    attr_accessor :edges
+
+    def initialize
+      @edges = []
+    end
+
+    # Get the information for every page the current doc is referenced in
+    # And push links to an array that represents the collections of those pages
+    def document_references(doc)
+      document_hash = {}
+
+      referenced_in(doc).each do |reference|
+        document_hash[reference.collection] = [] unless document_hash.key?(reference.collection)
+        document_hash[reference.collection].push(reference.markdown_link)
+      end
+
+      document_hash.each do |k, v|
+        document_hash[k] = v.uniq
+      end
+      document_hash
+    end
+
+    # Based on the graph, returns edges that a specific document is the referent of
+    def referenced_in(doc)
+      collection = doc.collection.label
+      slug = doc.data['slug']
+      @edges.select do |edge|
+        edge.reference.collection == collection && edge.reference.slug == slug
+      end.map(&:referent)
+    end
+
+    # Based on the graph, returns documents that are referenced, but do not exist yet
+    def unwritten
+      @edges.reject do |edge|
+        edge.reference.written
+      end
+    end
+
+    def hash
+      @edges.map(&:hash)
+    end
+  end
+end

data/lib/jekyll-rpg.rb

@@ -9,7 +9,7 @@ module JekyllRPG
   Jekyll::Hooks.register :site, :post_read do |site|
     ref = References.new(site)
 
-    site.data['graph'] = ref.hashed_graph
+    site.data['graph'] = ref.graph.hash
 
     site.data['broken_links'] = ref.broken_links
   end

data/lib/reference_table.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module JekyllRPG
+  # Generates Reference Table
+  class ReferenceTable
+    attr_accessor :html
+
+    def initialize(site, doc)
+      @html = ''
+      @html = refs_table(doc.data['referenced_by']) if refs_table_required(site, doc)
+    end
+
+    # Determines if refs table is required based on document,
+    # then collection, then site
+    def refs_table_required(site, doc)
+      if doc.data.key?('refs')
+        doc.data['refs']
+      elsif site.config['collections'][doc.collection.label].key?('refs')
+        site.config['collections'][doc.collection.label]['refs']
+      elsif site.config.key?('refs')
+        site.config['refs']
+      end
+    end
+
+    def refs_table(refs)
+      table = <<~TABLE
+        # Referenced By:
+        <table>
+          <thead>
+            <tr>
+              <th>Collection</th>
+              <th>Links</th>
+            </tr>
+          </thead>
+          <tbody>
+            #{refs_rows(refs)}
+          </tbody>
+        </table>
+      TABLE
+      table
+    end
+
+    def refs_rows(refs)
+      row = ''
+      refs.each do |reference|
+        row += <<~ROW
+          <tr>
+            <td markdown="span"><b> #{reference[0].capitalize} </b></td>
+            <td markdown="span"> #{refs_links(reference)} </td>
+          </tr>
+        ROW
+      end
+      row
+    end
+
+    def refs_links(reference)
+      links = ''
+      reference[1].each do |link|
+        links += " - #{link} <br>"
+      end
+      links
+    end
+  end
+end

data/lib/references.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require 'collection_page'
-require 'pry'
+require 'collection_document'
+require 'edge'
+require 'graph'
+require 'reference_table'
 
 module JekyllRPG
   # References within Jekyll Collections
@@ -10,59 +12,53 @@ module JekyllRPG
 
     def initialize(site)
       @site = site
-      @graph = []
+      @graph = Graph.new
       @broken_links = []
       @collection_keys = @site.collections.keys - ['posts']
 
+      reference_pass
+      referent_pass
+
+      # Create list of broken links
+      @graph.unwritten.each do |edge|
+        @broken_links.push(edge.hash)
+      end
+    end
+
+    # Generating data on how documents reference other documents
+    def reference_pass
       # Parse references from markdown links
-      @collection_keys.each do |collection|
-        @site.collections[collection].docs.each do |doc|
-          if doc.data['dm'] && !@site.config['dm_mode']
-            doc.data['published'] = false
-          else
-            referent = CollectionPage.new(
-              doc.data['name'],
-              doc.collection.label,
-              doc.data['slug'],
-              true
-            )
-            markdown_links(doc).each do |reference|
-              @graph.push(edge(referent, reference))
-            end
+      collection_documents.each do |doc|
+        # Do not publish or reference a page if the site is not in DM Mode
+        # And the page is marked as for dms
+        if doc.data['dm'] && !@site.config['dm_mode']
+          doc.data['published'] = false
+        else
+          referent = CollectionDocument.new.extract_doc(doc)
+          markdown_links(doc).each do |link|
+            reference = CollectionDocument.new.extract_markdown(@site, link)
+            @graph.edges.push(Edge.new(referent, reference))
           end
         end
       end
+    end
 
+    # Generating data on how documents are referenced to
+    def referent_pass
       # For each collection page, add where it is referenced
-      @collection_keys.each do |collection|
-        @site.collections[collection].docs.each do |doc|
-          page_refs = {}
+      collection_documents.each do |doc|
+        # Put the reference data on the doc
+        doc.data['referenced_by'] = @graph.document_references(doc)
 
-          # Get the information for every page the current doc is referenced in
-          # And push links to an array that represents the collections of those pages
-          referenced_in(collection, doc.data['slug']).each do |reference|
-            page_refs[reference.collection] = [] unless page_refs.key?(reference.collection)
-            page_refs[reference.collection].push(reference.markdown_link)
-          end
-
-          # Make sure links in collections are unique
-          page_refs.each do |k, v|
-            page_refs[k] = v.uniq
-          end
-
-          # Put the reference data on the doc
-          doc.data['referenced_by'] = page_refs
-
-          # If the references table option is configured, append the table
-          if refs_table_required(doc)
-            doc.content = doc.content + refs_table(doc.data['referenced_by'])
-          end
-        end
+        # If the references table option is configured, append the table
+        table = ReferenceTable.new(@site, doc).html
+        doc.content = doc.content + table
       end
+    end
 
-      # Create list of broken links
-      unwritten_pages.each do |edge|
-        @broken_links.push(edge_hash(edge))
+    def collection_documents
+      @collection_keys.flat_map do |collection|
+        @site.collections[collection].docs
       end
     end
 
@@ -72,130 +68,5 @@ module JekyllRPG
     def markdown_links(doc)
       doc.to_s.scan(%r{(?<=[^!])\[.*?\]\(/.*?/.*?\)})
     end
-
-    # returns link text, collection and slug
-    # [0](/1/2) - as a [0, 1, 2]
-    def link_components(link)
-      [link[/(?<=\[).*?(?=\])/], link[%r{(?<=/).*(?=/)}], link[%r{(?<=/)(?:(?!/).)*?(?=\))}]]
-    end
-
-    # Find a document based on its collection and slug
-    def find_page(collection, slug)
-      @site.collections[collection].docs.find { |doc| doc.data['slug'] == slug }
-    end
-
-    # Returns true if document cannot be found in collection
-    def page_missing(collection, slug)
-      @site.collections[collection].nil? || find_page(collection, slug).nil?
-    end
-
-    # Returns a hash of two CollectionPages representing a graph edge
-    def edge(referent, reference)
-      referenced_name, referenced_collection, referenced_slug = link_components(reference)
-      if page_missing(referenced_collection, referenced_slug)
-        written = false
-        name = referenced_name
-      else
-        written = true
-        name = find_page(referenced_collection, referenced_slug).data['name']
-      end
-      {
-        'referent' => referent,
-        'reference' => CollectionPage.new(
-          name,
-          referenced_collection,
-          referenced_slug,
-          written
-        )
-      }
-    end
-
-    # Based on the graph, returns edges that a specific document is the referent of
-    def referenced_in(collection, slug)
-      @graph.select do |edge|
-        edge['reference'].collection == collection && edge['reference'].slug == slug
-      end.map { |edge| edge['referent'] }
-    end
-
-    # Based on the graph, returns documents that are referenced, but do not exist yet
-    def unwritten_pages
-      @graph.reject do |edge|
-        edge['reference'].written
-      end
-    end
-
-    # Determines if refs table is required based on document,
-    # then collection, then site
-    def refs_table_required(doc)
-      if doc.data.key?('refs')
-        doc.data['refs']
-      elsif @site.config['collections'][doc.collection.label].key?('refs')
-        @site.config['collections'][doc.collection.label]['refs']
-      elsif @site.config.key?('refs')
-        @site.config['refs']
-      end
-    end
-
-    # Returns an easily accessible hash representing an edge for Jekyll purposes
-    def edge_hash(edge)
-      {
-        'reference_name' => edge['reference'].name,
-        'reference_collection' => edge['reference'].collection,
-        'reference_slug' => edge['reference'].slug,
-        'reference_link' => edge['reference'].markdown_link,
-        'referent_name' => edge['referent'].name,
-        'referent_collection' => edge['referent'].collection,
-        'referent_slug' => edge['referent'].slug,
-        'referent_link' => edge['referent'].markdown_link
-      }
-    end
-
-    # Returns a graph made up of hashed edges
-    def hashed_graph
-      @graph.map { |edge| edge_hash(edge) }
-    end
-
-    # The following three functions return a HTML table
-    # That for a specific document shows the documents that
-    # reference it
-
-    def refs_table(refs)
-      table = <<~TABLE
-        # Referenced By:
-        <table>
-          <thead>
-            <tr>
-              <th>Collection</th>
-              <th>Links</th>
-            </tr>
-          </thead>
-          <tbody>
-            #{refs_rows(refs)}
-          </tbody>
-        </table>
-      TABLE
-      table
-    end
-
-    def refs_rows(refs)
-      row = ''
-      refs.each do |reference|
-        row += <<~ROW
-          <tr>
-            <td markdown="span"><b> #{reference[0].capitalize} </b></td>
-            <td markdown="span"> #{refs_links(reference)} </td>
-          </tr>
-        ROW
-      end
-      row
-    end
-
-    def refs_links(reference)
-      links = ''
-      reference[1].each do |link|
-        links += " - #{link} <br>"
-      end
-      links
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-rpg
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Tom Lockwood
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-19 00:00:00.000000000 Z
+date: 2019-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -58,8 +72,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/collection_page.rb
+- lib/collection_document.rb
+- lib/edge.rb
+- lib/graph.rb
 - lib/jekyll-rpg.rb
+- lib/reference_table.rb
 - lib/references.rb
 homepage: https://github.com/tomlockwood/jekyll-rpg
 licenses:

data/lib/collection_page.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module JekyllRPG
-  # Represents a document that may be in a Jekyll collection
-  class CollectionPage
-    attr_accessor :name, :collection, :slug, :written
-
-    def initialize(name, collection, slug, written)
-      @name = name
-      @collection = collection
-      @slug = slug
-      # boolean
-      @written = written
-    end
-
-    def markdown_link
-      "[#{@name}](/#{@collection}/#{@slug})"
-    end
-  end
-end