jekyll 3.9.3 → 4.4.1

data/lib/jekyll/configuration.rb

@@ -4,11 +4,12 @@ module Jekyll
   class Configuration < Hash
     # Default options. Overridden by values in _config.yml.
     # Strings rather than symbols are used for compatibility with YAML.
-    DEFAULTS = Configuration[{
+    DEFAULTS = {
       # Where things are
       "source"              => Dir.pwd,
       "destination"         => File.join(Dir.pwd, "_site"),
       "collections_dir"     => "",
+      "cache_dir"           => ".jekyll-cache",
       "plugins_dir"         => "_plugins",
       "layouts_dir"         => "_layouts",
       "data_dir"            => "_data",
@@ -18,10 +19,7 @@ module Jekyll
       # Handling Reading
       "safe"                => false,
       "include"             => [".htaccess"],
-      "exclude"             => %w(
-        Gemfile Gemfile.lock node_modules vendor/bundle/ vendor/cache/ vendor/gems/
-        vendor/ruby/
-      ),
+      "exclude"             => [],
       "keep_files"          => [".git", ".svn"],
       "encoding"            => "utf-8",
       "markdown_ext"        => "markdown,mkdown,mkdn,mkd,md",
@@ -66,17 +64,9 @@ module Jekyll
         "strict_variables" => false,
       },
 
-      "rdiscount"           => {
-        "extensions" => [],
-      },
-
-      "redcarpet"           => {
-        "extensions" => [],
-      },
-
       "kramdown"            => {
         "auto_ids"      => true,
-        "toc_levels"    => "1..6",
+        "toc_levels"    => (1..6).to_a,
         "entity_output" => "as_char",
         "smart_quotes"  => "lsquo,rsquo,ldquo,rdquo",
         "input"         => "GFM",
@@ -85,22 +75,18 @@ module Jekyll
         "footnote_nr"   => 1,
         "show_warnings" => false,
       },
-    }.map { |k, v| [k, v.freeze] }].freeze
+    }.each_with_object(Configuration.new) { |(k, v), hsh| hsh[k] = v.freeze }.freeze
 
     class << self
       # Static: Produce a Configuration ready for use in a Site.
-      # It takes the input, fills in the defaults where values do not
-      # exist, and patches common issues including migrating options for
-      # backwards compatiblity. Except where a key or value is being fixed,
-      # the user configuration will override the defaults.
+      # It takes the input, fills in the defaults where values do not exist.
       #
       # user_config - a Hash or Configuration of overrides.
       #
-      # Returns a Configuration filled with defaults and fixed for common
-      # problems and backwards-compatibility.
+      # Returns a Configuration filled with defaults.
       def from(user_config)
         Utils.deep_merge_hashes(DEFAULTS, Configuration[user_config].stringify_keys)
-          .add_default_collections
+          .add_default_collections.add_default_excludes
       end
     end
 
@@ -108,7 +94,7 @@ module Jekyll
     #
     # Return a copy of the hash where all its keys are strings
     def stringify_keys
-      reduce({}) { |hsh, (k, v)| hsh.merge(k.to_s => v) }
+      each_with_object({}) { |(k, v), hsh| hsh[k.to_s] = v }
     end
 
     def get_config_value_with_override(config_key, override)
@@ -142,8 +128,8 @@ module Jekyll
       when %r!\.ya?ml!i
         SafeYAML.load_file(filename) || {}
       else
-        raise ArgumentError, "No parser for '#{filename}' is available.
-          Use a .y(a)ml or .toml file instead."
+        raise ArgumentError,
+              "No parser for '#{filename}' is available. Use a .y(a)ml or .toml file instead."
       end
     end
 
@@ -162,7 +148,7 @@ module Jekyll
       # Get configuration from <source>/_config.yml or <source>/<config_file>
       config_files = override["config"]
       if config_files.to_s.empty?
-        default = %w(yml yaml).find(-> { "yml" }) do |ext|
+        default = %w(yml yaml toml).find(-> { "yml" }) do |ext|
           File.exist?(Jekyll.sanitized_path(source(override), "_config.#{ext}"))
         end
         config_files = Jekyll.sanitized_path(source(override), "_config.#{default}")
