jekyll-docs 3.6.1.0 → 3.6.2

data/lib/jekyll/readers/collection_reader.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class CollectionReader
+    SPECIAL_COLLECTIONS = %w(posts data).freeze
+
+    attr_reader :site, :content
+    def initialize(site)
+      @site = site
+      @content = {}
+    end
+
+    # Read in all collections specified in the configuration
+    #
+    # Returns nothing.
+    def read
+      site.collections.each_value do |collection|
+        collection.read unless SPECIAL_COLLECTIONS.include?(collection.label)
+      end
+    end
+  end
+end

data/lib/jekyll/readers/data_reader.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class DataReader
+    attr_reader :site, :content
+    def initialize(site)
+      @site = site
+      @content = {}
+      @entry_filter = EntryFilter.new(site)
+    end
+
+    # Read all the files in <dir> and adds them to @content
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns @content, a Hash of the .yaml, .yml,
+    # .json, and .csv files in the base directory
+    def read(dir)
+      base = site.in_source_dir(dir)
+      read_data_to(base, @content)
+      @content
+    end
+
+    # Read and parse all .yaml, .yml, .json, .csv and .tsv
+    # files under <dir> and add them to the <data> variable.
+    #
+    # dir - The string absolute path of the directory to read.
+    # data - The variable to which data will be added.
+    #
+    # Returns nothing
+    def read_data_to(dir, data)
+      return unless File.directory?(dir) && !@entry_filter.symlink?(dir)
+
+      entries = Dir.chdir(dir) do
+        Dir["*.{yaml,yml,json,csv,tsv}"] + Dir["*"].select { |fn| File.directory?(fn) }
+      end
+
+      entries.each do |entry|
+        path = @site.in_source_dir(dir, entry)
+        next if @entry_filter.symlink?(path)
+
+        if File.directory?(path)
+          read_data_to(path, data[sanitize_filename(entry)] = {})
+        else
+          key = sanitize_filename(File.basename(entry, ".*"))
+          data[key] = read_data_file(path)
+        end
+      end
+    end
+
+    # Determines how to read a data file.
+    #
+    # Returns the contents of the data file.
+    def read_data_file(path)
+      case File.extname(path).downcase
+      when ".csv"
+        CSV.read(path, {
+          :headers  => true,
+          :encoding => site.config["encoding"],
+        }).map(&:to_hash)
+      when ".tsv"
+        CSV.read(path, {
+          :col_sep  => "\t",
+          :headers  => true,
+          :encoding => site.config["encoding"],
+        }).map(&:to_hash)
+      else
+        SafeYAML.load_file(path)
+      end
+    end
+
+    def sanitize_filename(name)
+      name.gsub(%r![^\w\s-]+|(?<=^|\b\s)\s+(?=$|\s?\b)!, "")
+        .gsub(%r!\s+!, "_")
+    end
+  end
+end

data/lib/jekyll/readers/layout_reader.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class LayoutReader
+    attr_reader :site
+    def initialize(site)
+      @site = site
+      @layouts = {}
+    end
+
+    def read
+      layout_entries.each do |layout_file|
+        @layouts[layout_name(layout_file)] = \
+          Layout.new(site, layout_directory, layout_file)
+      end
+
+      theme_layout_entries.each do |layout_file|
+        @layouts[layout_name(layout_file)] ||= \
+          Layout.new(site, theme_layout_directory, layout_file)
+      end
+
+      @layouts
+    end
+
+    def layout_directory
+      @layout_directory ||= (layout_directory_in_cwd || layout_directory_inside_source)
+    end
+
+    def theme_layout_directory
+      @theme_layout_directory ||= site.theme.layouts_path if site.theme
+    end
+
+    private
+
+    def layout_entries
+      entries_in layout_directory
+    end
+
+    def theme_layout_entries
+      theme_layout_directory ? entries_in(theme_layout_directory) : []
+    end
+
+    def entries_in(dir)
+      entries = []
+      within(dir) do
+        entries = EntryFilter.new(site).filter(Dir["**/*.*"])
+      end
+      entries
+    end
+
+    def layout_name(file)
+      file.split(".")[0..-2].join(".")
+    end
+
+    def within(directory)
+      return unless File.exist?(directory)
+      Dir.chdir(directory) { yield }
+    end
+
+    def layout_directory_inside_source
+      site.in_source_dir(site.config["layouts_dir"])
+    end
+
+    def layout_directory_in_cwd
+      dir = Jekyll.sanitized_path(Dir.pwd, site.config["layouts_dir"])
+      if File.directory?(dir) && !site.safe
+        dir
+      end
+    end
+  end
+end

