jekyll 3.10.0 → 4.0.0.pre.alpha1

data/lib/jekyll/site.rb

@@ -2,7 +2,7 @@
 
 module Jekyll
   class Site
-    attr_reader   :source, :dest, :config
+    attr_reader   :source, :dest, :cache_dir, :config
     attr_accessor :layouts, :pages, :static_files, :drafts,
                   :exclude, :include, :lsi, :highlighter, :permalink_style,
                   :time, :future, :unpublished, :safe, :plugins, :limit_posts,
@@ -22,6 +22,8 @@ module Jekyll
 
       self.config = config
 
+      @cache_dir       = in_source_dir(config["cache_dir"])
+
       @reader          = Reader.new(self)
       @regenerator     = Regenerator.new(self)
       @liquid_renderer = LiquidRenderer.new(self)
@@ -44,13 +46,14 @@ module Jekyll
       @config = config.clone
 
       %w(safe lsi highlighter baseurl exclude include future unpublished
-        show_drafts limit_posts keep_files).each do |opt|
-        self.send("#{opt}=", config[opt])
+         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_cache
       configure_plugins
       configure_theme
       configure_include_paths
@@ -58,6 +61,8 @@ module Jekyll
 
       self.permalink_style = config["permalink"].to_sym
 
+      # Read in a _config.yml from the current theme-gem at the very end.
+      @config = load_theme_configuration(config) if theme
       @config
     end
 
@@ -78,6 +83,8 @@ module Jekyll
       Jekyll.logger.info @liquid_renderer.stats_table
     end
 
+    # rubocop:disable Metrics/MethodLength
+    #
     # Reset Site details.
     #
     # Returns nothing
@@ -91,19 +98,22 @@ module Jekyll
       self.pages = []
       self.static_files = []
       self.data = {}
+      @post_attr_hash = {}
       @site_data = nil
       @collections = nil
+      @documents = nil
       @docs_to_write = nil
       @regenerator.clear_cache
       @liquid_renderer.reset
       @site_cleaner = nil
+      frontmatter_defaults.reset
 
-      if limit_posts < 0
-        raise ArgumentError, "limit_posts must be a non-negative number"
-      end
+      raise ArgumentError, "limit_posts must be a non-negative number" if limit_posts.negative?
 
+      Jekyll::Cache.clear_if_config_changed config
       Jekyll::Hooks.trigger :site, :after_reset, self
     end
+    # rubocop:enable Metrics/MethodLength
 
     # Load necessary libraries, plugins, converters, and generators.
     #
@@ -124,7 +134,7 @@ module Jekyll
       Pathname.new(source).ascend do |path|
         if path == dest_pathname
           raise Errors::FatalException,
-            "Destination directory cannot be or contain the Source directory."
+                "Destination directory cannot be or contain the Source directory."
         end
       end
     end
@@ -174,7 +184,7 @@ module Jekyll
         start = Time.now
         generator.generate(self)
         Jekyll.logger.debug "Generating:",
-          "#{generator.class} finished in #{Time.now - start} seconds."
+                            "#{generator.class} finished in #{Time.now - start} seconds."
       end
     end
 
@@ -232,12 +242,14 @@ module Jekyll
     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 } if p.data[post_attr]
+      @post_attr_hash[post_attr] ||= begin
+        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
-      hash.each_value { |posts| posts.sort!.reverse! }
-      hash
     end
 
     def tags
@@ -303,10 +315,10 @@ module Jekyll
     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."
+                                 " 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
 
@@ -314,15 +326,15 @@ module Jekyll
     #
     # Returns an Array of Documents which should be written
     def docs_to_write
-      documents.select(&:write?)
+      @docs_to_write ||= documents.select(&:write?)
     end
 
     # Get all the documents
     #
     # Returns an Array of all Documents
     def documents
-      collections.each_with_object(Set.new) do |(_, collection), set|
-        set.merge(collection.docs).merge(collection.files)
+      @documents ||= collections.reduce(Set.new) do |docs, (_, collection)|
+        docs + collection.docs + collection.files
       end.to_a
     end
 
@@ -377,6 +389,7 @@ module Jekyll
     # 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
@@ -394,6 +407,18 @@ module Jekyll
       end
     end
 
+    # Public: Prefix a given path with the cache directory.
+    #
+    # paths - (optional) path elements to a file or directory within the
+    #         cache directory
+    #
+    # Returns a path which is prefixed with the cache directory.
+    def in_cache_dir(*paths)
+      paths.reduce(cache_dir) 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.
     #
