jekyll 3.9.1 → 4.0.0.pre.alpha1

data/lib/jekyll/filters/grouping_filters.rb

@@ -41,16 +41,15 @@ module Jekyll
       end
 
       private
+
       def parse_expression(str)
         Liquid::Variable.new(str, Liquid::ParseContext.new)
       end
 
-      private
       def groupable?(element)
         element.respond_to?(:group_by)
       end
 
-      private
       def grouped_array(groups)
         groups.each_with_object([]) do |item, array|
           array << {

data/lib/jekyll/filters/url_filters.rb

@@ -10,10 +10,13 @@ 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
@@ -27,6 +30,7 @@ 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?
 
@@ -43,6 +47,7 @@ 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
 
@@ -55,9 +60,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

@@ -10,6 +10,11 @@ module Jekyll
     # Initializes a new instance.
     def initialize(site)
       @site = site
+      reset
+    end
+
+    def reset
+      @glob_cache = {}
     end
 
     def update_deprecated_types(set)
@@ -36,6 +41,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,39 +98,44 @@ 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
+        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 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)
+        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[path] ||= Dir.glob(path)
+    end
 
     def path_is_subpath?(path, parent_path)
       path.ascend do |ascended_path|
-        if ascended_path.to_s == parent_path.to_s
-          return true
-        end
+        return true if ascended_path.to_s == parent_path.to_s
       end
 
       false
@@ -134,6 +145,7 @@ module Jekyll
       collections_dir  = @site.config["collections_dir"]
       slashed_coll_dir = "#{collections_dir}/"
       return path if collections_dir.empty? || !path.to_s.start_with?(slashed_coll_dir)
+
       path.sub(slashed_coll_dir, "")
     end
 
@@ -188,8 +200,12 @@ module Jekyll
     #
     # 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
 
@@ -216,7 +232,7 @@ module Jekyll
 
     # Sanitizes the given path by removing a leading and adding a trailing slash
 
-    SANITIZATION_REGEX = %r!\A/|(?<=[^/])\z!
+    SANITIZATION_REGEX = %r!\A/|(?<=[^/])\z!.freeze
 
     def sanitize_path(path)
       if path.nil? || path.empty?

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

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

@@ -18,6 +18,7 @@ module Jekyll
 
     def reset
       @stats = {}
+      @cache = {}
     end
 
     def file(filename)
@@ -30,7 +31,6 @@ module Jekyll
         end
       LiquidRenderer::File.new(self, filename).tap do
         @stats[filename] ||= new_profile_hash
-        @stats[filename][:count] += 1
       end
     end
 
@@ -42,6 +42,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,6 +54,14 @@ 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

data/lib/jekyll/liquid_renderer/file.rb

@@ -10,8 +10,9 @@ 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
@@ -19,15 +20,20 @@ module Jekyll
       def render(*args)
         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)
         measure_time do
           measure_bytes do
-            @template.render!(*args)
+            measure_counts do
+              @template.render!(*args)
+            end
           end
         end
       end
@@ -38,6 +44,11 @@ module Jekyll
 
       private
 
+      def measure_counts
+        @renderer.increment_count(@filename)
+        yield
+      end
+
       def measure_bytes
         yield.tap do |str|
           @renderer.increment_bytes(@filename, str.bytesize)

data/lib/jekyll/liquid_renderer/table.rb

@@ -1,96 +1,98 @@
 # frozen_string_literal: true
 
 module Jekyll
-  class LiquidRenderer::Table
-    def initialize(stats)
-      @stats = stats
-    end
+  class LiquidRenderer
+    class Table
+      def initialize(stats)
+        @stats = stats
+      end
 
-    def to_s(num_of_rows = 50)
-      data = data_for_table(num_of_rows)
-      widths = table_widths(data)
-      generate_table(data, widths)
-    end
+      def to_s(num_of_rows = 50)
+        data = data_for_table(num_of_rows)
+        widths = table_widths(data)
+        generate_table(data, widths)
+      end
 
-    private
+      private
 
-    def generate_table(data, widths)
-      str = String.new("\n")
+      def generate_table(data, widths)
+        str = +"\n"
 
-      table_head = data.shift
-      str << generate_row(table_head, widths)
-      str << generate_table_head_border(table_head, widths)
+        table_head = data.shift
+        str << generate_row(table_head, widths)
+        str << generate_table_head_border(table_head, widths)
 
-      data.each do |row_data|
-        str << generate_row(row_data, widths)
+        data.each do |row_data|
+          str << generate_row(row_data, widths)
+        end
+
+        str << "\n"
+        str
       end
 
-      str << "\n"
-      str
-    end
+      def generate_table_head_border(row_data, widths)
+        str = +""
 
-    def generate_table_head_border(row_data, widths)
-      str = String.new("")
+        row_data.each_index do |cell_index|
+          str << "-" * widths[cell_index]
+          str << "-+-" unless cell_index == row_data.length - 1
+        end
 
-      row_data.each_index do |cell_index|
-        str << "-" * widths[cell_index]
-        str << "-+-" unless cell_index == row_data.length - 1
+        str << "\n"
+        str
       end
 
-      str << "\n"
-      str
-    end
+      def generate_row(row_data, widths)
+        str = +""
 
-    def generate_row(row_data, widths)
-      str = String.new("")
+        row_data.each_with_index do |cell_data, cell_index|
+          str << if cell_index.zero?
+                   cell_data.ljust(widths[cell_index], " ")
+                 else
+                   cell_data.rjust(widths[cell_index], " ")
+                 end
 
-      row_data.each_with_index do |cell_data, cell_index|
-        str << if cell_index.zero?
-                 cell_data.ljust(widths[cell_index], " ")
-               else
-                 cell_data.rjust(widths[cell_index], " ")
-               end
+          str << " | " unless cell_index == row_data.length - 1
+        end
 
-        str << " | " unless cell_index == row_data.length - 1
+        str << "\n"
+        str
       end
 
-      str << "\n"
-      str
-    end
-
-    def table_widths(data)
-      widths = []
+      def table_widths(data)
+        widths = []
 
-      data.each do |row|
-        row.each_with_index do |cell, index|
-          widths[index] = [cell.length, widths[index]].compact.max
+        data.each do |row|
+          row.each_with_index do |cell, index|
+            widths[index] = [cell.length, widths[index]].compact.max
+          end
         end
+
+        widths
       end
 
-      widths
-    end
+      def data_for_table(num_of_rows)
+        sorted = @stats.sort_by { |_, file_stats| -file_stats[:time] }
+        sorted = sorted.slice(0, num_of_rows)
 
-    def data_for_table(num_of_rows)
-      sorted = @stats.sort_by { |_, file_stats| -file_stats[:time] }
-      sorted = sorted.slice(0, num_of_rows)
+        table = [%w(Filename Count Bytes Time)]
 
-      table = [%w(Filename Count Bytes Time)]
+        sorted.each do |filename, file_stats|
+          row = []
+          row << filename
+          row << file_stats[:count].to_s
+          row << format_bytes(file_stats[:bytes])
+          row << format("%.3f", file_stats[:time])
+          table << row
+        end
 
-      sorted.each do |filename, file_stats|
-        row = []
-        row << filename
-        row << file_stats[:count].to_s
-        row << format_bytes(file_stats[:bytes])
-        row << format("%.3f", file_stats[:time])
-        table << row
+        table
       end
 
-      table
-    end
-
-    def format_bytes(bytes)
-      bytes /= 1024.0
-      format("%.2fK", bytes)
+      def format_bytes(bytes)
+        bytes /= 1024.0
+        format("%.2fK", bytes)
+      end
     end
   end
 end