jekyll 4.0.1 → 4.1.0

data/lib/jekyll/document.rb

@@ -116,7 +116,7 @@ module Jekyll
     #
     # Returns the output extension
     def output_ext
-      @output_ext ||= Jekyll::Renderer.new(site, self).output_ext
+      renderer.output_ext
     end
 
     # The base filename of the document, without the file extname.
@@ -133,6 +133,10 @@ module Jekyll
       @basename ||= File.basename(path)
     end
 
+    def renderer
+      @renderer ||= Jekyll::Renderer.new(site, self)
+    end
+
     # Produces a "cleaned" relative path.
     # The "cleaned" relative path is the relative path without the extname
     #   and with the collection's directory removed as well.
@@ -414,9 +418,13 @@ module Jekyll
     #
     # Returns nothing.
     def categories_from_path(special_dir)
-      superdirs = relative_path.sub(Document.superdirs_regex(special_dir), "")
-      superdirs = superdirs.split(File::SEPARATOR)
-      superdirs.reject! { |c| c.empty? || c == special_dir || c == basename }
+      if relative_path.start_with?(special_dir)
+        superdirs = []
+      else
+        superdirs = relative_path.sub(Document.superdirs_regex(special_dir), "")
+        superdirs = superdirs.split(File::SEPARATOR)
+        superdirs.reject! { |c| c.empty? || c == special_dir || c == basename }
+      end
 
       merge_data!({ "categories" => superdirs }, :source => "file path")
     end
@@ -490,6 +498,7 @@ module Jekyll
       end
     end
 
+    # rubocop:disable Metrics/AbcSize
     def populate_title
       if relative_path =~ DATE_FILENAME_MATCHER
         date, slug, ext = Regexp.last_match.captures
@@ -497,6 +506,10 @@ module Jekyll
       elsif relative_path =~ DATELESS_FILENAME_MATCHER
         slug, ext = Regexp.last_match.captures
       end
+      # `slug` will be nil for documents without an extension since the regex patterns
+      # above tests for an extension as well.
+      # In such cases, assign `basename_without_ext` as the slug.
+      slug ||= basename_without_ext
 
       # slugs shouldn't end with a period
       # `String#gsub!` removes all trailing periods (in comparison to `String#chomp!`)
@@ -508,6 +521,7 @@ module Jekyll
       data["slug"]  ||= slug
       data["ext"]   ||= ext
     end
+    # rubocop:enable Metrics/AbcSize
 
     def modify_date(date)
       if !data["date"] || data["date"].to_i == site.time.to_i

data/lib/jekyll/drops/document_drop.rb

@@ -64,6 +64,18 @@ module Jekyll
           result[key] = doc[key] unless NESTED_OBJECT_FIELD_BLACKLIST.include?(key)
         end
       end
+
+      def title
+        @obj.data["title"]
+      end
+
+      def categories
+        @obj.data["categories"]
+      end
+
+      def tags
+        @obj.data["tags"]
+      end
     end
   end
 end

data/lib/jekyll/drops/page_drop.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Drops
+    class PageDrop < Drop
+      extend Forwardable
+
+      mutable false
+
+      def_delegators :@obj, :content, :dir, :name, :path, :url, :excerpt
+      private def_delegator :@obj, :data, :fallback_data
+
+      def title
+        @obj.data["title"]
+      end
+    end
+  end
+end

data/lib/jekyll/drops/url_drop.rb

@@ -35,6 +35,14 @@ module Jekyll
         category_set.to_a.join("/")
       end
 
+      # Similar to output from #categories, but each category will be downcased and
+      # all non-alphanumeric characters of the category replaced with a hyphen.
+      def slugified_categories
+        Array(@obj.data["categories"]).each_with_object(Set.new) do |category, set|
+          set << Utils.slugify(category.to_s)
+        end.to_a.join("/")
+      end
+
       # CCYY
       def year
         @obj.date.strftime("%Y")

data/lib/jekyll/entry_filter.rb

@@ -3,6 +3,7 @@
 module Jekyll
   class EntryFilter
     attr_reader :site
+
     SPECIAL_LEADING_CHAR_REGEX = %r!\A#{Regexp.union([".", "_", "#", "~"])}!o.freeze
 
     def initialize(site, base_directory = nil)
@@ -27,20 +28,30 @@ module Jekyll
       )
     end
 
