jekyll 3.8.7 → 4.1.0

data/lib/jekyll/filters/url_filters.rb

@@ -10,13 +10,17 @@ module Jekyll
       # Returns the absolute URL as a String.
       def absolute_url(input)
         return if input.nil?
-        input = input.url if input.respond_to?(:url)
-        return input if Addressable::URI.parse(input.to_s).absolute?
-        site = @context.registers[:site]
-        return relative_url(input) if site.config["url"].nil?
-        Addressable::URI.parse(
-          site.config["url"].to_s + relative_url(input)
-        ).normalize.to_s
+
+        cache = if input.is_a?(String)
+                  (@context.registers[:site].filter_cache[:absolute_url] ||= {})
+                else
+                  (@context.registers[:cached_absolute_url] ||= {})
+                end
+        cache[input] ||= compute_absolute_url(input)
+
+        # Duplicate cached string so that the cached value is never mutated by
+        # a subsequent filter.
+        cache[input].dup
       end
 
       # Produces a URL relative to the domain root based on site.baseurl
@@ -27,13 +31,17 @@ module Jekyll
       # Returns a URL relative to the domain root as a String.
       def relative_url(input)
         return if input.nil?
-        input = input.url if input.respond_to?(:url)
-        return input if Addressable::URI.parse(input.to_s).absolute?
 
-        parts = [sanitized_baseurl, input]
-        Addressable::URI.parse(
-          parts.compact.map { |part| ensure_leading_slash(part.to_s) }.join
-        ).normalize.to_s
+        cache = if input.is_a?(String)
+                  (@context.registers[:site].filter_cache[:relative_url] ||= {})
+                else
+                  (@context.registers[:cached_relative_url] ||= {})
+                end
+        cache[input] ||= compute_relative_url(input)
+
+        # Duplicate cached string so that the cached value is never mutated by
+        # a subsequent filter.
+        cache[input].dup
       end
 
       # Strips trailing `/index.html` from URLs to create pretty permalinks
@@ -43,11 +51,35 @@ module Jekyll
       # Returns a URL with the trailing `/index.html` removed
       def strip_index(input)
         return if input.nil? || input.to_s.empty?
+
         input.sub(%r!/index\.html?$!, "/")
       end
 
       private
 
+      def compute_absolute_url(input)
+        input = input.url if input.respond_to?(:url)
+        return input if Addressable::URI.parse(input.to_s).absolute?
+
+        site = @context.registers[:site]
+        site_url = site.config["url"]
+        return relative_url(input) if site_url.nil? || site_url == ""
+
+        Addressable::URI.parse(
+          site_url.to_s + relative_url(input)
+        ).normalize.to_s
+      end
+
+      def compute_relative_url(input)
+        input = input.url if input.respond_to?(:url)
+        return input if Addressable::URI.parse(input.to_s).absolute?
+
+        parts = [sanitized_baseurl, input]
+        Addressable::URI.parse(
+          parts.compact.map { |part| ensure_leading_slash(part.to_s) }.join
+        ).normalize.to_s
+      end
+
       def sanitized_baseurl
         site = @context.registers[:site]
         site.config["baseurl"].to_s.chomp("/")
@@ -55,9 +87,9 @@ module Jekyll
 
       def ensure_leading_slash(input)
         return input if input.nil? || input.empty? || input.start_with?("/")
+
         "/#{input}"
       end
-
     end
   end
 end

data/lib/jekyll/frontmatter_defaults.rb

@@ -12,6 +12,10 @@ module Jekyll
       @site = site
     end
 
+    def reset
+      @glob_cache = {} if @glob_cache
+    end
+
     def update_deprecated_types(set)
       return set unless set.key?("scope") && set["scope"].key?("type")
 
@@ -36,6 +40,7 @@ module Jekyll
     def ensure_time!(set)
       return set unless set.key?("values") && set["values"].key?("date")
       return set if set["values"]["date"].is_a?(Time)
