ngage 0.0.0

data/lib/ngage/jekyll/related_posts.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class RelatedPosts
+    class << self
+      attr_accessor :lsi
+    end
+
+    attr_reader :post, :site
+
+    def initialize(post)
+      @post = post
+      @site = post.site
+      Jekyll::External.require_with_graceful_fail("classifier-reborn") if site.lsi
+    end
+
+    def build
+      return [] unless site.posts.docs.size > 1
+
+      if site.lsi
+        build_index
+        lsi_related_posts
+      else
+        most_recent_posts
+      end
+    end
+
+    def build_index
+      self.class.lsi ||= begin
+        lsi = ClassifierReborn::LSI.new(:auto_rebuild => false)
+        Jekyll.logger.info("Populating LSI...")
+
+        site.posts.docs.each do |x|
+          lsi.add_item(x)
+        end
+
+        Jekyll.logger.info("Rebuilding index...")
+        lsi.build_index
+        Jekyll.logger.info("")
+        lsi
+      end
+    end
+
+    def lsi_related_posts
+      self.class.lsi.find_related(post, 11)
+    end
+
+    def most_recent_posts
+      @most_recent_posts ||= (site.posts.docs.last(11).reverse - [post]).first(10)
+    end
+  end
+end

data/lib/ngage/jekyll/renderer.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Renderer
+    attr_reader :document, :site
+    attr_writer :layouts, :payload
+
+    def initialize(site, document, site_payload = nil)
+      @site     = site
+      @document = document
+      @payload  = site_payload
+    end
+
+    # Fetches the payload used in Liquid rendering.
+    # It can be written with #payload=(new_payload)
+    # Falls back to site.site_payload if no payload is set.
+    #
+    # Returns a Jekyll::Drops::UnifiedPayloadDrop
+    def payload
+      @payload ||= site.site_payload
+    end
+
+    # The list of layouts registered for this Renderer.
+    # It can be written with #layouts=(new_layouts)
+    # Falls back to site.layouts if no layouts are registered.
+    #
+    # Returns a Hash of String => Jekyll::Layout identified
+    # as basename without the extension name.
+    def layouts
+      @layouts || site.layouts
+    end
+
+    # Determine which converters to use based on this document's
+    # extension.
+    #
+    # Returns Array of Converter instances.
+    def converters
+      @converters ||= site.converters.select { |c| c.matches(document.extname) }.sort
+    end
+
+    # Determine the extname the outputted file should have
+    #
+    # Returns String the output extname including the leading period.
+    def output_ext
+      @output_ext ||= (permalink_ext || converter_output_ext)
+    end
+
+    # Prepare payload and render the document
+    #
+    # Returns String rendered document output
+    def run
+      Jekyll.logger.debug "Rendering:", document.relative_path
+
+      assign_pages!
+      assign_current_document!
+      assign_highlighter_options!
+      assign_layout_data!
+
+      Jekyll.logger.debug "Pre-Render Hooks:", document.relative_path
+      document.trigger_hooks(:pre_render, payload)
+
+      render_document
+    end
+
+    # Render the document.
+    #
+    # Returns String rendered document output
+    # rubocop: disable AbcSize
+    def render_document
+      info = {
+        :registers        => { :site => site, :page => payload["page"] },
+        :strict_filters   => liquid_options["strict_filters"],
+        :strict_variables => liquid_options["strict_variables"],
+      }
+
+      output = document.content
+      if document.render_with_liquid?
+        Jekyll.logger.debug "Rendering Liquid:", document.relative_path
+        output = render_liquid(output, payload, info, document.path)
+      end
+
+      Jekyll.logger.debug "Rendering Markup:", document.relative_path
+      output = convert(output.to_s)
+      document.content = output
+
+      if document.place_in_layout?
+        Jekyll.logger.debug "Rendering Layout:", document.relative_path
+        output = place_in_layouts(output, payload, info)
+      end
+
+      output
+    end
+    # rubocop: enable AbcSize
+
+    # Convert the document using the converters which match this renderer's document.
+    #
+    # Returns String the converted content.
+    def convert(content)
+      converters.reduce(content) do |output, converter|
+        begin
+          converter.convert output
+        rescue StandardError => e
+          Jekyll.logger.error "Conversion error:",
+                              "#{converter.class} encountered an error while "\
+                              "converting '#{document.relative_path}':"
+          Jekyll.logger.error("", e.to_s)
+          raise e
+        end
+      end
+    end
+
+    # Render the given content with the payload and info
+    #
+    # content -
+    # payload -
+    # info    -
+    # path    - (optional) the path to the file, for use in ex
+    #
+    # Returns String the content, rendered by Liquid.
+    def render_liquid(content, payload, info, path = nil)
+      template = site.liquid_renderer.file(path).parse(content)
+      template.warnings.each do |e|
+        Jekyll.logger.warn "Liquid Warning:",
+                           LiquidRenderer.format_error(e, path || document.relative_path)
+      end
+      template.render!(payload, info)
+    # rubocop: disable RescueException
+    rescue Exception => e
+      Jekyll.logger.error "Liquid Exception:",
+                          LiquidRenderer.format_error(e, path || document.relative_path)
+      raise e
+    end
+    # rubocop: enable RescueException
+
+    # Checks if the layout specified in the document actually exists
+    #
+    # layout - the layout to check
+    #
+    # Returns Boolean true if the layout is invalid, false if otherwise
+    def invalid_layout?(layout)
+      !document.data["layout"].nil? && layout.nil? && !(document.is_a? Jekyll::Excerpt)
+    end
+
+    # Render layouts and place document content inside.
+    #
+    # Returns String rendered content
+    def place_in_layouts(content, payload, info)
+      output = content.dup
+      layout = layouts[document.data["layout"].to_s]
+      validate_layout(layout)
+
+      used = Set.new([layout])
+
+      # Reset the payload layout data to ensure it starts fresh for each page.
+      payload["layout"] = nil
+
+      while layout
+        output = render_layout(output, layout, info)
+        add_regenerator_dependencies(layout)
+
+        next unless (layout = site.layouts[layout.data["layout"]])
+        break if used.include?(layout)
+
+        used << layout
+      end
+      output
+    end
+
+    private
+
+    # Checks if the layout specified in the document actually exists
+    #
+    # layout - the layout to check
+    # Returns nothing
+    def validate_layout(layout)
+      if invalid_layout?(layout)
+        Jekyll.logger.warn(
+          "Build Warning:",
+          "Layout '#{document.data["layout"]}' requested "\
+          "in #{document.relative_path} does not exist."
+        )
+      elsif !layout.nil?
+        layout_source = layout.path.start_with?(site.source) ? :site : :theme
+        Jekyll.logger.debug "Layout source:", layout_source
+      end
+    end
+
+    # Render layout content into document.output
+    #
+    # Returns String rendered content
+    def render_layout(output, layout, info)
+      payload["content"] = output
+      payload["layout"]  = Utils.deep_merge_hashes(layout.data, payload["layout"] || {})
+
+      render_liquid(
+        layout.content,
+        payload,
+        info,
+        layout.relative_path
+      )
+    end
+
+    def add_regenerator_dependencies(layout)
+      return unless document.write?
+
+      site.regenerator.add_dependency(
+        site.in_source_dir(document.path),
+        layout.path
+      )
+    end
+
+    # Set page content to payload and assign pager if document has one.
+    #
+    # Returns nothing
+    def assign_pages!
+      payload["page"] = document.to_liquid
+      payload["paginator"] = (document.pager.to_liquid if document.respond_to?(:pager))
+    end
+
+    # Set related posts to payload if document is a post.
+    #
+    # Returns nothing
+    def assign_current_document!
+      payload["site"].current_document = document
+    end
+
+    # Set highlighter prefix and suffix
+    #
+    # Returns nothing
+    def assign_highlighter_options!
+      payload["highlighter_prefix"] = converters.first.highlighter_prefix
+      payload["highlighter_suffix"] = converters.first.highlighter_suffix
+    end
+
+    def assign_layout_data!
+      layout = layouts[document.data["layout"]]
+      payload["layout"] = Utils.deep_merge_hashes(layout.data, payload["layout"] || {}) if layout
+    end
+
+    def permalink_ext
+      document_permalink = document.permalink
+      if document_permalink && !document_permalink.end_with?("/")
+        permalink_ext = File.extname(document_permalink)
+        permalink_ext unless permalink_ext.empty?
+      end
+    end
+
+    def converter_output_ext
+      if output_exts.size == 1
+        output_exts.last
+      else
+        output_exts[-2]
+      end
+    end
+
+    def output_exts
+      @output_exts ||= converters.map do |c|
+        c.output_ext(document.extname)
+      end.compact
+    end
+
+    def liquid_options
+      @liquid_options ||= site.config["liquid"]
+    end
+  end
+end