data/lib/jekyll/readers/page_reader.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class PageReader
+    attr_reader :site, :dir, :unfiltered_content
+    def initialize(site, dir)
+      @site = site
+      @dir = dir
+      @unfiltered_content = []
+    end
+
+    # Read all the files in <source>/<dir>/ for Yaml header and create a new Page
+    # object for each file.
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns an array of static pages.
+    def read(files)
+      files.map do |page|
+        @unfiltered_content << Page.new(@site, @site.source, @dir, page)
+      end
+      @unfiltered_content.select { |page| site.publisher.publish?(page) }
+    end
+  end
+end

data/lib/jekyll/readers/post_reader.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class PostReader
+    attr_reader :site, :unfiltered_content
+    def initialize(site)
+      @site = site
+    end
+
+    # Read all the files in <source>/<dir>/_drafts and create a new
+    # Document object with each one.
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns nothing.
+    def read_drafts(dir)
+      read_publishable(dir, "_drafts", Document::DATELESS_FILENAME_MATCHER)
+    end
+
+    # Read all the files in <source>/<dir>/_posts and create a new Document
+    # object with each one.
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns nothing.
+    def read_posts(dir)
+      read_publishable(dir, "_posts", Document::DATE_FILENAME_MATCHER)
+    end
+
+    # Read all the files in <source>/<dir>/<magic_dir> and create a new
+    # Document object with each one insofar as it matches the regexp matcher.
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns nothing.
+    def read_publishable(dir, magic_dir, matcher)
+      read_content(dir, magic_dir, matcher).tap { |docs| docs.each(&:read) }
+        .select do |doc|
+          if doc.content.valid_encoding?
+            site.publisher.publish?(doc).tap do |will_publish|
+              if !will_publish && site.publisher.hidden_in_the_future?(doc)
+                Jekyll.logger.debug "Skipping:", "#{doc.relative_path} has a future date"
+              end
+            end
+          else
+            Jekyll.logger.debug "Skipping:", "#{doc.relative_path} is not valid UTF-8"
+            false
+          end
+        end
+    end
+
+    # Read all the content files from <source>/<dir>/magic_dir
+    #   and return them with the type klass.
+    #
+    # dir - The String relative path of the directory to read.
+    # magic_dir - The String relative directory to <dir>,
+    #   looks for content here.
+    # klass - The return type of the content.
+    #
+    # Returns klass type of content files
+    def read_content(dir, magic_dir, matcher)
+      @site.reader.get_entries(dir, magic_dir).map do |entry|
+        next unless entry =~ matcher
+        path = @site.in_source_dir(File.join(dir, magic_dir, entry))
+        Document.new(path, {
+          :site       => @site,
+          :collection => @site.posts,
+        })
+      end.reject(&:nil?)
+    end
+  end
+end

data/lib/jekyll/readers/static_file_reader.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class StaticFileReader
+    attr_reader :site, :dir, :unfiltered_content
+    def initialize(site, dir)
+      @site = site
+      @dir = dir
+      @unfiltered_content = []
+    end
+
+    # Read all the files in <source>/<dir>/ for Yaml header and create a new Page
+    # object for each file.
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns an array of static files.
+    def read(files)
+      files.map do |file|
+        @unfiltered_content << StaticFile.new(@site, @site.source, @dir, file)
+      end
+      @unfiltered_content
+    end
+  end
+end

data/lib/jekyll/readers/theme_assets_reader.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class ThemeAssetsReader
+    attr_reader :site
+    def initialize(site)
+      @site = site
+    end
+
+    def read
+      return unless site.theme && site.theme.assets_path
+
+      Find.find(site.theme.assets_path) do |path|
+        next if File.directory?(path)
+        if File.symlink?(path)
+          Jekyll.logger.warn "Theme reader:", "Ignored symlinked asset: #{path}"
+        else
+          read_theme_asset(path)
+        end
+      end
+    end
+
+    private
+    def read_theme_asset(path)
+      base = site.theme.root
+      dir = File.dirname(path.sub("#{site.theme.root}/", ""))
+      name = File.basename(path)
+
+      if Utils.has_yaml_header?(path)
+        append_unless_exists site.pages,
+          Jekyll::Page.new(site, base, dir, name)
+      else
+        append_unless_exists site.static_files,
+          Jekyll::StaticFile.new(site, base, "/#{dir}", name)
+      end
+    end
+
+    def append_unless_exists(haystack, new_item)
+      if haystack.any? { |file| file.relative_path == new_item.relative_path }
+        Jekyll.logger.debug "Theme:",
+          "Ignoring #{new_item.relative_path} in theme due to existing file " \
+          "with that path in site."
+        return
+      end
+
+      haystack << new_item
+    end
+  end
+end

