jekyll 4.0.0.pre.beta1 → 4.2.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.
@@ -253,14 +257,16 @@ module Jekyll
     #
     # Returns the full path to the output file of this document.
     def destination(base_directory)
-      dest = site.in_dest_dir(base_directory)
-      path = site.in_dest_dir(dest, URL.unescape_path(url))
-      if url.end_with? "/"
-        path = File.join(path, "index.html")
-      else
-        path << output_ext unless path.end_with? output_ext
+      @destination ||= {}
+      @destination[base_directory] ||= begin
+        path = site.in_dest_dir(base_directory, URL.unescape_path(url))
+        if url.end_with? "/"
+          path = File.join(path, "index.html")
+        else
+          path << output_ext unless path.end_with? output_ext
+        end
+        path
       end
-      path
     end
 
     # Write the generated Document file to the destination directory.
@@ -298,7 +304,7 @@ module Jekyll
       else
         begin
           merge_defaults
-          read_content(opts)
+          read_content(**opts)
           read_post_data
         rescue StandardError => e
           handle_read_error(e)
@@ -347,9 +353,14 @@ module Jekyll
     # True if the document has a collection and if that collection's #write?
     # method returns true, and if the site's Publisher will publish the document.
     # False otherwise.
+    #
+    # rubocop:disable Naming/MemoizedInstanceVariableName
     def write?
-      collection&.write? && site.publisher.publish?(self)
+      return @write_p if defined?(@write_p)
+
+      @write_p = collection&.write? && site.publisher.publish?(self)
     end
+    # rubocop:enable Naming/MemoizedInstanceVariableName
 
     # The Document excerpt_separator, from the YAML Front-Matter or site
     # default excerpt_separator value
@@ -414,9 +425,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
@@ -429,14 +444,14 @@ module Jekyll
       categories.flatten!
       categories.uniq!
 
-      merge_data!("categories" => categories)
+      merge_data!({ "categories" => categories })
     end
 
     def populate_tags
       tags = Utils.pluralized_array_from_hash(data, "tag", "tags")
       tags.flatten!
 
-      merge_data!("tags" => tags)
+      merge_data!({ "tags" => tags })
     end
 
     private
@@ -444,7 +459,10 @@ module Jekyll
     def merge_categories!(other)
       if other.key?("categories") && !other["categories"].nil?
         other["categories"] = other["categories"].split if other["categories"].is_a?(String)
-        other["categories"] = (data["categories"] || []) | other["categories"]
+
+        if data["categories"].is_a?(Array)
+          other["categories"] = data["categories"] | other["categories"]
+        end
       end
     end
 
@@ -462,10 +480,10 @@ module Jekyll
       merge_data!(defaults, :source => "front matter defaults") unless defaults.empty?
     end
 
-    def read_content(opts)
-      self.content = File.read(path, Utils.merged_file_read_opts(site, opts))
+    def read_content(**opts)
+      self.content = File.read(path, **Utils.merged_file_read_opts(site, opts))
       if content =~ YAML_FRONT_MATTER_REGEXP
-        self.content = $POSTMATCH
+        self.content = Regexp.last_match.post_match
         data_file = SafeYAML.load(Regexp.last_match(1))
         merge_data!(data_file, :source => "YAML front matter") if data_file
       end
