_plugins/page_structure.rb

#
# Adds a liquid tag to build a page on the contents of the folder it's in
# 
# Pulls in files in the format <Number>_<title>.md in the order of version number. Ignores files not in this format.
#

require 'rubygems'
require 'yaml'
require "kramdown"
require 'pathname'

module PageStructureUtils
  
  class ChildPage
    def initialize(yaml, content)
      @yaml=yaml
      @content=content
    end
    attr_accessor :yaml
    attr_accessor :content
    def to_s # called with print / puts
      "YAML : #{@yaml}" #, Content : #{@content}"
    end

    ##
    # Sort a list of children by their YAML containing section positions. Do this with Gem:Version
    #
    #
    def self.sortBySectionPositions(yaml)
      
      $major = "1"
      $minor = 1
      # first check all the child pages are numbered, if not, number them in the order they are
      yaml.each do |i|
        if i.yaml['section_position'] == nil
          i.yaml['section_position'] = $major+"."+$minor.to_s
          $minor += 1
        else
          # Store any major, start incrementing minor
          $major = i.yaml['section_position'].to_s
          $minor = 1
        end
      end
      
      # return the comparison between the versions
      yaml.sort{ |x,y| Gem::Version.new(x.yaml['section_position'].to_s) <=> Gem::Version.new(y.yaml['section_position'].to_s) }
    end
    ##
    # This goes through the hash looking for the keys for the different types of children
    #
    def self.getDefiningParameterFromHash(hash)
      param_name = hash['path']
      param_name = (param_name == nil ? hash['link'] : param_name)
       (param_name == nil ? hash['section'] : param_name)
    end
    ##
    # Sorts a list of yaml children, if there's no numbering, use the YAML order to create a numbering
    # NOTE: doesn't alter the returned object as that seemed to break things downstream
    #
    def self.sortYAMLSectionPositions(yaml)
          position = Hash.new
          $major = "1"
          $minor = 1
          # go through and generate a position for each
          yaml.each do |i|
            if i.instance_of? String
              position[i] = $major+"."+$minor.to_s
              $minor += 1
            else
              # get the key for this type of child
              defining_param = getDefiningParameterFromHash(i)
              if i['section_position'] == nil
                position[defining_param] = $major+"."+$minor.to_s
                $minor += 1
              else
                # Store any major, start incrementing minor
                position[defining_param] = i['section_position'].to_s
                $major = i['section_position'].to_s
                $minor = 1
              end
            end
          end
          # sort on the position (NB: sort! for in-place sorting)
          yaml.sort!{ |x,y| 
            $pos_x = nil
            $pos_y = nil
            if x.instance_of? String
              $pos_x = position[x]
            else
              defining_param = getDefiningParameterFromHash(x)
              $pos_x = position[defining_param]
            end
            if y.instance_of? String
              $pos_y = position[y]
            else
              defining_param = getDefiningParameterFromHash(y)
              $pos_y = position[defining_param]
            end
            Gem::Version.new($pos_x.to_s) <=> Gem::Version.new($pos_y.to_s) 
            }
        end
    
    ##
    # This function looks at all the *.md files at the YAML in the headers and produces a list of children ordered by section_position
    #
    #
    def self.parseChildYAMLFromParent(page)
      # get the base directory of the current file
      $baseFile = Dir.pwd+"/"+(Pathname(page['path']).dirname.to_s)
      # list all of the files in that directory
      $listings = Dir[$baseFile+"/*.md"]
      $allPages = []

      for $listing in $listings
                
        # read the file
        $fileContent = IO.read($listing)
        # try and split of any YAML
        $partitionedFileContent = $fileContent.split('---');
        # if there's potentially partitioned YAML try and parse it
        if $partitionedFileContent.size > 2
          # try and parse the YAML
          yamlContent = YAML.load($partitionedFileContent[1])
          # if we can, use it (section_type needs to be one of the allowed)
          if yamlContent != nil && yamlContent != false && yamlContent['section_type'] != nil && yamlContent['section_type'] != "default"

            if yamlContent['section_type'] == nil
              # if no section position has been specified, put it at the end
              yamlContent['section_position'] = Integer::MAX
            end
            # if there's YAML, check it has the section_position tag and put it into child pages
            ($allPages ||= []) << ChildPage.new(yamlContent, $partitionedFileContent[2..-1].join('---'))
          end
        end     
      end
      $allPages = sortBySectionPositions($allPages)
      # return the combined content
      $allPages
    end
          
    ##
    # This function looks in a parent folder for all files in the format <Number>_<title>.md
    # 
    #
    def self.parseChildPagesFromParent(page)
      # get the base directory of the current file
      $baseFile = Dir.pwd+"/"+(Pathname(page['path']).dirname.to_s)
      # list all of the files in that directory
      $listings = Dir[$baseFile+"/*"]
      # filter by the key pattern
      $listings = $listings.select{ |i| i[/[\d\.]\_.*\.md/] }
      # Sort the files based on the Gem::Version of the prefix
      $listings = $listings.sort{ |x,y| Gem::Version.new((File.basename x).partition('_').first) <=> Gem::Version.new((File.basename y).partition('_').first)  }
      # loop through them and merge the content
      $allPages = []

      for $listing in $listings
        $textContent = ""
        yamlContent = nil
                
        # read the file
        $fileContent = IO.read($listing)
        # try and split of any YAML
        $partitionedFileContent = $fileContent.split('---');
        # if there's potentially partitioned YAML try and parse it
        if $partitionedFileContent.size > 2
          # try and parse the YAML
          yamlContent = YAML.load($partitionedFileContent[1])
          # if we can, use it
          if yamlContent != nil && yamlContent != false
            $textContent = $partitionedFileContent[2..-1].join('---')
          end
        end
        
        # if there's no text content set yet, just use the whole file
        if $textContent == ""
          # use the whole file content
          $textContent = $fileContent
        end
        # append the current file to the content
        ($allPages ||= []) << ChildPage.new(yamlContent, $textContent)
                
      end
      # return the combined content
      $allPages
    end
  end
  
  class IncludePageContentTag < Liquid::Tag
      def initialize(tag_name, text, tokens)
        super
        @text = text.strip
      end
      def render(context)
#        $childPages = ChildPage.parseChildPagesFromParent(context['page'])
        $childPages = ChildPage.parseChildYAMLFromParent(context['page'])
        $content = ""
        for $childPage in $childPages
          #append the content
          $content = $content+$childPage.content()
        end
        site = context.registers[:site]
        pageHash = context.registers[:page]
          
        # not sure how to get the page object so look through site.pages for the current URL
        page = nil;
        for currPage in site.pages
          if currPage['url'] == pageHash['url']
            page = currPage
            break
          end
        end

        # render the included content with the current page renderer
        info = { :filters => [Jekyll::Filters], :registers => { :site => site, :page => page } }
        path_for_cache = "include_page-#{context['page']}"

        relative_link_parser = JekyllRelativeLinks::Generator.new(nil)
        relative_link_parser.prepare_for_site(site)
        $content = relative_link_parser.replace_relative_links_in_content($content, page.relative_path)

        page.render_liquid($content, site.site_payload, info, path_for_cache)
      end
    end
end

Liquid::Template.register_tag('child_content', PageStructureUtils::IncludePageContentTag)