jekyll 3.8.7 → 4.1.0

data/lib/jekyll/external.rb

@@ -9,6 +9,7 @@ module Jekyll
       #
       def blessed_gems
         %w(
+          jekyll-compose
           jekyll-docs
           jekyll-import
         )
@@ -41,6 +42,7 @@ module Jekyll
       # RubyGems.
       def version_constraint(gem_name)
         return "= #{Jekyll::VERSION}" if gem_name.to_s.eql?("jekyll-docs")
+
         "> 0"
       end
 
@@ -57,13 +59,16 @@ module Jekyll
             Jekyll.logger.debug "Requiring:", name.to_s
             require name
           rescue LoadError => e
-            Jekyll.logger.error "Dependency Error:", <<-MSG
-Yikes! It looks like you don't have #{name} or one of its dependencies installed.
-In order to use Jekyll as currently configured, you'll need to install this gem.
+            Jekyll.logger.error "Dependency Error:", <<~MSG
+              Yikes! It looks like you don't have #{name} or one of its dependencies installed.
+              In order to use Jekyll as currently configured, you'll need to install this gem.
+
+              If you've run Jekyll with `bundle exec`, ensure that you have included the #{name}
+              gem in your Gemfile as well.
 
-The full error message from Ruby is: '#{e.message}'
+              The full error message from Ruby is: '#{e.message}'
 
-If you run into trouble, you can find helpful resources at https://jekyllrb.com/help/!
+              If you run into trouble, you can find helpful resources at https://jekyllrb.com/help/!
             MSG
             raise Jekyll::Errors::MissingDependencyException, name
           end

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
@@ -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
 
@@ -181,8 +196,8 @@ module Jekyll
       # 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 || []
+          compare_property_vs_target(item_property(object, property), value)
+        end.to_a
       end
     end
 
@@ -195,6 +210,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 +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
@@ -214,6 +290,7 @@ module Jekyll
     def to_integer(input)
       return 1 if input == true
       return 0 if input == false
+
       input.to_i
     end
 
@@ -225,9 +302,8 @@ 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
@@ -246,6 +322,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 +331,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 +339,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 +348,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 +356,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,35 +382,86 @@ 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
+    #
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    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
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    def item_property(item, property)
+      @item_property_cache ||= {}
+      @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
 
-    private
+    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
+
+    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
+
     def as_liquid(item)
       case item
       when Hash
@@ -352,25 +484,53 @@ module Jekyll
       end
     end
 
+    # -----------   The following set of code was *adapted* from Liquid::If
+    # -----------   ref: https://git.io/vp6K6
+
     # 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/filters/date_filters.rb

@@ -45,6 +45,7 @@ module Jekyll
       # Returns the formatted String.
       def date_to_xmlschema(date)
         return date if date.to_s.empty?
+
         time(date).xmlschema
       end
 
@@ -60,10 +61,12 @@ module Jekyll
       # Returns the formatted String.
       def date_to_rfc822(date)
         return date if date.to_s.empty?
+
         time(date).rfc822
       end
 
       private
+
       # month_type: Notations that evaluate to 'Month' via `Time#strftime` ("%b", "%B")
       # type: nil (default) or "ordinal"
       # style: nil (default) or "US"
@@ -71,17 +74,18 @@ module Jekyll
       # Returns a stringified date or the empty input.
       def stringify_date(date, month_type, type = nil, style = nil)
         return date if date.to_s.empty?
+
         time = time(date)
         if type == "ordinal"
           day = time.day
           ordinal_day = "#{day}#{ordinal(day)}"
           return time.strftime("#{month_type} #{ordinal_day}, %Y") if style == "US"
+
           return time.strftime("#{ordinal_day} #{month_type} %Y")
         end
         time.strftime("%d #{month_type} %Y")
       end
 
-      private
       def ordinal(number)
         return "th" if (11..13).cover?(number)
 
@@ -93,12 +97,11 @@ module Jekyll
         end
       end
 
-      private
       def time(input)
         date = Liquid::Utils.to_date(input)
         unless date.respond_to?(:to_time)
           raise Errors::InvalidDateError,
-            "Invalid Date: '#{input.inspect}' is not a valid datetime."
+                "Invalid Date: '#{input.inspect}' is not a valid datetime."
         end
         date.to_time.dup.localtime
       end

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 << {