@@ -497,6 +515,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!`)

data/lib/jekyll/drops/collection_drop.rb

@@ -7,10 +7,10 @@ module Jekyll
 
       mutable false
 
-      def_delegator  :@obj, :write?, :output
-      def_delegators :@obj, :label, :docs, :files, :directory, :relative_directory
+      delegate_method_as :write?, :output
+      delegate_methods :label, :docs, :files, :directory, :relative_directory
 
-      private def_delegator :@obj, :metadata, :fallback_data
+      private delegate_method_as :metadata, :fallback_data
 
       def to_s
         docs.to_s

data/lib/jekyll/drops/document_drop.rb

@@ -11,10 +11,11 @@ module Jekyll
 
       mutable false
 
-      def_delegator :@obj, :relative_path, :path
-      def_delegators :@obj, :id, :output, :content, :to_s, :relative_path, :url, :date
+      delegate_method_as :relative_path, :path
+      private delegate_method_as :data, :fallback_data
 
-      private def_delegator :@obj, :data, :fallback_data
+      delegate_methods :id, :output, :content, :to_s, :relative_path, :url, :date
+      data_delegators "title", "categories", "tags"
 
       def collection
         @obj.collection.label

data/lib/jekyll/drops/drop.rb

@@ -6,20 +6,101 @@ module Jekyll
       include Enumerable
 
       NON_CONTENT_METHODS = [:fallback_data, :collapse_document].freeze
+      NON_CONTENT_METHOD_NAMES = NON_CONTENT_METHODS.map(&:to_s).freeze
+      private_constant :NON_CONTENT_METHOD_NAMES
 
-      # Get or set whether the drop class is mutable.
-      # Mutability determines whether or not pre-defined fields may be
-      # overwritten.
-      #
-      # is_mutable - Boolean set mutability of the class (default: nil)
-      #
-      # Returns the mutability of the class
-      def self.mutable(is_mutable = nil)
-        @is_mutable = is_mutable || false
-      end
+      # A private stash to avoid repeatedly generating the setter method name string for
+      # a call to `Drops::Drop#[]=`.
+      # The keys of the stash below have a very high probability of being called upon during
+      # the course of various `Jekyll::Renderer#run` calls.
+      SETTER_KEYS_STASH = {
+        "content"            => "content=",
+        "layout"             => "layout=",
+        "page"               => "page=",
+        "paginator"          => "paginator=",
+        "highlighter_prefix" => "highlighter_prefix=",
+        "highlighter_suffix" => "highlighter_suffix=",
+      }.freeze
+      private_constant :SETTER_KEYS_STASH
+
+      class << self
+        # Get or set whether the drop class is mutable.
+        # Mutability determines whether or not pre-defined fields may be
+        # overwritten.
+        #
+        # is_mutable - Boolean set mutability of the class (default: nil)
+        #
+        # Returns the mutability of the class
+        def mutable(is_mutable = nil)
+          @is_mutable = is_mutable || false
+        end
+
+        def mutable?
+          @is_mutable
+        end
+
+        # public delegation helper methods that calls onto Drop's instance
+        # variable `@obj`.
+
+        # Generate private Drop instance_methods for each symbol in the given list.
+        #
+        # Returns nothing.
+        def private_delegate_methods(*symbols)
+          symbols.each { |symbol| private delegate_method(symbol) }
+          nil
+        end
+
+        # Generate public Drop instance_methods for each symbol in the given list.
+        #
+        # Returns nothing.
+        def delegate_methods(*symbols)
+          symbols.each { |symbol| delegate_method(symbol) }
+          nil
+        end
 
-      def self.mutable?
-        @is_mutable
+        # Generate public Drop instance_method for given symbol that calls `@obj.<sym>`.
+        #
+        # Returns delegated method symbol.
+        def delegate_method(symbol)
+          define_method(symbol) { @obj.send(symbol) }
+        end
+
+        # Generate public Drop instance_method named `delegate` that calls `@obj.<original>`.
+        #
+        # Returns delegated method symbol.
+        def delegate_method_as(original, delegate)
+          define_method(delegate) { @obj.send(original) }
+        end
+
+        # Generate public Drop instance_methods for each string entry in the given list.
+        # The generated method(s) access(es) `@obj`'s data hash.
+        #
+        # Returns nothing.
+        def data_delegators(*strings)
+          strings.each do |key|
+            data_delegator(key) if key.is_a?(String)
+          end
+          nil
+        end
+
+        # Generate public Drop instance_methods for given string `key`.
+        # The generated method access(es) `@obj`'s data hash.
+        #
+        # Returns method symbol.
+        def data_delegator(key)
+          define_method(key.to_sym) { @obj.data[key] }
+        end
+
+        # Array of stringified instance methods that do not end with the assignment operator.
+        #
+        # (<klass>.instance_methods always generates a new Array object so it can be mutated)
+        #
+        # Returns array of strings.
+        def getter_method_names
+          @getter_method_names ||= instance_methods.map!(&:to_s).tap do |list|
+            list.reject! { |item| item.end_with?("=") }
+          end
+        end
       end
 
       # Create a new Drop
@@ -65,7 +146,7 @@ module Jekyll
       # and the key matches a method in which case it raises a
       # DropMutationException.
       def []=(key, val)
