jekyll 3.9.3 → 4.4.1

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,21 +51,48 @@ 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.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("/")
+        baseurl = site.config["baseurl"]
+        return "" if baseurl.nil?
+
+        baseurl.to_s.chomp("/")
       end
 
       def ensure_leading_slash(input)
         return input if input.nil? || input.empty? || input.start_with?("/")
+
         "/#{input}"
       end
-
     end
   end
 end

data/lib/jekyll/filters.rb

@@ -113,7 +113,7 @@ module Jekyll
     #
     # Returns the formatted String
     def normalize_whitespace(input)
-      input.to_s.gsub(%r!\s+!, " ").strip
+      input.to_s.gsub(%r!\s+!, " ").tap(&:strip!)
     end
 
     # Count the number of words in the input string.
@@ -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
@@ -161,14 +173,17 @@ module Jekyll
 
     # Filter an array of objects
     #
-    # input - the object array
-    # property - property within each object to filter by
-    # value - desired value
+    # input    - the object array.
+    # property - the property within each object to filter 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 filtered array of objects
     def where(input, property, value)
-      return input if property.nil? || value.nil?
+      return input if !property || value.is_a?(Array) || value.is_a?(Hash)
       return input unless input.respond_to?(:select)
+
       input    = input.values if input.is_a?(Hash)
       input_id = input.hash
 
@@ -178,12 +193,10 @@ module Jekyll
       @where_filter_cache[input_id] ||= {}
       @where_filter_cache[input_id][property] ||= {}
 
-      # stash or retrive results to return
-      @where_filter_cache[input_id][property][value] ||= begin
-        input.select do |object|
-          Array(item_property(object, property)).map!(&:to_s).include?(value.to_s)
-        end || []
-      end
+      # stash or retrieve results to return
+      @where_filter_cache[input_id][property][value] ||= input.select do |object|
+        compare_property_vs_target(item_property(object, property), value)
+      end.to_a
     end
 
     # Filters an array of objects against an expression
@@ -195,6 +208,7 @@ module Jekyll
     # Returns the filtered array of objects
     def where_exp(input, variable, expression)
       return input unless input.respond_to?(:select)
+
       input = input.values if input.is_a?(Hash) # FIXME
 
       condition = parse_condition(expression)
@@ -206,6 +220,65 @@ 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 retrieve 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] ||= input.find do |object|
+        compare_property_vs_target(item_property(object, property), value)
+      end || "<__NO MATCH__>"
+
+      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
@@ -214,6 +287,7 @@ module Jekyll
     def to_integer(input)
       return 1 if input == true
       return 0 if input == false
+
       input.to_i
     end
 
@@ -225,19 +299,19 @@ module Jekyll
     #
     # Returns the filtered array of objects
     def sort(input, property = nil, nils = "first")
-      if input.nil?
-        raise ArgumentError, "Cannot sort a null object."
-      end
+      raise ArgumentError, "Cannot sort a null object." if input.nil?
+
       if property.nil?
         input.sort
       else
-        if nils == "first"
+        case nils
+        when "first"
           order = - 1
-        elsif nils == "last"
+        when "last"
           order = + 1
         else
           raise ArgumentError, "Invalid nils order: " \
-            "'#{nils}' is not a valid nils order. It must be 'first' or 'last'."
+                               "'#{nils}' is not a valid nils order. It must be 'first' or 'last'."
         end
 
         sort_input(input, property, order)
@@ -246,6 +320,7 @@ module Jekyll
 
     def pop(array, num = 1)
       return array unless array.is_a?(Array)
+
       num = Liquid::Utils.to_integer(num)
       new_ary = array.dup
       new_ary.pop(num)
@@ -254,6 +329,7 @@ module Jekyll
 
     def push(array, input)
       return array unless array.is_a?(Array)
+
       new_ary = array.dup
       new_ary.push(input)
       new_ary
@@ -261,6 +337,7 @@ module Jekyll
 
     def shift(array, num = 1)
       return array unless array.is_a?(Array)
+
       num = Liquid::Utils.to_integer(num)
       new_ary = array.dup
       new_ary.shift(num)
@@ -269,6 +346,7 @@ module Jekyll
 
     def unshift(array, input)
       return array unless array.is_a?(Array)
+
       new_ary = array.dup
       new_ary.unshift(input)
       new_ary
@@ -276,6 +354,7 @@ module Jekyll
 
     def sample(input, num = 1)
       return input unless input.respond_to?(:sample)
+
       num = Liquid::Utils.to_integer(num) rescue 1
       if num == 1
         input.sample
@@ -301,40 +380,94 @@ module Jekyll
     # We also utilize the Schwartzian transform to make this more efficient.
     def sort_input(input, property, order)
       input.map { |item| [item_property(item, property), item] }
-        .sort! do |apple_info, orange_info|
-          apple_property = apple_info.first
-          orange_property = orange_info.first
+        .sort! do |a_info, b_info|
+          a_property = a_info.first
+          b_property = b_info.first
 
-          if !apple_property.nil? && orange_property.nil?
+          if !a_property.nil? && b_property.nil?
             - order
-          elsif apple_property.nil? && !orange_property.nil?
+          elsif a_property.nil? && !b_property.nil?
             + order
           else
-            apple_property <=> orange_property
+            a_property <=> b_property || a_property.to_s <=> b_property.to_s
           end
         end
         .map!(&:last)
     end
 