@@ -177,8 +163,13 @@ module Jekyll
     #
     # Returns this configuration, overridden by the values in the file
     def read_config_file(file)
+      file = File.expand_path(file)
       next_config = safe_load_file(file)
-      check_config_is_hash!(next_config, file)
+
+      unless next_config.is_a?(Hash)
+        raise ArgumentError, "Configuration file: (INVALID) #{file}".yellow
+      end
+
       Jekyll.logger.info "Configuration file:", file
       next_config
     rescue SystemCallError
@@ -186,8 +177,7 @@ module Jekyll
         Jekyll.logger.warn "Configuration file:", "none"
         {}
       else
-        Jekyll.logger.error "Fatal:", "The configuration file '#{file}'
-          could not be found."
+        Jekyll.logger.error "Fatal:", "The configuration file '#{file}' could not be found."
         raise LoadError, "The Configuration file '#{file}' could not be found."
       end
     end
@@ -204,16 +194,16 @@ module Jekyll
       begin
         files.each do |config_file|
           next if config_file.nil? || config_file.empty?
+
           new_config = read_config_file(config_file)
           configuration = Utils.deep_merge_hashes(configuration, new_config)
         end
-      rescue ArgumentError => err
-        Jekyll.logger.warn "WARNING:", "Error reading configuration. " \
-                     "Using defaults (and options)."
-        warn err
+      rescue ArgumentError => e
+        Jekyll.logger.warn "WARNING:", "Error reading configuration. Using defaults (and options)."
+        warn e
       end
 
-      configuration.backwards_compatibilize.add_default_collections
+      configuration.validate.add_default_collections
     end
 
     # Public: Split a CSV string into an array containing its values
@@ -225,35 +215,18 @@ module Jekyll
       csv.split(",").map(&:strip)
     end
 
-    # Public: Ensure the proper options are set in the configuration to allow for
-    # backwards-compatibility with Jekyll pre-1.0
+    # Public: Ensure the proper options are set in the configuration
     #
-    # Returns the backwards-compatible configuration
-    def backwards_compatibilize
+    # Returns the configuration Hash
+    def validate
       config = clone
-      # Provide backwards-compatibility
-      check_auto(config)
-      check_server(config)
-      check_plugins(config)
 
-      renamed_key "server_port", "port", config
-      renamed_key "gems", "plugins", config
-      renamed_key "layouts", "layouts_dir", config
-      renamed_key "data_source", "data_dir", config
-
-      check_pygments(config)
+      check_plugins(config)
       check_include_exclude(config)
-      check_coderay(config)
-      check_maruku(config)
 
       config
     end
 
-    # DEPRECATED.
-    def fix_common_issues
-      self
-    end
-
     def add_default_collections
       config = clone
 
@@ -262,7 +235,9 @@ module Jekyll
 
       # Ensure we have a hash.
       if config["collections"].is_a?(Array)
