jekyll 3.9.3 → 4.4.1

data/lib/jekyll/path_manager.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Jekyll
+  # A singleton class that caches frozen instances of path strings returned from its methods.
+  #
+  # NOTE:
+  #   This class exists because `File.join` allocates an Array and returns a new String on every
+  #   call using **the same arguments**. Caching the result means reduced memory usage.
+  #   However, the caches are never flushed so that they can be used even when a site is
+  #   regenerating. The results are frozen to deter mutation of the cached string.
+  #
+  #   Therefore, employ this class only for situations where caching the result is necessary
+  #   for performance reasons.
+  #
+  class PathManager
+    # This class cannot be initialized from outside
+    private_class_method :new
+
+    class << self
+      # Wraps `File.join` to cache the frozen result.
+      # Reassigns `nil`, empty strings and empty arrays to a frozen empty string beforehand.
+      #
+      # Returns a frozen string.
+      def join(base, item)
+        base = "" if base.nil? || base.empty?
+        item = "" if item.nil? || item.empty?
+        @join ||= {}
+        @join[base] ||= {}
+        @join[base][item] ||= File.join(base, item).freeze
+      end
+
+      # Ensures the questionable path is prefixed with the base directory
+      # and prepends the questionable path with the base directory if false.
+      #
+      # Returns a frozen string.
+      def sanitized_path(base_directory, questionable_path)
+        @sanitized_path ||= {}
+        @sanitized_path[base_directory] ||= {}
+        @sanitized_path[base_directory][questionable_path] ||= if questionable_path.nil?
+                                                                 base_directory.freeze
+                                                               else
+                                                                 sanitize_and_join(
+                                                                   base_directory, questionable_path
+                                                                 ).freeze
+                                                               end
+      end
+
+      private
+
+      def sanitize_and_join(base_directory, questionable_path)
+        clean_path = if questionable_path.start_with?("~")
+                       questionable_path.dup.insert(0, "/")
+                     else
+                       questionable_path
+                     end
+        clean_path = File.expand_path(clean_path, "/")
+        return clean_path if clean_path.eql?(base_directory)
+
+        # remove any remaining extra leading slashes not stripped away by calling
+        # `File.expand_path` above.
+        clean_path.squeeze!("/")
+        return clean_path if clean_path.start_with?(slashed_dir_cache(base_directory))
+
+        clean_path.sub!(%r!\A\w:/!, "/")
+        join(base_directory, clean_path)
+      end
+
+      def slashed_dir_cache(base_directory)
+        @slashed_dir_cache ||= {}
+        @slashed_dir_cache[base_directory] ||= base_directory.sub(%r!\z!, "/")
+      end
+    end
+  end
+end

data/lib/jekyll/plugin.rb

@@ -13,7 +13,7 @@ module Jekyll
     #
 
     def self.inherited(const)
-      return catch_inheritance(const) do |const_|
+      catch_inheritance(const) do |const_|
         catch_inheritance(const_)
       end
     end
@@ -23,9 +23,7 @@ module Jekyll
     def self.catch_inheritance(const)
       const.define_singleton_method :inherited do |const_|
         (@children ||= Set.new).add const_
-        if block_given?
-          yield const_
-        end
+        yield const_ if block_given?
       end
     end
 
@@ -48,9 +46,7 @@ module Jekyll
     # Returns the Symbol priority.
     def self.priority(priority = nil)
       @priority ||= nil
-      if priority && PRIORITIES.key?(priority)
-        @priority = priority
-      end
+      @priority = priority if priority && PRIORITIES.key?(priority)
       @priority || :normal
     end
 
@@ -62,9 +58,7 @@ module Jekyll
     #
     # Returns the safety Boolean.
     def self.safe(safe = nil)
-      unless defined?(@safe) && safe.nil?
-        @safe = safe
-      end
+      @safe = safe unless defined?(@safe) && safe.nil?
       @safe || false
     end
 
@@ -74,7 +68,7 @@ module Jekyll
     #
     # Returns -1, 0, 1.
     def self.<=>(other)