+    # rubocop:disable Metrics/CyclomaticComplexity
     def filter(entries)
       entries.reject do |e|
         # Reject this entry if it is just a "dot" representation.
         #   e.g.: '.', '..', '_movies/.', 'music/..', etc
         next true if e.end_with?(".")
-        # Reject this entry if it is a symlink.
+
+        # Check if the current entry is explicitly included and cache the result
+        included = included?(e)
+
+        # Reject current entry if it is excluded but not explicitly included as well.
+        next true if excluded?(e) && !included
+
+        # Reject current entry if it is a symlink.
         next true if symlink?(e)
-        # Do not reject this entry if it is included.
-        next false if included?(e)
 
-        # Reject this entry if it is special, a backup file, or excluded.
-        special?(e) || backup?(e) || excluded?(e)
+        # Do not reject current entry if it is explicitly included.
+        next false if included
+
+        # Reject current entry if it is special or a backup file.
+        special?(e) || backup?(e)
       end
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
 
     def included?(entry)
       glob_include?(site.include, entry) ||
@@ -91,6 +102,7 @@ module Jekyll
     # Returns true if path matches against any glob pattern, else false.
     def glob_include?(enumerator, entry)
       entry_with_source = PathManager.join(site.source, entry)
+      entry_is_directory = File.directory?(entry_with_source)
 
       enumerator.any? do |pattern|
         case pattern
@@ -98,7 +110,8 @@ module Jekyll
           pattern_with_source = PathManager.join(site.source, pattern)
 
           File.fnmatch?(pattern_with_source, entry_with_source) ||
-            entry_with_source.start_with?(pattern_with_source)
+            entry_with_source.start_with?(pattern_with_source) ||
+            (pattern_with_source == "#{entry_with_source}/" if entry_is_directory)
         when Regexp
           pattern.match?(entry_with_source)
         else

data/lib/jekyll/excerpt.rb

@@ -56,7 +56,7 @@ module Jekyll
     #
     # Returns true if the string passed in
     def include?(something)
-      (output&.include?(something)) || content.include?(something)
+      output&.include?(something) || content.include?(something)
     end
 
     # The UID for this doc (useful in feeds).

data/lib/jekyll/filters.rb

@@ -121,8 +121,20 @@ module Jekyll
     # input - The String on which to operate.
     #
     # Returns the Integer word count.