data/lib/ngage/jekyll/site.rb

@@ -0,0 +1,476 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Site
+    attr_reader   :source, :dest, :config
+    attr_accessor :layouts, :pages, :static_files, :drafts,
+                  :exclude, :include, :lsi, :highlighter, :permalink_style,
+                  :time, :future, :unpublished, :safe, :plugins, :limit_posts,
+                  :show_drafts, :keep_files, :baseurl, :data, :file_read_opts,
+                  :gems, :plugin_manager, :theme
+
+    attr_accessor :converters, :generators, :reader
+    attr_reader   :regenerator, :liquid_renderer, :includes_load_paths
+
+    # Public: Initialize a new Site.
+    #
+    # config - A Hash containing site configuration details.
+    def initialize(config)
+      # Source and destination may not be changed after the site has been created.
+      @source          = File.expand_path(config["source"]).freeze
+      @dest            = File.expand_path(config["destination"]).freeze
+
+      self.config = config
+
+      @reader          = Reader.new(self)
+      @regenerator     = Regenerator.new(self)
+      @liquid_renderer = LiquidRenderer.new(self)
+
+      Jekyll.sites << self
+
+      reset
+      setup
+
+      Jekyll::Hooks.trigger :site, :after_init, self
+    end
+
+    # Public: Set the site's configuration. This handles side-effects caused by
+    # changing values in the configuration.
+    #
+    # config - a Jekyll::Configuration, containing the new configuration.
+    #
+    # Returns the new configuration.
+    def config=(config)
+      @config = config.clone
+
+      %w(safe lsi highlighter baseurl exclude include future unpublished
+         show_drafts limit_posts keep_files).each do |opt|
+        send("#{opt}=", config[opt])
+      end
+
+      # keep using `gems` to avoid breaking change
+      self.gems = config["plugins"]
+
+      configure_plugins
+      configure_theme
+      configure_include_paths
+      configure_file_read_opts
+
+      self.permalink_style = config["permalink"].to_sym
+
+      @config
+    end
+
+    # Public: Read, process, and write this Site to output.
+    #
+    # Returns nothing.
+    def process
+      reset
+      read
+      generate
+      render
+      cleanup
+      write
+      print_stats if config["profile"]
+    end
+
+    def print_stats
+      Jekyll.logger.info @liquid_renderer.stats_table
+    end
+
+    # Reset Site details.
+    #
+    # Returns nothing
+    def reset
+      self.time = if config["time"]
+                    Utils.parse_date(config["time"].to_s, "Invalid time in _config.yml.")
+                  else
+                    Time.now
+                  end
+      self.layouts = {}
+      self.pages = []
+      self.static_files = []
+      self.data = {}
+      @site_data = nil
+      @collections = nil
+      @docs_to_write = nil
+      @regenerator.clear_cache
+      @liquid_renderer.reset
+      @site_cleaner = nil
+
+      raise ArgumentError, "limit_posts must be a non-negative number" if limit_posts.negative?
+
+      Jekyll::Hooks.trigger :site, :after_reset, self
+    end
+
+    # Load necessary libraries, plugins, converters, and generators.
+    #
+    # Returns nothing.
+    def setup
+      ensure_not_in_dest
+
+      plugin_manager.conscientious_require
+
+      self.converters = instantiate_subclasses(Jekyll::Converter)
+      self.generators = instantiate_subclasses(Jekyll::Generator)
+    end
+
+    # Check that the destination dir isn't the source dir or a directory
+    # parent to the source dir.
+    def ensure_not_in_dest
+      dest_pathname = Pathname.new(dest)
+      Pathname.new(source).ascend do |path|
+        if path == dest_pathname
+          raise Errors::FatalException,
+                "Destination directory cannot be or contain the Source directory."
+        end
+      end
+    end
+
+    # The list of collections and their corresponding Jekyll::Collection instances.
+    # If config['collections'] is set, a new instance is created
+    # for each item in the collection, a new hash is returned otherwise.
+    #
+    # Returns a Hash containing collection name-to-instance pairs.
+    def collections
+      @collections ||= Hash[collection_names.map do |coll|
+        [coll, Jekyll::Collection.new(self, coll)]
+      end]
+    end
+
+    # The list of collection names.
+    #
+    # Returns an array of collection names from the configuration,
+    #   or an empty array if the `collections` key is not set.
+    def collection_names
+      case config["collections"]
+      when Hash
+        config["collections"].keys
+      when Array
+        config["collections"]
+      when nil
+        []
+      else
+        raise ArgumentError, "Your `collections` key must be a hash or an array."
+      end
+    end
+
+    # Read Site data from disk and load it into internal data structures.
+    #
+    # Returns nothing.
+    def read
+      reader.read
+      limit_posts!
+      Jekyll::Hooks.trigger :site, :post_read, self
+    end
+
+    # Run each of the Generators.
+    #
+    # Returns nothing.
+    def generate
+      generators.each do |generator|
+        start = Time.now
+        generator.generate(self)
+        Jekyll.logger.debug "Generating:",
+                            "#{generator.class} finished in #{Time.now - start} seconds."
+      end
+    end
+
+    # Render the site to the destination.
+    #
+    # Returns nothing.
+    def render
+      relative_permalinks_are_deprecated
+
+      payload = site_payload
+
+      Jekyll::Hooks.trigger :site, :pre_render, self, payload
+
+      render_docs(payload)
+      render_pages(payload)
+
+      Jekyll::Hooks.trigger :site, :post_render, self, payload
+    end
+
+    # Remove orphaned files and empty directories in destination.
+    #
+    # Returns nothing.
+    def cleanup
+      site_cleaner.cleanup!
+    end
+
+    # Write static files, pages, and posts.
+    #
+    # Returns nothing.
+    def write
+      each_site_file do |item|
+        item.write(dest) if regenerator.regenerate?(item)
+      end
+      regenerator.write_metadata
+      Jekyll::Hooks.trigger :site, :post_write, self
+    end
+
+    def posts
+      collections["posts"] ||= Collection.new(self, "posts")
+    end
+
+    # Construct a Hash of Posts indexed by the specified Post attribute.
+    #
+    # post_attr - The String name of the Post attribute.
+    #
+    # Examples
+    #
+    #   post_attr_hash('categories')
+    #   # => { 'tech' => [<Post A>, <Post B>],
+    #   #      'ruby' => [<Post B>] }
+    #
+    # Returns the Hash: { attr => posts } where
+    #   attr  - One of the values for the requested attribute.
+    #   posts - The Array of Posts with the given attr value.
+    def post_attr_hash(post_attr)
+      # Build a hash map based on the specified post attribute ( post attr =>
+      # array of posts ) then sort each array in reverse order.
+      hash = Hash.new { |h, key| h[key] = [] }
+      posts.docs.each do |p|
+        p.data[post_attr]&.each { |t| hash[t] << p }
+      end
+      hash.each_value { |posts| posts.sort!.reverse! }
+      hash
+    end
+
+    def tags
+      post_attr_hash("tags")
+    end
+
+    def categories
+      post_attr_hash("categories")
+    end
+
+    # Prepare site data for site payload. The method maintains backward compatibility
+    # if the key 'data' is already used in _config.yml.
+    #
+    # Returns the Hash to be hooked to site.data.
+    def site_data
+      @site_data ||= (config["data"] || data)
+    end
+
+    # The Hash payload containing site-wide data.
+    #
+    # Returns the Hash: { "site" => data } where data is a Hash with keys:
+    #   "time"       - The Time as specified in the configuration or the
+    #                  current time if none was specified.
+    #   "posts"      - The Array of Posts, sorted chronologically by post date
+    #                  and then title.
+    #   "pages"      - The Array of all Pages.
+    #   "html_pages" - The Array of HTML Pages.
+    #   "categories" - The Hash of category values and Posts.
+    #                  See Site#post_attr_hash for type info.
+    #   "tags"       - The Hash of tag values and Posts.
+    #                  See Site#post_attr_hash for type info.
+    def site_payload
+      Drops::UnifiedPayloadDrop.new self
+    end
+    alias_method :to_liquid, :site_payload
+
+    # Get the implementation class for the given Converter.
+    # Returns the Converter instance implementing the given Converter.
+    # klass - The Class of the Converter to fetch.
+    def find_converter_instance(klass)
+      @find_converter_instance ||= {}
+      @find_converter_instance[klass] ||= begin
+        converters.find { |converter| converter.instance_of?(klass) } || \
+          raise("No Converters found for #{klass}")
+      end
+    end
+
+    # klass - class or module containing the subclasses.
+    # Returns array of instances of subclasses of parameter.
+    # Create array of instances of the subclasses of the class or module
+    # passed in as argument.
+
+    def instantiate_subclasses(klass)
+      klass.descendants.select { |c| !safe || c.safe }.sort.map do |c|
+        c.new(config)
+      end
+    end
+
+    # Warns the user if permanent links are relative to the parent
+    # directory. As this is a deprecated function of Jekyll.
+    #
+    # Returns
+    def relative_permalinks_are_deprecated
+      if config["relative_permalinks"]
+        Jekyll.logger.abort_with "Since v3.0, permalinks for pages" \
+                                 " in subfolders must be relative to the" \
+                                 " site source directory, not the parent" \
+                                 " directory. Check https://jekyllrb.com/docs/upgrading/"\
+                                 " for more info."
+      end
+    end
+
+    # Get the to be written documents
+    #
+    # Returns an Array of Documents which should be written
+    def docs_to_write
+      @docs_to_write ||= documents.select(&:write?)
+    end
+
+    # Get all the documents
+    #
+    # Returns an Array of all Documents
+    def documents
+      collections.reduce(Set.new) do |docs, (_, collection)|
+        docs + collection.docs + collection.files
+      end.to_a
+    end
+
+    def each_site_file
+      %w(pages static_files docs_to_write).each do |type|
+        send(type).each do |item|
+          yield item
+        end
+      end
+    end
+
+    # Returns the FrontmatterDefaults or creates a new FrontmatterDefaults
+    # if it doesn't already exist.
+    #
+    # Returns The FrontmatterDefaults
+    def frontmatter_defaults
+      @frontmatter_defaults ||= FrontmatterDefaults.new(self)
+    end
+
+    # Whether to perform a full rebuild without incremental regeneration
+    #
+    # Returns a Boolean: true for a full rebuild, false for normal build
+    def incremental?(override = {})
+      override["incremental"] || config["incremental"]
+    end
+
+    # Returns the publisher or creates a new publisher if it doesn't
+    # already exist.
+    #
+    # Returns The Publisher
+    def publisher
+      @publisher ||= Publisher.new(self)
+    end
+
+    # Public: Prefix a given path with the source directory.
+    #
+    # paths - (optional) path elements to a file or directory within the
+    #         source directory
+    #
+    # Returns a path which is prefixed with the source directory.
+    def in_source_dir(*paths)
+      paths.reduce(source) do |base, path|
+        Jekyll.sanitized_path(base, path)
+      end
+    end
+
+    # Public: Prefix a given path with the theme directory.
+    #
+    # paths - (optional) path elements to a file or directory within the
+    #         theme directory
+    #
+    # Returns a path which is prefixed with the theme root directory.
+    def in_theme_dir(*paths)
+      return nil unless theme
+
+      paths.reduce(theme.root) do |base, path|
+        Jekyll.sanitized_path(base, path)
+      end
+    end
+
+    # Public: Prefix a given path with the destination directory.
+    #
+    # paths - (optional) path elements to a file or directory within the
+    #         destination directory
+    #
+    # Returns a path which is prefixed with the destination directory.
+    def in_dest_dir(*paths)
+      paths.reduce(dest) do |base, path|
+        Jekyll.sanitized_path(base, path)
+      end
+    end
+
+    # Public: The full path to the directory that houses all the collections registered
+    # with the current site.
+    #
+    # Returns the source directory or the absolute path to the custom collections_dir
+    def collections_path
+      dir_str = config["collections_dir"]
+      @collections_path ||= dir_str.empty? ? source : in_source_dir(dir_str)
+    end
+
+    private
+
+    # Limits the current posts; removes the posts which exceed the limit_posts
+    #
+    # Returns nothing
+    def limit_posts!
+      if limit_posts.positive?
+        limit = posts.docs.length < limit_posts ? posts.docs.length : limit_posts
+        posts.docs = posts.docs[-limit, limit]
+      end
+    end
+
+    # Returns the Cleaner or creates a new Cleaner if it doesn't
+    # already exist.
+    #
+    # Returns The Cleaner
+    def site_cleaner
+      @site_cleaner ||= Cleaner.new(self)
+    end
+
+    def configure_plugins
+      self.plugin_manager = Jekyll::PluginManager.new(self)
+      self.plugins        = plugin_manager.plugins_path
+    end
+
+    def configure_theme
+      self.theme = nil
+      return if config["theme"].nil?
+
+      self.theme =
+        if config["theme"].is_a?(String)
+          Jekyll::Theme.new(config["theme"])
+        else
+          Jekyll.logger.warn "Theme:", "value of 'theme' in config should be " \
+          "String to use gem-based themes, but got #{config["theme"].class}"
+          nil
+        end
+    end
+
+    def configure_include_paths
+      @includes_load_paths = Array(in_source_dir(config["includes_dir"].to_s))
+      @includes_load_paths << theme.includes_path if theme&.includes_path
+    end
+
+    def configure_file_read_opts
+      self.file_read_opts = {}
+      file_read_opts[:encoding] = config["encoding"] if config["encoding"]
+      self.file_read_opts = Jekyll::Utils.merged_file_read_opts(self, {})
+    end
+
+    def render_docs(payload)
+      collections.each_value do |collection|
+        collection.docs.each do |document|
+          render_regenerated(document, payload)
+        end
+      end
+    end
+
+    def render_pages(payload)
+      pages.flatten.each do |page|
+        render_regenerated(page, payload)
+      end
+    end
+
+    def render_regenerated(document, payload)
+      return unless regenerator.regenerate?(document)
+
+      document.output = Jekyll::Renderer.new(self, document, payload).run
+      document.trigger_hooks(:post_render)
+    end
+  end
+end