-      PRIORITIES[other.priority] <=> PRIORITIES[self.priority]
+      PRIORITIES[other.priority] <=> PRIORITIES[priority]
     end
 
     # Spaceship is priority [higher -> lower]

data/lib/jekyll/plugin_manager.rb

@@ -37,14 +37,16 @@ module Jekyll
     # Returns false only if no dependencies have been specified, otherwise nothing.
     def require_theme_deps
       return false unless site.theme.runtime_dependencies
+
       site.theme.runtime_dependencies.each do |dep|
         next if dep.name == "jekyll"
+
         External.require_with_graceful_fail(dep.name) if plugin_allowed?(dep.name)
       end
     end
 
     def self.require_from_bundler
-      if !ENV["JEKYLL_NO_BUNDLER_REQUIRE"] && File.file?("Gemfile")
+      if !ENV["JEKYLL_NO_BUNDLER_REQUIRE"] && gemfile_exists?
         require "bundler"
 
         Bundler.setup
@@ -59,6 +61,13 @@ module Jekyll
       end
     end
 
+    # Check for the existence of a Gemfile.
+    #
+    # Returns true if a Gemfile exists in the places bundler will look
+    def self.gemfile_exists?
+      File.file?("Gemfile") || (ENV["BUNDLE_GEMFILE"] && File.file?(ENV["BUNDLE_GEMFILE"]))
+    end
+
     # Check whether a gem plugin is allowed to be used during this build.
     #
     # plugin_name - the name of the plugin
@@ -74,7 +83,7 @@ module Jekyll
     # Returns an array of strings, each string being the name of a gem name
     #   that is allowed to be used.
     def whitelist
-      @whitelist ||= Array[site.config["whitelist"]].flatten
+      @whitelist ||= [site.config["whitelist"]].flatten
     end
 
     # Require all .rb files if safe mode is off
@@ -104,9 +113,10 @@ module Jekyll
       pagination_included = (site.config["plugins"] || []).include?("jekyll-paginate") ||
         defined?(Jekyll::Paginate)
       if site.config["paginate"] && !pagination_included
-        Jekyll::Deprecator.deprecation_message "You appear to have pagination " \
-          "turned on, but you haven't included the `jekyll-paginate` gem. " \
-          "Ensure you have `plugins: [jekyll-paginate]` in your configuration file."
+        Jekyll::Deprecator.deprecation_message <<~MSG
+          You appear to have pagination turned on, but you haven't included the `jekyll-paginate`
+          gem. Ensure you have `plugins: [jekyll-paginate]` in your configuration file.
+        MSG
       end
     end
   end

data/lib/jekyll/profiler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Profiler
+    TERMINAL_TABLE_STYLES = {
+      :alignment     => :right,
+      :border_top    => false,
+      :border_bottom => false,
+    }.freeze
+    private_constant :TERMINAL_TABLE_STYLES
+
+    def self.tabulate(table_rows)
+      require "terminal-table"
+
+      rows   = table_rows.dup
+      header = rows.shift
+      output = +"\n"
+
+      table = Terminal::Table.new do |t|
+        t << header
+        t << :separator
+        rows.each { |row| t << row }
+        t.style = TERMINAL_TABLE_STYLES
+        t.align_column(0, :left)
+      end
+
+      output << table.to_s << "\n"
+    end
+
+    def initialize(site)
+      @site = site
+    end
+
+    def profile_process
+      profile_data = { "PHASE" => "TIME" }
+
+      [:reset, :read, :generate, :render, :cleanup, :write].each do |method|
+        start_time = Time.now
+        @site.send(method)
+        end_time = (Time.now - start_time).round(4)
+        profile_data[method.to_s.upcase] = format("%.4f", end_time)
+      end
+
+      Jekyll.logger.info "\nBuild Process Summary:"
+      Jekyll.logger.info Profiler.tabulate(Array(profile_data))
+
+      Jekyll.logger.info "\nSite Render Stats:"
+      @site.print_stats
+    end
+  end
+end

data/lib/jekyll/reader.rb

@@ -14,10 +14,28 @@ module Jekyll
     def read
       @site.layouts = LayoutReader.new(site).read
       read_directories