@@ -403,14 +428,34 @@ module Jekyll
       @collections_path ||= dir_str.empty? ? source : in_source_dir(dir_str)
     end
 
+    private
+
+    def load_theme_configuration(config)
+      theme_config_file = in_theme_dir("_config.yml")
+      return config unless File.exist?(theme_config_file)
+
+      # Bail out if the theme_config_file is a symlink file irrespective of safe mode
+      return config if File.symlink?(theme_config_file)
+
+      theme_config = SafeYAML.load_file(theme_config_file)
+      return config unless theme_config.is_a?(Hash)
+
+      Jekyll.logger.info "Theme Config file:", theme_config_file
+
+      # theme_config should not be overriding Jekyll's defaults
+      theme_config.delete_if { |key, _| Configuration::DEFAULTS.key?(key) }
+
+      # Override theme_config with existing config and return the result.
+      Utils.deep_merge_hashes(theme_config, config)
+    end
+
     # Limits the current posts; removes the posts which exceed the limit_posts
     #
     # Returns nothing
-    private
     def limit_posts!
-      if limit_posts > 0
+      if limit_posts.positive?
         limit = posts.docs.length < limit_posts ? posts.docs.length : limit_posts
-        self.posts.docs = posts.docs[-limit, limit]
+        posts.docs = posts.docs[-limit, limit]
       end
     end
 
@@ -418,18 +463,21 @@ module Jekyll
     # already exist.
     #
     # Returns The Cleaner
-    private
     def site_cleaner
       @site_cleaner ||= Cleaner.new(self)
     end
 
-    private
+    # Disable Marshaling cache to disk in Safe Mode
+    def configure_cache
+      Jekyll::Cache.base_dir = in_source_dir(config["cache_dir"], "Jekyll/Cache")
+      Jekyll::Cache.disable_disk_cache! if safe
+    end
+
     def configure_plugins
       self.plugin_manager = Jekyll::PluginManager.new(self)
       self.plugins        = plugin_manager.plugins_path
     end
 
-    private
     def configure_theme
       self.theme = nil
       return if config["theme"].nil?
@@ -444,20 +492,17 @@ module Jekyll
         end
     end
 
-    private
     def configure_include_paths
       @includes_load_paths = Array(in_source_dir(config["includes_dir"].to_s))
-      @includes_load_paths << theme.includes_path if theme && theme.includes_path
+      @includes_load_paths << theme.includes_path if theme&.includes_path
     end
 
-    private
     def configure_file_read_opts
       self.file_read_opts = {}
-      self.file_read_opts[:encoding] = config["encoding"] if config["encoding"]
+      file_read_opts[:encoding] = config["encoding"] if config["encoding"]
       self.file_read_opts = Jekyll::Utils.merged_file_read_opts(self, {})
     end
 
-    private
     def render_docs(payload)
       collections.each_value do |collection|
         collection.docs.each do |document|
@@ -466,16 +511,15 @@ module Jekyll
       end
     end
 
-    private
     def render_pages(payload)
-      pages.flatten.each do |page|
+      pages.each do |page|
         render_regenerated(page, payload)
       end
     end
 
-    private
     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

data/lib/jekyll/static_file.rb

@@ -54,7 +54,8 @@ module Jekyll
     #
     # Returns destination file path.
     def destination(dest)
-      @site.in_dest_dir(*[dest, destination_rel_dir, @name].compact)
+      dest = @site.in_dest_dir(dest)
+      @site.in_dest_dir(dest, Jekyll::URL.unescape_path(url))
     end
 
     def destination_rel_dir
@@ -86,7 +87,10 @@ module Jekyll
     # Returns true unless the defaults for the destination path from
     # _config.yml contain `published: false`.
     def write?
-      defaults.fetch("published", true)
+      publishable = defaults.fetch("published", true)
+      return publishable unless @collection
+
+      publishable && @collection.write?
     end
 
     # Write the static file to the destination directory (if modified).
@@ -96,8 +100,8 @@ module Jekyll
     # Returns false if the file was not modified since last time (no-op).
     def write(dest)
       dest_path = destination(dest)
-
       return false if File.exist?(dest_path) && !modified?
+
       self.class.mtimes[path] = mtime
 
       FileUtils.mkdir_p(File.dirname(dest_path))