-    private
-    def item_property(item, property)
-      if item.respond_to?(:to_liquid)
-        property.to_s.split(".").reduce(item.to_liquid) do |subvalue, attribute|
-          subvalue[attribute]
-        end
-      elsif item.respond_to?(:data)
-        item.data[property.to_s]
+    # `where` filter helper
+    #
+    def compare_property_vs_target(property, target)
+      case target
+      when NilClass
+        return true if property.nil?
+      when Liquid::Expression::MethodLiteral # `empty` or `blank`
+        target = target.to_s
+        return true if property == target || Array(property).join == target
       else
-        item[property.to_s]
+        target = target.to_s
+        if property.is_a? String
+          return true if property == target
+        else
+          Array(property).each do |prop|
+            return true if prop.to_s == target
+          end
+        end
       end
+
+      false
+    end
+
+    def item_property(item, property)
+      @item_property_cache ||= @context.registers[:site].filter_cache[:item_property] ||= {}
+      @item_property_cache[property] ||= {}
+      @item_property_cache[property][item] ||= begin
+        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
+    rescue TypeError => e
+      msg = if liquid_data.is_a?(Array)
+              "Error accessing object (#{liquid_data.to_s[0...20]}) with given key. Expected an " \
+                "integer but got #{property.inspect} instead."
+            else
+              e.message
+            end
+      raise e, msg
+    end
+
+    FLOAT_LIKE   = %r!\A\s*-?(?:\d+\.?\d*|\.\d+)\s*\Z!.freeze
+    INTEGER_LIKE = %r!\A\s*-?\d+\s*\Z!.freeze
+    private_constant :FLOAT_LIKE, :INTEGER_LIKE
+
+    # return numeric values as numbers for proper sorting
+    def parse_sort_input(property)
+      stringified = property.to_s
+      return property.to_i if INTEGER_LIKE.match?(stringified)
+      return property.to_f if FLOAT_LIKE.match?(stringified)
+
+      property
     end
 
-    private
     def as_liquid(item)
       case item
       when Hash
-        pairs = item.map { |k, v| as_liquid([k, v]) }
-        Hash[pairs]
+        item.each_with_object({}) { |(k, v), result| result[as_liquid(k)] = as_liquid(v) }
       when Array
         item.map { |i| as_liquid(i) }
       else
@@ -352,25 +485,53 @@ module Jekyll
       end
     end
 
+    # -----------   The following set of code was *adapted* from Liquid::If
+    # -----------   ref: https://github.com/Shopify/liquid/blob/ffb0ace30315bbcf3548a0383fab531452060ae8/lib/liquid/tags/if.rb#L84-L107
+
     # Parse a string to a Liquid Condition
-    private
     def parse_condition(exp)
-      parser = Liquid::Parser.new(exp)
-      left_expr = parser.expression
-      operator = parser.consume?(:comparison)
-      condition =
-        if operator
-          Liquid::Condition.new(Liquid::Expression.parse(left_expr),
-                                operator,
-                                Liquid::Expression.parse(parser.expression))
-        else
-          Liquid::Condition.new(Liquid::Expression.parse(left_expr))
-        end
-      parser.consume(:end_of_string)
+      parser    = Liquid::Parser.new(exp)
+      condition = parse_binary_comparison(parser)
 
+      parser.consume(:end_of_string)
       condition
     end
 
+    # Generate a Liquid::Condition object from a Liquid::Parser object additionally processing
+    # the parsed expression based on whether the expression consists of binary operations with
+    # Liquid operators `and` or `or`
+    #
+    #  - parser: an instance of Liquid::Parser
+    #
+    # Returns an instance of Liquid::Condition
+    def parse_binary_comparison(parser)
+      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
+    # expression involves a "comparison" operator (e.g. <, ==, >, !=, etc)
+    #
+    #  - parser: an instance of Liquid::Parser
+    #
+    # Returns an instance of Liquid::Condition
+    def parse_comparison(parser)
+      left_operand = Liquid::Expression.parse(parser.expression)
+      operator     = parser.consume?(:comparison)
+
+      # No comparison-operator detected. Initialize a Liquid::Condition using only left operand
+      return Liquid::Condition.new(left_operand) unless operator
+
+      # Parse what remained after extracting the left operand and the `:comparison` operator
+      # and initialize a Liquid::Condition object using the operands and the comparison-operator
+      Liquid::Condition.new(left_operand, operator, Liquid::Expression.parse(parser.expression))
+    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
 
@@ -149,7 +157,7 @@ module Jekyll
     # Returns true if either of the above conditions are satisfied,
     #   otherwise returns false
     def applies_type?(scope, type)
-      !scope.key?("type") || scope["type"].eql?(type.to_s)
+      !scope.key?("type") || type&.to_sym.eql?(scope["type"].to_sym)
     end
 
     # Checks if a given set of default values is valid
@@ -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,13 +190,15 @@ 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|
+      @matched_set_cache ||= {}
+      @matched_set_cache[path] ||= {}
+      @matched_set_cache[path][type] ||= valid_sets.select do |set|
         !set.key?("scope") || applies?(set["scope"], path, type)
       end
     end
@@ -211,18 +221,17 @@ module Jekyll
           Jekyll.logger.warn set.to_s
           nil
         end
-      end.compact
+      end.tap(&: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