+      read_included_excludes
       sort_files!
-      @site.data = DataReader.new(site).read(site.config["data_dir"])
       CollectionReader.new(site).read
       ThemeAssetsReader.new(site).read
+      read_data
+    end
+
+    # Read and merge the data files.
+    # If a theme is specified and it contains data, it will be read.
+    # Site data will overwrite theme data with the same key using the
+    # semantics of Utils.deep_merge_hashes.
+    #
+    # Returns nothing.
+    def read_data
+      @site.data = DataReader.new(site).read(site.config["data_dir"])
+      return unless site.theme&.data_path
+
+      theme_data = DataReader.new(
+        site,
+        :in_source_dir => site.method(:in_theme_dir)
+      ).read(site.theme.data_path)
+      @site.data = Jekyll::Utils.deep_merge_hashes(theme_data, @site.data)
     end
 
     # Sorts posts, pages, and static files.
@@ -39,13 +57,21 @@ module Jekyll
 
       return unless File.directory?(base)
 
+      dot_dirs = []
+      dot_pages = []
+      dot_static_files = []
+
       dot = Dir.chdir(base) { filter_entries(Dir.entries("."), base) }
-      dot_dirs = dot.select { |file| File.directory?(@site.in_source_dir(base, file)) }
-      dot_files = (dot - dot_dirs)
-      dot_pages = dot_files.select do |file|
-        Utils.has_yaml_header?(@site.in_source_dir(base, file))
+      dot.each do |entry|
+        file_path = @site.in_source_dir(base, entry)
+        if File.directory?(file_path)
+          dot_dirs << entry
+        elsif Utils.has_yaml_header?(file_path)
+          dot_pages << entry
+        else
+          dot_static_files << entry
+        end
       end
-      dot_static_files = dot_files - dot_pages
 
       retrieve_posts(dir)
       retrieve_dirs(base, dir, dot_dirs)
@@ -61,6 +87,7 @@ module Jekyll
     # Returns nothing.
     def retrieve_posts(dir)
       return if outside_configured_directory?(dir)
+
       site.posts.docs.concat(post_reader.read_posts(dir))
       site.posts.docs.concat(post_reader.read_drafts(dir)) if site.show_drafts
     end
@@ -75,10 +102,8 @@ module Jekyll
     def retrieve_dirs(_base, dir, dot_dirs)
       dot_dirs.each do |file|
         dir_path = site.in_source_dir(dir, file)
-        rel_path = File.join(dir, file)
-        unless @site.dest.chomp("/") == dir_path
-          @site.reader.read_directories(rel_path)
-        end
+        rel_path = PathManager.join(dir, file)
+        @site.reader.read_directories(rel_path) unless @site.dest.chomp("/") == dir_path
       end
     end
 
@@ -126,6 +151,7 @@ module Jekyll
     def get_entries(dir, subfolder)
       base = site.in_source_dir(dir, subfolder)
       return [] unless File.exist?(base)
+
       entries = Dir.chdir(base) { filter_entries(Dir["**/*"], base) }
       entries.delete_if { |e| File.directory?(site.in_source_dir(base, e)) }
     end
@@ -150,5 +176,34 @@ module Jekyll
     def post_reader
       @post_reader ||= PostReader.new(site)
     end
+
+    def read_included_excludes
+      entry_filter = EntryFilter.new(site)
+
+      site.include.each do |entry|
+        entry_path = site.in_source_dir(entry)
+        next if File.directory?(entry_path)
+        next if entry_filter.symlink?(entry_path)
+
+        read_included_file(entry_path) if File.file?(entry_path)
+      end
+    end
+
+    def read_included_file(entry_path)
+      if Utils.has_yaml_header?(entry_path)
+        conditionally_generate_entry(entry_path, site.pages, PageReader)
+      else
+        conditionally_generate_entry(entry_path, site.static_files, StaticFileReader)
+      end
+    end
+
+    def conditionally_generate_entry(entry_path, container, reader)
+      return if container.find { |item| site.in_source_dir(item.relative_path) == entry_path }
+
+      dir, files = File.split(entry_path)
+      dir.sub!(site.source, "")
+      files = Array(files)
+      container.concat(reader.new(site, dir).read(files))
+    end
   end
 end