@@ -111,33 +115,58 @@ module Jekyll
       @to_liquid ||= Drops::StaticFileDrop.new(self)
     end
 
+    # Generate "basename without extension" and strip away any trailing periods.
+    # NOTE: `String#gsub` removes all trailing periods (in comparison to `String#chomp`)
     def basename
-      File.basename(name, extname)
+      @basename ||= File.basename(name, extname).gsub(%r!\.*\z!, "")
     end
 
     def placeholders
       {
         :collection => @collection.label,
-        :path       => relative_path[
-          @collection.relative_directory.size..relative_path.size],
+        :path       => cleaned_relative_path,
         :output_ext => "",
         :name       => "",
         :title      => "",
       }
     end
 
+    # Similar to Jekyll::Document#cleaned_relative_path.
+    # Generates a relative path with the collection's directory removed when applicable
+    #   and additionally removes any multiple periods in the string.
+    #
+    # NOTE: `String#gsub!` removes all trailing periods (in comparison to `String#chomp!`)
+    #
+    # Examples:
+    #   When `relative_path` is "_methods/site/my-cool-avatar...png":
+    #     cleaned_relative_path
+    #     # => "/site/my-cool-avatar"
+    #
+    # Returns the cleaned relative path of the static file.
+    def cleaned_relative_path
+      @cleaned_relative_path ||= begin
+        cleaned = relative_path[0..-extname.length - 1]
+        cleaned.gsub!(%r!\.*\z!, "")
+        cleaned.sub!(@collection.relative_directory, "") if @collection
+        cleaned
+      end
+    end
+
     # Applies a similar URL-building technique as Jekyll::Document that takes
     # the collection's URL template into account. The default URL template can
     # be overriden in the collection's configuration in _config.yml.
     def url
-      @url ||= if @collection.nil?
-                 relative_path
+      @url ||= begin
+        base = if @collection.nil?
+                 cleaned_relative_path
                else
-                 ::Jekyll::URL.new({
+                 Jekyll::URL.new(
                    :template     => @collection.url_template,
-                   :placeholders => placeholders,
-                 })
+                   :placeholders => placeholders
+                 )
                end.to_s.chomp("/")
+        base << extname
+      end
     end
 
     # Returns the type of the collection if present, nil otherwise.
@@ -151,7 +180,14 @@ module Jekyll
       @defaults ||= @site.frontmatter_defaults.all url, type
     end
 
+    # Returns a debug string on inspecting the static file.
+    # Includes only the relative path of the object.
+    def inspect
+      "#<#{self.class} @relative_path=#{relative_path.inspect}>"
+    end
+
     private
+
     def copy_file(dest_path)
       if @site.safe || Jekyll.env == "production"
         FileUtils.cp(path, dest_path)

data/lib/jekyll/stevenson.rb

@@ -3,19 +3,21 @@
 module Jekyll
   class Stevenson < ::Logger
     def initialize
-      formatter = proc do |_, _, _, msg|
+      @progname = nil
+      @level = DEBUG
+      @default_formatter = Formatter.new
+      @logdev = $stdout
+      @formatter = proc do |_, _, _, msg|
         msg.to_s
       end
-      super($stdout, :formatter => formatter)
     end
 
     def add(severity, message = nil, progname = nil)
       severity ||= UNKNOWN
       @logdev = logdevice(severity)
 
-      if @logdev.nil? || severity < @level
-        return true
-      end
+      return true if @logdev.nil? || severity < @level
+
       progname ||= @progname
       if message.nil?
         if block_given?

data/lib/jekyll/tags/highlight.rb

@@ -2,7 +2,7 @@
 
 module Jekyll
   module Tags
-    class HighlightBlock < Liquid::Block
+    class HighlightBlock < Liquid::Raw
       include Liquid::StandardFilters
 
       # The regular expression syntax checker. Start with the language specifier.
@@ -10,7 +10,7 @@ module Jekyll
       # forms: name, name=value, or name="<quoted list>"
       #
       # <quoted list> is a space-separated list of numbers