data/lib/jekyll/regenerator.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Regenerator
+    attr_reader :site, :metadata, :cache
+    attr_accessor :disabled
+    private :disabled, :disabled=
+
+    def initialize(site)
+      @site = site
+
+      # Read metadata from file
+      read_metadata
+
+      # Initialize cache to an empty hash
+      clear_cache
+    end
+
+    # Checks if a renderable object needs to be regenerated
+    #
+    # Returns a boolean.
+    def regenerate?(document)
+      case document
+      when Page
+        regenerate_page?(document)
+      when Document
+        regenerate_document?(document)
+      else
+        source_path = document.respond_to?(:path) ? document.path : nil
+        dest_path = if document.respond_to?(:destination)
+                      document.destination(@site.dest)
+                    end
+        source_modified_or_dest_missing?(source_path, dest_path)
+      end
+    end
+
+    # Add a path to the metadata
+    #
+    # Returns true, also on failure.
+    def add(path)
+      return true unless File.exist?(path)
+
+      metadata[path] = {
+        "mtime" => File.mtime(path),
+        "deps"  => [],
+      }
+      cache[path] = true
+    end
+
+    # Force a path to regenerate
+    #
+    # Returns true.
+    def force(path)
+      cache[path] = true
+    end
+
+    # Clear the metadata and cache
+    #
+    # Returns nothing
+    def clear
+      @metadata = {}
+      clear_cache
+    end
+
+    # Clear just the cache
+    #
+    # Returns nothing
+    def clear_cache
+      @cache = {}
+    end
+
+    # Checks if the source has been modified or the
+    # destination is missing
+    #
+    # returns a boolean
+    def source_modified_or_dest_missing?(source_path, dest_path)
+      modified?(source_path) || (dest_path && !File.exist?(dest_path))
+    end
+
+    # Checks if a path's (or one of its dependencies)
+    # mtime has changed
+    #
+    # Returns a boolean.
+    def modified?(path)
+      return true if disabled?
+
+      # objects that don't have a path are always regenerated
+      return true if path.nil?
+
+      # Check for path in cache
+      if cache.key? path
+        return cache[path]
+      end
+
+      if metadata[path]
+        # If we have seen this file before,
+        # check if it or one of its dependencies has been modified
+        existing_file_modified?(path)
+      else
+        # If we have not seen this file before, add it to the metadata and regenerate it
+        add(path)
+      end
+    end
+
+    # Add a dependency of a path
+    #
+    # Returns nothing.
+    def add_dependency(path, dependency)
+      return if metadata[path].nil? || disabled
+
+      unless metadata[path]["deps"].include? dependency
+        metadata[path]["deps"] << dependency
+        add(dependency) unless metadata.include?(dependency)
+      end
+      regenerate? dependency
+    end
+
+    # Write the metadata to disk
+    #
+    # Returns nothing.
+    def write_metadata
+      unless disabled?
+        File.binwrite(metadata_file, Marshal.dump(metadata))
+      end
+    end
+
+    # Produce the absolute path of the metadata file
+    #
+    # Returns the String path of the file.
+    def metadata_file
+      site.in_source_dir(".jekyll-metadata")
+    end
+
+    # Check if metadata has been disabled
+    #
+    # Returns a Boolean (true for disabled, false for enabled).
+    def disabled?
+      self.disabled = !site.incremental? if disabled.nil?
+      disabled
+    end
+
+    private
+
+    # Read metadata from the metadata file, if no file is found,
+    # initialize with an empty hash
+    #
+    # Returns the read metadata.
+    def read_metadata
+      @metadata =
+        if !disabled? && File.file?(metadata_file)
+          content = File.binread(metadata_file)
+
+          begin
+            Marshal.load(content)
+          rescue TypeError
+            SafeYAML.load(content)
+          rescue ArgumentError => e
+            Jekyll.logger.warn("Failed to load #{metadata_file}: #{e}")
+            {}
+          end
+        else
+          {}
+        end
+    end
+
+    private
+    def regenerate_page?(document)
+      document.asset_file? || document.data["regenerate"] ||
+        source_modified_or_dest_missing?(
+          site.in_source_dir(document.relative_path), document.destination(@site.dest)
+        )
+    end
+
+    private
+    def regenerate_document?(document)
+      !document.write? || document.data["regenerate"] ||
+        source_modified_or_dest_missing?(
+          document.path, document.destination(@site.dest)
+        )
+    end
+
+    private
+    def existing_file_modified?(path)
+      # If one of this file dependencies have been modified,
+      # set the regeneration bit for both the dependency and the file to true
+      metadata[path]["deps"].each do |dependency|
+        if modified?(dependency)
+          return cache[dependency] = cache[path] = true
+        end
+      end
+
+      if File.exist?(path) && metadata[path]["mtime"].eql?(File.mtime(path))
+        # If this file has not been modified, set the regeneration bit to false
+        cache[path] = false
+      else
+        # If it has been modified, set it to true
+        add(path)
+      end
+    end
+  end
+end