data/lib/jekyll/readers/collection_reader.rb

@@ -5,6 +5,7 @@ module Jekyll
     SPECIAL_COLLECTIONS = %w(posts data).freeze
 
     attr_reader :site, :content
+
     def initialize(site)
       @site = site
       @content = {}

data/lib/jekyll/readers/data_reader.rb

@@ -3,10 +3,13 @@
 module Jekyll
   class DataReader
     attr_reader :site, :content
-    def initialize(site)
+
+    def initialize(site, in_source_dir: nil)
       @site = site
       @content = {}
       @entry_filter = EntryFilter.new(site)
+      @in_source_dir = in_source_dir || @site.method(:in_source_dir)
+      @source_dir = @in_source_dir.call("/")
     end
 
     # Read all the files in <dir> and adds them to @content
@@ -16,7 +19,7 @@ module Jekyll
     # 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)
+      base = @in_source_dir.call(dir)
       read_data_to(base, @content)
       @content
     end
@@ -36,7 +39,7 @@ module Jekyll
       end
 
       entries.each do |entry|
-        path = @site.in_source_dir(dir, entry)
+        path = @in_source_dir.call(dir, entry)
         next if @entry_filter.symlink?(path)
 
         if File.directory?(path)
@@ -52,16 +55,13 @@ module Jekyll
     #
     # Returns the contents of the data file.
     def read_data_file(path)
+      Jekyll.logger.debug "Reading:", path.sub(@source_dir, "")
+
       case File.extname(path).downcase
       when ".csv"
-        CSV.read(path,
-          :headers  => true,
-          :encoding => site.config["encoding"]).map(&:to_hash)
+        CSV.read(path, **csv_config).map { |row| convert_row(row) }
       when ".tsv"
-        CSV.read(path,
-          :col_sep  => "\t",
-          :headers  => true,
-          :encoding => site.config["encoding"]).map(&:to_hash)
+        CSV.read(path, **tsv_config).map { |row| convert_row(row) }
       else
         SafeYAML.load_file(path)
       end
@@ -71,5 +71,43 @@ module Jekyll
       name.gsub(%r![^\w\s-]+|(?<=^|\b\s)\s+(?=$|\s?\b)!, "")
         .gsub(%r!\s+!, "_")
     end
+
+    private
+
+    # @return [Hash]
+    def csv_config
+      @csv_config ||= read_config("csv_reader")
+    end
+
+    # @return [Hash]
+    def tsv_config
+      @tsv_config ||= read_config("tsv_reader", { :col_sep => "\t" })
+    end
+
+    # @param config_key [String]
+    # @param overrides [Hash]
+    # @return [Hash]
+    # @see https://ruby-doc.org/stdlib-2.5.0/libdoc/csv/rdoc/CSV.html#Converters
+    def read_config(config_key, overrides = {})
+      reader_config = config[config_key] || {}
+
+      defaults = {
+        :converters => reader_config.fetch("csv_converters", []).map(&:to_sym),
+        :headers    => reader_config.fetch("headers", true),
+        :encoding   => reader_config.fetch("encoding", config["encoding"]),
+      }
+
+      defaults.merge(overrides)
+    end
+
+    def config
+      @config ||= site.config
+    end
+
+    # @param row [Array, CSV::Row]
+    # @return [Array, Hash]
+    def convert_row(row)
+      row.instance_of?(CSV::Row) ? row.to_hash : row
+    end
   end
 end

data/lib/jekyll/readers/layout_reader.rb

@@ -3,6 +3,7 @@
 module Jekyll
   class LayoutReader
     attr_reader :site
+
     def initialize(site)
       @site = site
       @layouts = {}
@@ -23,7 +24,7 @@ module Jekyll
     end
 
     def layout_directory
-      @layout_directory ||= (layout_directory_in_cwd || layout_directory_inside_source)
+      @layout_directory ||= site.in_source_dir(site.config["layouts_dir"])
     end
 
     def theme_layout_directory