-    def number_of_words(input)
-      input.split.length
+    def number_of_words(input, mode = nil)
+      cjk_charset = '\p{Han}\p{Katakana}\p{Hiragana}\p{Hangul}'
+      cjk_regex = %r![#{cjk_charset}]!o
+      word_regex = %r![^#{cjk_charset}\s]+!o
+
+      case mode
+      when "cjk"
+        input.scan(cjk_regex).length + input.scan(word_regex).length
+      when "auto"
+        cjk_count = input.scan(cjk_regex).length
+        cjk_count.zero? ? input.split.length : cjk_count + input.scan(word_regex).length
+      else
+        input.split.length
+      end
     end
 
     # Join an array of things into a string by separating with commas and the
@@ -210,6 +222,66 @@ module Jekyll
       end || []
     end
 
+    # Search an array of objects and returns the first object that has the queried attribute
+    # with the given value or returns nil otherwise.
+    #
+    # input    - the object array.
+    # property - the property within each object to search by.
+    # value    - the desired value.
+    #            Cannot be an instance of Array nor Hash since calling #to_s on them returns
+    #            their `#inspect` string object.
+    #
+    # Returns the found object or nil
+    #
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def find(input, property, value)
+      return input if !property || value.is_a?(Array) || value.is_a?(Hash)
+      return input unless input.respond_to?(:find)
+
+      input    = input.values if input.is_a?(Hash)
+      input_id = input.hash
+
+      # implement a hash based on method parameters to cache the end-result for given parameters.
+      @find_filter_cache ||= {}
+      @find_filter_cache[input_id] ||= {}
+      @find_filter_cache[input_id][property] ||= {}
+
+      # stash or retrive results to return
+      # Since `enum.find` can return nil or false, we use a placeholder string "<__NO MATCH__>"
+      #   to validate caching.
+      result = @find_filter_cache[input_id][property][value] ||= begin
+        input.find do |object|
+          compare_property_vs_target(item_property(object, property), value)
+        end || "<__NO MATCH__>"
+      end
+      return nil if result == "<__NO MATCH__>"
+
+      result
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    # Searches an array of objects against an expression and returns the first object for which
+    # the expression evaluates to true, or returns nil otherwise.
+    #
+    # input - the object array
+    # variable - the variable to assign each item to in the expression
+    # expression - a Liquid comparison expression passed in as a string
+    #
+    # Returns the found object or nil
+    def find_exp(input, variable, expression)
+      return input unless input.respond_to?(:find)
+
+      input = input.values if input.is_a?(Hash)
+
+      condition = parse_condition(expression)
+      @context.stack do
+        input.find do |object|
+          @context[variable] = object
+          condition.evaluate(@context)
+        end
+      end
+    end
+
     # Convert the input into integer
     #
     # input - the object string
@@ -356,15 +428,24 @@ module Jekyll
       @item_property_cache ||= {}
       @item_property_cache[property] ||= {}
       @item_property_cache[property][item] ||= begin
-        if item.respond_to?(:to_liquid)
-          property.to_s.split(".").reduce(item.to_liquid) do |subvalue, attribute|
-            parse_sort_input(subvalue[attribute])
-          end
-        elsif item.respond_to?(:data)
-          parse_sort_input(item.data[property.to_s])
-        else
-          parse_sort_input(item[property.to_s])
-        end
+        property = property.to_s
+        property = if item.respond_to?(:to_liquid)
+                     read_liquid_attribute(item.to_liquid, property)
+                   elsif item.respond_to?(:data)
+                     item.data[property]
+                   else
+                     item[property]
+                   end
+
+        parse_sort_input(property)
+      end
+    end
+
+    def read_liquid_attribute(liquid_data, property)
+      return liquid_data[property] unless property.include?(".")
+
+      property.split(".").reduce(liquid_data) do |data, key|
+        data.respond_to?(:[]) && data[key]
       end
     end
 
@@ -423,10 +504,14 @@ module Jekyll
     #
     # Returns an instance of Liquid::Condition
     def parse_binary_comparison(parser)
-      parse_comparison(parser).tap do |condition|
-        binary_operator = parser.id?("and") || parser.id?("or")
-        condition.send(binary_operator, parse_comparison(parser)) if binary_operator
+      condition = parse_comparison(parser)
+      first_condition = condition
+      while (binary_operator = parser.id?("and") || parser.id?("or"))
+        child_condition = parse_comparison(parser)
+        condition.send(binary_operator, child_condition)
+        condition = child_condition
       end
+      first_condition
     end
 
     # Generates a Liquid::Condition object from a Liquid::Parser object based on whether the parsed

data/lib/jekyll/filters/url_filters.rb

@@ -11,15 +11,16 @@ module Jekyll
       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?
+        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)
 
-        Addressable::URI.parse(
-          site.config["url"].to_s + relative_url(input)
-        ).normalize.to_s
+        # 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
@@ -31,13 +32,16 @@ module Jekyll
       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?
+        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)
 
-        parts = [sanitized_baseurl, input]
-        Addressable::URI.parse(
-          parts.compact.map { |part| ensure_leading_slash(part.to_s) }.join
-        ).normalize.to_s
+        # 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
@@ -53,6 +57,29 @@ module Jekyll
 
       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("/")

data/lib/jekyll/frontmatter_defaults.rb

@@ -103,15 +103,15 @@ module Jekyll
     end
 
     def applies_path?(scope, path)
-      return true if !scope.key?("path") || scope["path"].empty?
+      rel_scope_path = scope["path"]
+      return true if !rel_scope_path.is_a?(String) || rel_scope_path.empty?
 
-      sanitized_path = Pathname.new(sanitize_path(path))
-      rel_scope_path = Pathname.new(scope["path"])
+      sanitized_path = sanitize_path(path)
 
-      if scope["path"].to_s.include?("*")
+      if rel_scope_path.include?("*")
         glob_scope(sanitized_path, rel_scope_path)
       else
-        path_is_subpath?(sanitized_path, strip_collections_dir(scope["path"]))
+        path_is_subpath?(sanitized_path, strip_collections_dir(rel_scope_path))
       end
     end
 
@@ -134,11 +134,7 @@ module Jekyll
     end
 
     def path_is_subpath?(path, parent_path)
-      path.ascend do |ascended_path|
-        return true if ascended_path.to_s == parent_path.to_s
-      end
-
-      false
+      path.start_with?(parent_path)
     end
 
     def strip_collections_dir(path)
@@ -179,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?
 
@@ -194,7 +190,7 @@ 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
     #
@@ -230,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!.freeze
-
+    # 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