-        setter = "#{key}="
+        setter = SETTER_KEYS_STASH[key] || "#{key}="
         if respond_to?(setter)
           public_send(setter, val)
         elsif respond_to?(key.to_s)
@@ -84,13 +165,10 @@ module Jekyll
       #
       # Returns an Array of strings which represent method-specific keys.
       def content_methods
-        @content_methods ||= (
-          self.class.instance_methods \
-            - Jekyll::Drops::Drop.instance_methods \
-            - NON_CONTENT_METHODS
-        ).map(&:to_s).reject do |method|
-          method.end_with?("=")
-        end
+        @content_methods ||= \
+          self.class.getter_method_names \
+            - Jekyll::Drops::Drop.getter_method_names \
+            - NON_CONTENT_METHOD_NAMES
       end
 
       # Check if key exists in Drop

data/lib/jekyll/drops/site_drop.rb

@@ -7,10 +7,10 @@ module Jekyll
 
       mutable false
 
-      def_delegator  :@obj, :site_data, :data
-      def_delegators :@obj, :time, :pages, :static_files, :tags, :categories
+      delegate_method_as :site_data, :data
+      delegate_methods :time, :pages, :static_files, :tags, :categories
 
-      private def_delegator :@obj, :config, :fallback_data
+      private delegate_method_as :config, :fallback_data
 
       def [](key)
         if key != "posts" && @obj.collections.key?(key)

data/lib/jekyll/drops/static_file_drop.rb

@@ -4,11 +4,11 @@ module Jekyll
   module Drops
     class StaticFileDrop < Drop
       extend Forwardable
-      def_delegators :@obj, :name, :extname, :modified_time, :basename
-      def_delegator :@obj, :relative_path, :path
-      def_delegator :@obj, :type, :collection
+      delegate_methods   :name, :extname, :modified_time, :basename
+      delegate_method_as :relative_path, :path
+      delegate_method_as :type, :collection
 
-      private def_delegator :@obj, :data, :fallback_data
+      private delegate_method_as :data, :fallback_data
     end
   end
 end

data/lib/jekyll/drops/url_drop.rb

@@ -7,8 +7,8 @@ module Jekyll
 
       mutable false
 
-      def_delegator :@obj, :cleaned_relative_path, :path
-      def_delegator :@obj, :output_ext, :output_ext
+      delegate_method :output_ext
+      delegate_method_as :cleaned_relative_path, :path
 
       def collection
         @obj.collection.label
@@ -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")
@@ -125,7 +133,7 @@ module Jekyll
       private
 
       def fallback_data
-        {}
+        @fallback_data ||= {}
       end
     end
   end

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)
@@ -32,13 +33,21 @@ module Jekyll
         # 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
 
@@ -53,7 +62,7 @@ module Jekyll
     end
 
     def backup?(entry)
-      entry[-1..-1] == "~"
+      entry.end_with?("~")
     end
 
     def excluded?(entry)
@@ -91,6 +100,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 +108,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

@@ -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
@@ -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
@@ -235,9 +307,10 @@ module Jekyll
       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: " \
@@ -327,8 +400,6 @@ module Jekyll
 
     # `where` filter helper
     #
-    # rubocop:disable Metrics/CyclomaticComplexity
-    # rubocop:disable Metrics/PerceivedComplexity
     def compare_property_vs_target(property, target)
       case target
       when NilClass
@@ -349,40 +420,49 @@ module Jekyll
 
       false
     end
-    # rubocop:enable Metrics/CyclomaticComplexity
-    # rubocop:enable Metrics/PerceivedComplexity
 
     def item_property(item, property)
-      @item_property_cache ||= {}
+      @item_property_cache ||= @context.registers[:site].filter_cache[:item_property] ||= {}
       @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
 
-    # rubocop:disable Performance/RegexpMatch
+    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)
-      number_like = %r!\A\s*-?(?:\d+\.?\d*|\.\d+)\s*\Z!
-      return property.to_f if property =~ number_like
+      stringified = property.to_s
+      return property.to_i if INTEGER_LIKE.match?(stringified)
+      return property.to_f if FLOAT_LIKE.match?(stringified)
 
       property
     end
-    # rubocop:enable Performance/RegexpMatch
 
     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
@@ -420,10 +500,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