@@ -54,18 +55,8 @@ module Jekyll
 
     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
+      Dir.chdir(directory) { yield }
     end
   end
 end

data/lib/jekyll/readers/page_reader.rb

@@ -3,20 +3,20 @@
 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.
+    # Create a new `Jekyll::Page` object for each entry in a given array.
     #
-    # dir - The String relative path of the directory to read.
+    # files - An array of file names inside `@dir`
     #
-    # Returns an array of static pages.
+    # Returns an array of publishable `Jekyll::Page` objects.
     def read(files)
-      files.map do |page|
+      files.each do |page|
         @unfiltered_content << Page.new(@site, @site.source, @dir, page)
       end
       @unfiltered_content.select { |page| site.publisher.publish?(page) }

data/lib/jekyll/readers/post_reader.rb

@@ -3,6 +3,7 @@
 module Jekyll
   class PostReader
     attr_reader :site, :unfiltered_content
+
     def initialize(site)
       @site = site
     end
@@ -34,19 +35,9 @@ module Jekyll
     #
     # 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
+      read_content(dir, magic_dir, matcher)
+        .tap { |docs| docs.each(&:read) }
+        .select { |doc| processable?(doc) }
     end
 
     # Read all the content files from <source>/<dir>/magic_dir
@@ -60,13 +51,35 @@ module Jekyll
     # 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
+        next unless matcher.match?(entry)
+
         path = @site.in_source_dir(File.join(dir, magic_dir, entry))
-        Document.new(path, {
-          :site       => @site,
-          :collection => @site.posts,
-        })
-      end.reject(&:nil?)
+        Document.new(path,
+                     :site       => @site,
+                     :collection => @site.posts)
+      end.tap(&:compact!)
+    end
+
+    private
+
+    def processable?(doc)
+      if doc.content.nil?
+        Jekyll.logger.debug "Skipping:", "Content in #{doc.relative_path} is nil"
+        false
+      elsif !doc.content.valid_encoding?
+        Jekyll.logger.debug "Skipping:", "#{doc.relative_path} is not valid UTF-8"
+        false
+      else
+        publishable?(doc)
+      end
+    end
+
+    def publishable?(doc)
+      site.publisher.publish?(doc).tap do |will_publish|
+        if !will_publish && site.publisher.hidden_in_the_future?(doc)
+          Jekyll.logger.warn "Skipping:", "#{doc.relative_path} has a future date"
+        end
+      end
     end
   end
 end

data/lib/jekyll/readers/static_file_reader.rb

@@ -3,20 +3,20 @@
 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.
+    # Create a new StaticFile object for every entry in a given list of basenames.
     #
-    # dir - The String relative path of the directory to read.
+    # files - an array of file basenames.
     #
     # Returns an array of static files.
     def read(files)
-      files.map do |file|
+      files.each do |file|
         @unfiltered_content << StaticFile.new(@site, @site.source, @dir, file)
       end
       @unfiltered_content

data/lib/jekyll/readers/theme_assets_reader.rb

@@ -3,15 +3,17 @@
 module Jekyll
   class ThemeAssetsReader
     attr_reader :site
+
     def initialize(site)
       @site = site
     end
 
     def read
-      return unless site.theme && site.theme.assets_path
+      return unless 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
@@ -21,6 +23,7 @@ module Jekyll
     end
 
     private
+
     def read_theme_asset(path)
       base = site.theme.root
       dir = File.dirname(path.sub("#{site.theme.root}/", ""))
@@ -28,18 +31,18 @@ module Jekyll
 
       if Utils.has_yaml_header?(path)
         append_unless_exists site.pages,
-          Jekyll::Page.new(site, base, dir, name)
+                             Jekyll::Page.new(site, base, dir, name)
       else
         append_unless_exists site.static_files,
-          Jekyll::StaticFile.new(site, base, "/#{dir}", name)
+                             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."
+                            "Ignoring #{new_item.relative_path} in theme due to existing file " \
+                            "with that path in site."
         return
       end