-        config["collections"] = Hash[config["collections"].map { |c| [c, {}] }]
+        config["collections"] = config["collections"].each_with_object({}) do |collection, hash|
+          hash[collection] = {}
+        end
       end
 
       config["collections"] = Utils.deep_merge_hashes(
@@ -277,109 +252,44 @@ module Jekyll
       config
     end
 
-    def renamed_key(old, new, config, _ = nil)
-      if config.key?(old)
-        Jekyll::Deprecator.deprecation_message "The '#{old}' configuration" \
-          " option has been renamed to '#{new}'. Please update your config" \
-          " file accordingly."
-        config[new] = config.delete(old)
-      end
-    end
+    DEFAULT_EXCLUDES = %w(
+      .sass-cache .jekyll-cache
+      gemfiles Gemfile Gemfile.lock
+      node_modules
+      vendor/bundle/ vendor/cache/ vendor/gems/ vendor/ruby/
+    ).freeze
 
-    private
-    def style_to_permalink(permalink_style)
-      case permalink_style.to_sym
-      when :pretty
-        "/:categories/:year/:month/:day/:title/"
-      when :none
-        "/:categories/:title:output_ext"
-      when :date
-        "/:categories/:year/:month/:day/:title:output_ext"
-      when :ordinal
-        "/:categories/:year/:y_day/:title:output_ext"
-      else
-        permalink_style.to_s
-      end
-    end
+    def add_default_excludes
+      config = clone
+      return config if config["exclude"].nil?
 
-    # Private: Checks if a given config is a hash
-    #
-    # extracted_config - the value to check
-    # file - the file from which the config was extracted
-    #
-    # Raises an ArgumentError if given config is not a hash
-    private
-    def check_config_is_hash!(extracted_config, file)
-      unless extracted_config.is_a?(Hash)
-        raise ArgumentError, "Configuration file: (INVALID) #{file}".yellow
-      end
+      config["exclude"].concat(DEFAULT_EXCLUDES).uniq!
+      config
     end
 
     private
-    def check_auto(config)
-      if config.key?("auto") || config.key?("watch")
-        Jekyll::Deprecator.deprecation_message "Auto-regeneration can no longer" \
-                            " be set from your configuration file(s). Use the" \
-                            " --[no-]watch/-w command-line option instead."
-        config.delete("auto")
-        config.delete("watch")
-      end
-    end
 
-    private
-    def check_server(config)
-      if config.key?("server")
-        Jekyll::Deprecator.deprecation_message "The 'server' configuration option" \
-                            " is no longer accepted. Use the 'jekyll serve'" \
-                            " subcommand to serve your site with WEBrick."
-        config.delete("server")
-      end
-    end
+    STYLE_TO_PERMALINK = {
+      :none     => "/:categories/:title:output_ext",
+      :date     => "/:categories/:year/:month/:day/:title:output_ext",
+      :ordinal  => "/:categories/:year/:y_day/:title:output_ext",
+      :pretty   => "/:categories/:year/:month/:day/:title/",
+      :weekdate => "/:categories/:year/W:week/:short_day/:title:output_ext",
+    }.freeze
 
-    private
-    def check_pygments(config)
-      if config.key?("pygments")
-        Jekyll::Deprecator.deprecation_message "The 'pygments' configuration option" \
-                            " has been renamed to 'highlighter'. Please update your" \
-                            " config file accordingly. The allowed values are 'rouge', " \
-                            "'pygments' or null."
-
-        config["highlighter"] = "pygments" if config["pygments"]
-        config.delete("pygments")
-      end
+    private_constant :STYLE_TO_PERMALINK
+
+    def style_to_permalink(permalink_style)
+      STYLE_TO_PERMALINK[permalink_style.to_sym] || permalink_style.to_s
     end
 
-    private
     def check_include_exclude(config)
       %w(include exclude).each do |option|
-        if config[option].is_a?(String)
-          Jekyll::Deprecator.deprecation_message "The '#{option}' configuration option" \
-            " must now be specified as an array, but you specified" \
-            " a string. For now, we've treated the string you provided" \
-            " as a list of comma-separated values."
-          config[option] = csv_to_array(config[option])
-        end
-        config[option].map!(&:to_s) if config[option]
-      end
-    end
-
-    private
-    def check_coderay(config)
-      if (config["kramdown"] || {}).key?("use_coderay")
-        Jekyll::Deprecator.deprecation_message "Please change 'use_coderay'" \
-          " to 'enable_coderay' in your configuration file."
-        config["kramdown"]["use_coderay"] = config["kramdown"].delete("enable_coderay")
-      end
-    end
+        next unless config.key?(option)
+        next if config[option].is_a?(Array)
 
-    private
-    def check_maruku(config)
-      if config.fetch("markdown", "kramdown").to_s.casecmp("maruku").zero?
-        Jekyll.logger.abort_with "Error:", "You're using the 'maruku' " \
-          "Markdown processor, which has been removed as of 3.0.0. " \
-          "We recommend you switch to Kramdown. To do this, replace " \
-          "`markdown: maruku` with `markdown: kramdown` in your " \
-          "`_config.yml` file."
+        raise Jekyll::Errors::InvalidConfigurationError,
+              "'#{option}' should be set as an array, but was: #{config[option].inspect}."
       end
     end
 
@@ -388,18 +298,16 @@ module Jekyll
     # config - the config hash
     #
     # Raises a Jekyll::Errors::InvalidConfigurationError if the config `plugins`
-    # is a string
-    private
+    # is not an Array.
     def check_plugins(config)
-      if config.key?("plugins") && config["plugins"].is_a?(String)
-        Jekyll.logger.error "Configuration Error:", "You specified the" \
-          " `plugins` config in your configuration file as a string, please" \
-          " use an array instead. If you wanted to set the directory of your" \
-          " plugins, use the config key `plugins_dir` instead."
-        raise Jekyll::Errors::InvalidConfigurationError,
-          "'plugins' should not be a string, but was: " \
-          "#{config["plugins"].inspect}. Use 'plugins_dir' instead."
-      end
+      return unless config.key?("plugins")
+      return if config["plugins"].is_a?(Array)
+
+      Jekyll.logger.error "'plugins' should be set as an array of gem-names, but was: " \
+                          "#{config["plugins"].inspect}. Use 'plugins_dir' instead to set " \
+                          "the directory for your non-gemified Ruby plugins."
+      raise Jekyll::Errors::InvalidConfigurationError,
+            "'plugins' should be set as an array, but was: #{config["plugins"].inspect}."
     end
   end
 end

data/lib/jekyll/converters/identity.rb

@@ -2,19 +2,37 @@
 
 module Jekyll
   module Converters
+    # Identity converter. Returns same content as given.
+    # For more info on converters see https://jekyllrb.com/docs/plugins/converters/
     class Identity < Converter
       safe true
 
       priority :lowest
 
+      # Public: Does the given extension match this converter's list of acceptable extensions?
+      # Takes one argument: the file's extension (including the dot).
+      #
+      # _ext - The String extension to check (not relevant here)
+      #
+      # Returns true since it always matches.
       def matches(_ext)
         true
       end
 
+      # Public: The extension to be given to the output file (including the dot).
+      #
+      # ext - The String extension or original file.
+      #
+      # Returns The String output file extension.
       def output_ext(ext)
         ext
       end
 
+      # Logic to do the content conversion.
+      #
+      # content - String content of file (without front matter).
+      #
+      # Returns a String of the converted content.
       def convert(content)
         content
       end

data/lib/jekyll/converters/markdown/kramdown_parser.rb

@@ -1,4 +1,72 @@
-# Frozen-string-literal: true
+# frozen_string_literal: true
+
+module Kramdown
+  # A Kramdown::Document subclass meant to optimize memory usage from initializing
+  # a kramdown document for parsing.
+  #
+  # The optimization is by using the same options Hash (and its derivatives) for
+  # converting all Markdown documents in a Jekyll site.
+  class JekyllDocument < Document
+    class << self
+      attr_reader :options, :parser
+
+      # The implementation is basically the core logic in +Kramdown::Document#initialize+
+      #
+      # rubocop:disable Naming/MemoizedInstanceVariableName
+      def setup(options)
+        @cache ||= {}
+
+        # reset variables on a subsequent set up with a different options Hash
+        unless @cache[:id] == options.hash
+          @options = @parser = nil
+          @cache[:id] = options.hash
+        end
+
+        @options ||= Options.merge(options).freeze
+        @parser  ||= begin
+          parser_name = (@options[:input] || "kramdown").to_s
+          parser_name = parser_name[0..0].upcase + parser_name[1..-1]
+          try_require("parser", parser_name)
+
+          if Parser.const_defined?(parser_name)
+            Parser.const_get(parser_name)
+          else
+            raise Kramdown::Error, "kramdown has no parser to handle the specified " \
+                                   "input format: #{@options[:input]}"
+          end
+        end
+      end
+      # rubocop:enable Naming/MemoizedInstanceVariableName
+
+      private
+
+      def try_require(type, name)
+        require "kramdown/#{type}/#{Utils.snake_case(name)}"
+      rescue LoadError
+        false
+      end
+    end
+
+    def initialize(source, options = {})
+      JekyllDocument.setup(options)
+
+      @options = JekyllDocument.options
+      @root, @warnings = JekyllDocument.parser.parse(source, @options)
+    end
+
+    # Use Kramdown::Converter::Html class to convert this document into HTML.
+    #
+    # The implementation is basically an optimized version of core logic in
+    # +Kramdown::Document#method_missing+ from kramdown-2.1.0.
+    def to_html
+      output, warnings = Kramdown::Converter::Html.convert(@root, @options)
+      @warnings.concat(warnings)
+      output
+    end
+  end
+end
+
+#
 
 module Jekyll
   module Converters
@@ -35,11 +103,10 @@ module Jekyll
           @config["syntax_highlighter_opts"]["guess_lang"] = @config["guess_lang"]
           @config["coderay"] ||= {} # XXX: Legacy.
           modernize_coderay_config
-          make_accessible
         end
 
         def convert(content)
-          document = Kramdown::Document.new(content, @config)
+          document = Kramdown::JekyllDocument.new(content, @config)
           html_output = document.to_html
           if @config["show_warnings"]
             document.warnings.each do |warning|
@@ -52,36 +119,24 @@ module Jekyll
         private
 
         def load_dependencies
-          return if Kramdown::VERSION.to_i < 2
-          if @config["input"] == "GFM"
-            Jekyll::External.require_with_graceful_fail("kramdown-parser-gfm")
-          end
+          require "kramdown-parser-gfm" if @config["input"] == "GFM"
 
           if highlighter == "coderay"
             Jekyll::External.require_with_graceful_fail("kramdown-syntax-coderay")
           end
 
-          # `mathjax` emgine is bundled within kramdown-2.x and will be handled by
+          # `mathjax` engine is bundled within kramdown-2.x and will be handled by
           # kramdown itself.
           if (math_engine = @config["math_engine"]) && math_engine != "mathjax"
             Jekyll::External.require_with_graceful_fail("kramdown-math-#{math_engine}")
           end
         end
 
-        def make_accessible(hash = @config)
-          hash.keys.each do |key|
-            hash[key.to_sym] = hash[key]
-            make_accessible(hash[key]) if hash[key].is_a?(Hash)
-          end
-        end
-
-        # config[kramdown][syntax_higlighter] >
+        # config[kramdown][syntax_highlighter] >
         #   config[kramdown][enable_coderay] >
         #   config[highlighter]
         # Where `enable_coderay` is now deprecated because Kramdown
         # supports Rouge now too.
-
-        private
         def highlighter
           return @highlighter if @highlighter
 
@@ -91,24 +146,21 @@ module Jekyll
             ]
           end
 