-      SYNTAX = %r!^([a-zA-Z0-9.+#_-]+)((\s+\w+(=(\w+|"([0-9]+\s)*[0-9]+"))?)*)$!
+      SYNTAX = %r!^([a-zA-Z0-9.+#_-]+)((\s+\w+(=(\w+|"([0-9]+\s)*[0-9]+"))?)*)$!.freeze
 
       def initialize(tag_name, markup, tokens)
         super
@@ -18,29 +18,29 @@ module Jekyll
           @lang = Regexp.last_match(1).downcase
           @highlight_options = parse_options(Regexp.last_match(2))
         else
-          raise SyntaxError, <<-MSG
-Syntax Error in tag 'highlight' while parsing the following markup:
+          raise SyntaxError, <<~MSG
+            Syntax Error in tag 'highlight' while parsing the following markup:
 
-  #{markup}
+            #{markup}
 
-Valid syntax: highlight <lang> [linenos]
-MSG
+            Valid syntax: highlight <lang> [linenos]
+          MSG
         end
       end
 
+      LEADING_OR_TRAILING_LINE_TERMINATORS = %r!\A(\n|\r)+|(\n|\r)+\z!.freeze
+
       def render(context)
         prefix = context["highlighter_prefix"] || ""
         suffix = context["highlighter_suffix"] || ""
-        code = super.to_s.gsub(%r!\A(\n|\r)+|(\n|\r)+\z!, "")
-
-        is_safe = !!context.registers[:site].safe
+        code   = @body.gsub(LEADING_OR_TRAILING_LINE_TERMINATORS, "")
 
         output =
           case context.registers[:site].highlighter
-          when "pygments"
-            render_pygments(code, is_safe)
           when "rouge"
             render_rouge(code)
+          when "pygments"
+            render_pygments(code, context)
           else
             render_codehighlighter(code)
           end
@@ -49,23 +49,9 @@ MSG
         prefix + rendered_output + suffix
       end
 
-      def sanitized_opts(opts, is_safe)
-        if is_safe
-          Hash[[
-            [:startinline, opts.fetch(:startinline, nil)],
-            [:hl_lines,    opts.fetch(:hl_lines, nil)],
-            [:linenos,     opts.fetch(:linenos, nil)],
-            [:encoding,    opts.fetch(:encoding, "utf-8")],
-            [:cssclass,    opts.fetch(:cssclass, nil)],
-          ].reject { |f| f.last.nil? }]
-        else
-          opts
-        end
-      end
-
       private
 
-      OPTIONS_REGEX = %r!(?:\w="[^"]*"|\w=\w|\w)+!
+      OPTIONS_REGEX = %r!(?:\w="[^"]*"|\w=\w|\w)+!.freeze
 
       def parse_options(input)
         options = {}
@@ -75,7 +61,7 @@ MSG
         input.scan(OPTIONS_REGEX) do |opt|
           key, value = opt.split("=")
           # If a quoted list, convert to array
-          if value && value.include?('"')
+          if value&.include?('"')
             value.delete!('"')
             value = value.split
           end
@@ -86,33 +72,15 @@ MSG
         options
       end
 
-      def render_pygments(code, is_safe)
-        Jekyll::External.require_with_graceful_fail("pygments") unless defined?(Pygments)
-
-        highlighted_code = Pygments.highlight(
-          code,
-          :lexer   => @lang,
-          :options => sanitized_opts(@highlight_options, is_safe)
-        )
-
-        if highlighted_code.nil?
-          Jekyll.logger.error <<-MSG
-There was an error highlighting your code:
-
-#{code}
-
-While attempting to convert the above code, Pygments.rb returned an unacceptable value.
-This is usually a timeout problem solved by running `jekyll build` again.
-MSG
-          raise ArgumentError, "Pygments.rb returned an unacceptable value "\
-          "when attempting to highlight some code."
-        end
-
-        highlighted_code.sub('<div class="highlight"><pre>', "").sub("</pre></div>", "")
+      def render_pygments(code, _context)
+        Jekyll.logger.warn "Warning:", "Highlight Tag no longer supports rendering with Pygments."
+        Jekyll.logger.warn "", "Using the default highlighter, Rouge, instead."
+        render_rouge(code)
       end
 
       def render_rouge(code)
-        formatter = Jekyll::Utils::Rouge.html_formatter(
+        require "rouge"
+        formatter = ::Rouge::Formatters::HTMLLegacy.new(
           :line_numbers => @highlight_options[:linenos],
           :wrap         => false,
           :css_class    => "highlight",
@@ -135,6 +103,8 @@ MSG
         "<figure class=\"highlight\"><pre><code #{code_attributes}>"\
         "#{code.chomp}</code></pre></figure>"
       end
+
+      def ensure_valid_markup(tag_name, markup, parse_context); end
     end
   end
 end