+
       set["values"]["date"] = Utils.parse_date(
         set["values"]["date"],
         "An invalid date format was found in a front-matter default set: #{set}"
@@ -92,48 +97,51 @@ module Jekyll
     # path - the path to check for
     # type - the type (:post, :page or :draft) to check for
     #
-    # Returns true if the scope applies to the given path and type
+    # Returns true if the scope applies to the given type and path
     def applies?(scope, path, type)
-      applies_path?(scope, path) && applies_type?(scope, type)
+      applies_type?(scope, type) && applies_path?(scope, path)
     end
 
-    # rubocop:disable Metrics/AbcSize
     def applies_path?(scope, path)
-      return true if !scope.key?("path") || scope["path"].empty?
-
-      sanitized_path = Pathname.new(sanitize_path(path))
-      site_path      = Pathname.new(@site.source)
-      rel_scope_path = Pathname.new(scope["path"])
-      abs_scope_path = File.join(@site.source, rel_scope_path)
-
-      if scope["path"].to_s.include?("*")
-        Dir.glob(abs_scope_path).each do |scope_path|
-          scope_path = Pathname.new(scope_path).relative_path_from(site_path)
-          scope_path = strip_collections_dir(scope_path)
-          Jekyll.logger.debug "Globbed Scope Path:", scope_path
-          return true if path_is_subpath?(sanitized_path, scope_path)
-        end
-        false
+      rel_scope_path = scope["path"]
+      return true if !rel_scope_path.is_a?(String) || rel_scope_path.empty?
+
+      sanitized_path = sanitize_path(path)
+
+      if rel_scope_path.include?("*")
+        glob_scope(sanitized_path, rel_scope_path)
       else
         path_is_subpath?(sanitized_path, strip_collections_dir(rel_scope_path))
       end
     end
-    # rubocop:enable Metrics/AbcSize
 
-    def path_is_subpath?(path, parent_path)
-      path.ascend do |ascended_path|
-        if ascended_path.to_s == parent_path.to_s
-          return true
-        end
-      end
+    def glob_scope(sanitized_path, rel_scope_path)
+      site_source    = Pathname.new(@site.source)
+      abs_scope_path = site_source.join(rel_scope_path).to_s
 
+      glob_cache(abs_scope_path).each do |scope_path|
+        scope_path = Pathname.new(scope_path).relative_path_from(site_source).to_s
+        scope_path = strip_collections_dir(scope_path)
+        Jekyll.logger.debug "Globbed Scope Path:", scope_path
+        return true if path_is_subpath?(sanitized_path, scope_path)
+      end
       false
     end
 
+    def glob_cache(path)
+      @glob_cache ||= {}
+      @glob_cache[path] ||= Dir.glob(path)
+    end
+
+    def path_is_subpath?(path, parent_path)
+      path.start_with?(parent_path)
+    end
+
     def strip_collections_dir(path)
       collections_dir  = @site.config["collections_dir"]
-      slashed_coll_dir = "#{collections_dir}/"
+      slashed_coll_dir = collections_dir.empty? ? "/" : "#{collections_dir}/"
       return path if collections_dir.empty? || !path.to_s.start_with?(slashed_coll_dir)
+
       path.sub(slashed_coll_dir, "")
     end
 
@@ -167,7 +175,7 @@ module Jekyll
     # new_scope - the new scope hash
     #
     # Returns true if the new scope has precedence over the older
-    # rubocop: disable PredicateName
+    # rubocop: disable Naming/PredicateName
     def has_precedence?(old_scope, new_scope)
       return true if old_scope.nil?
 
@@ -182,14 +190,18 @@ module Jekyll
         !old_scope.key? "type"
       end
     end
-    # rubocop: enable PredicateName
+    # rubocop: enable Naming/PredicateName
 
     # Collects a list of sets that match the given path and type
     #
     # Returns an array of hashes
     def matching_sets(path, type)
-      valid_sets.select do |set|
-        !set.key?("scope") || applies?(set["scope"], path, type)
+      @matched_set_cache ||= {}
+      @matched_set_cache[path] ||= {}
+      @matched_set_cache[path][type] ||= begin
+        valid_sets.select do |set|
+          !set.key?("scope") || applies?(set["scope"], path, type)
+        end
       end
     end
 
@@ -214,15 +226,14 @@ module Jekyll
       end.compact
     end
 
-    # Sanitizes the given path by removing a leading and adding a trailing slash
-
-    SANITIZATION_REGEX = %r!\A/|(?<=[^/])\z!
-
+    # Sanitizes the given path by removing a leading slash
     def sanitize_path(path)
       if path.nil? || path.empty?
         ""
+      elsif path.start_with?("/")
+        path.gsub(%r!\A/|(?<=[^/])\z!, "")
       else
-        path.gsub(SANITIZATION_REGEX, "")
+        path
       end
     end
   end

data/lib/jekyll/hooks.rb

@@ -60,6 +60,7 @@ module Jekyll
     # Ensure the priority is a Fixnum
     def self.priority_value(priority)
       return priority if priority.is_a?(Integer)
+
       PRIORITY_MAP[priority] || DEFAULT_PRIORITY
     end
 
@@ -77,9 +78,7 @@ module Jekyll
           "following hooks #{@registry[owner].keys.inspect}"
       end
 
-      unless block.respond_to? :call
-        raise Uncallable, "Hooks must respond to :call"
-      end
+      raise Uncallable, "Hooks must respond to :call" unless block.respond_to? :call
 
       insert_hook owner, event, priority, &block
     end
@@ -92,11 +91,8 @@ module Jekyll
     # interface for Jekyll core components to trigger hooks
     def self.trigger(owner, event, *args)
       # proceed only if there are hooks to call
-      return unless @registry[owner]
-      return unless @registry[owner][event]
-
-      # hooks to call for this owner and event
-      hooks = @registry[owner][event]
+      hooks = @registry.dig(owner, event)
+      return if hooks.nil? || hooks.empty?
 
       # sort and call hooks according to priority and load order
       hooks.sort_by { |h| @hook_priority[h] }.each do |hook|

data/lib/jekyll/inclusion.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Inclusion
+    attr_reader :site, :name, :path
+    private :site
+
+    def initialize(site, base, name)
+      @site = site
+      @name = name
+      @path = PathManager.join(base, name)
+    end
+
+    def render(context)
+      @template ||= site.liquid_renderer.file(path).parse(content)
+      @template.render!(context)
+    rescue Liquid::Error => e
+      e.template_name  = path
+      e.markup_context = "included " if e.markup_context.nil?
+      raise e
+    end
+
+    def content
+      @content ||= File.read(path, **site.file_read_opts)
+    end
+
+    def inspect
+      "#{self.class} #{path.inspect}"
+    end
+    alias_method :to_s, :inspect
+  end
+end

data/lib/jekyll/liquid_extensions.rb

@@ -2,7 +2,6 @@
 
 module Jekyll
   module LiquidExtensions
-
     # Lookup a Liquid variable in the given context.
     #
     # context  - the Liquid context in question.
@@ -19,6 +18,5 @@ module Jekyll
 
       lookup || variable
     end
-
   end
 end

data/lib/jekyll/liquid_renderer.rb

@@ -5,11 +5,6 @@ require_relative "liquid_renderer/table"
 
 module Jekyll
   class LiquidRenderer
-    extend Forwardable
-
-    private def_delegator :@site, :in_source_dir, :source_dir
-    private def_delegator :@site, :in_theme_dir, :theme_dir
-
     def initialize(site)
       @site = site
       Liquid::Template.error_mode = @site.config["liquid"]["error_mode"].to_sym
@@ -18,19 +13,13 @@ module Jekyll
 
     def reset
       @stats = {}
+      @cache = {}
     end
 
     def file(filename)
-      filename.match(filename_regex)
-      filename =
-        if Regexp.last_match(1) == theme_dir("")
-          ::File.join(::File.basename(Regexp.last_match(1)), Regexp.last_match(2))
-        else
-          Regexp.last_match(2)
-        end
+      filename = normalize_path(filename)
       LiquidRenderer::File.new(self, filename).tap do
         @stats[filename] ||= new_profile_hash
-        @stats[filename][:count] += 1
       end
     end
 
@@ -42,6 +31,10 @@ module Jekyll
       @stats[filename][:time] += time
     end
 
+    def increment_count(filename)
+      @stats[filename][:count] += 1
+    end
+
     def stats_table(num_of_rows = 50)
       LiquidRenderer::Table.new(@stats).to_s(num_of_rows)
     end
@@ -50,11 +43,33 @@ module Jekyll
       "#{error.message} in #{path}"
     end
 
+    # A persistent cache to store and retrieve parsed templates based on the filename
+    # via `LiquidRenderer::File#parse`
+    #
+    # It is emptied when `self.reset` is called.
+    def cache
+      @cache ||= {}
+    end
+
     private
 
-    def filename_regex
-      @filename_regex ||= begin
-        %r!\A(#{Regexp.escape(source_dir)}/|#{Regexp.escape(theme_dir.to_s)}/|/*)(.*)!i
+    def normalize_path(filename)
+      @normalize_path ||= {}
+      @normalize_path[filename] ||= begin
+        theme_dir = @site.theme&.root
+        case filename
+        when %r!\A(#{Regexp.escape(@site.source)}/)(?<rest>.*)!io
+          Regexp.last_match(:rest)
+        when %r!(/gems/.*)*/gems/(?<dirname>[^/]+)(?<rest>.*)!,
+             %r!(?<dirname>[^/]+/lib)(?<rest>.*)!
+          "#{Regexp.last_match(:dirname)}#{Regexp.last_match(:rest)}"
+        when theme_dir && %r!\A#{Regexp.escape(theme_dir)}/(?<rest>.*)!io
+          PathManager.join(@site.theme.basename, Regexp.last_match(:rest))
+        when %r!\A/(.*)!
+          Regexp.last_match(1)
+        else
+          filename
+        end
       end
     end
 

data/lib/jekyll/liquid_renderer/file.rb

@@ -10,24 +10,34 @@ module Jekyll
 
       def parse(content)
         measure_time do
-          @template = Liquid::Template.parse(content, :line_numbers => true)
+          @renderer.cache[@filename] ||= Liquid::Template.parse(content, :line_numbers => true)
         end
+        @template = @renderer.cache[@filename]
 
         self
       end
 
       def render(*args)
+        reset_template_assigns
+
         measure_time do
           measure_bytes do
-            @template.render(*args)
+            measure_counts do
+              @template.render(*args)
+            end
           end
         end
       end
 
+      # This method simply 'rethrows any error' before attempting to render the template.
       def render!(*args)
+        reset_template_assigns
+
         measure_time do
           measure_bytes do
-            @template.render!(*args)
+            measure_counts do
+              @template.render!(*args)
+            end
           end
         end
       end
@@ -38,6 +48,17 @@ module Jekyll
 
       private
 
+      # clear assigns to `Liquid::Template` instance prior to rendering since
+      # `Liquid::Template` instances are cached in Jekyll 4.
+      def reset_template_assigns
+        @template.instance_assigns.clear
+      end
+
+      def measure_counts
+        @renderer.increment_count(@filename)
+        yield
+      end
+
       def measure_bytes
         yield.tap do |str|
           @renderer.increment_bytes(@filename, str.bytesize)