-          @highlighter = begin
-            if @config.key?("enable_coderay") && @config["enable_coderay"]
-              Jekyll::Deprecator.deprecation_message(
-                "You are using 'enable_coderay', " \
-                "use syntax_highlighter: coderay in your configuration file."
-              )
+          @highlighter = if @config.key?("enable_coderay") && @config["enable_coderay"]
+                           Jekyll::Deprecator.deprecation_message(
+                             "You are using 'enable_coderay', " \
+                             "use syntax_highlighter: coderay in your configuration file."
+                           )
 
-              "coderay"
-            else
-              @main_fallback_highlighter
-            end
-          end
+                           "coderay"
+                         else
+                           @main_fallback_highlighter
+                         end
         end
 
-        private
         def strip_coderay_prefix(hash)
           hash.each_with_object({}) do |(key, val), hsh|
-            cleaned_key = key.to_s.gsub(%r!\Acoderay_!, "")
+            cleaned_key = key.to_s.delete_prefix("coderay_")
 
             if key != cleaned_key
               Jekyll::Deprecator.deprecation_message(
@@ -123,8 +175,6 @@ module Jekyll
         # If our highlighter is CodeRay we go in to merge the CodeRay defaults
         # with your "coderay" key if it's there, deprecating it in the
         # process of you using it.
-
-        private
         def modernize_coderay_config
           unless @config["coderay"].empty?
             Jekyll::Deprecator.deprecation_message(