jekyll 3.9.3 → 4.4.1

data/lib/jekyll/document.rb

@@ -5,14 +5,31 @@ module Jekyll
     include Comparable
     extend Forwardable
 
-    attr_reader :path, :site, :extname, :collection
+    attr_reader :path, :site, :extname, :collection, :type
     attr_accessor :content, :output
 
     def_delegator :self, :read_post_data, :post_read
 
-    YAML_FRONT_MATTER_REGEXP = %r!\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)!m
-    DATELESS_FILENAME_MATCHER = %r!^(?:.+/)*(.*)(\.[^.]+)$!
-    DATE_FILENAME_MATCHER = %r!^(?:.+/)*(\d{2,4}-\d{1,2}-\d{1,2})-(.*)(\.[^.]+)$!
+    YAML_FRONT_MATTER_REGEXP = %r!\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)!m.freeze
+    DATELESS_FILENAME_MATCHER = %r!^(?:.+/)*(.*)(\.[^.]+)$!.freeze
+    DATE_FILENAME_MATCHER = %r!^(?>.+/)*?(\d{2,4}-\d{1,2}-\d{1,2})-([^/]*)(\.[^.]+)$!.freeze
+
+    SASS_FILE_EXTS = %w(.sass .scss).freeze
+    YAML_FILE_EXTS = %w(.yaml .yml).freeze
+
+    #
+
+    # Class-wide cache to stash and retrieve regexp to detect "super-directories"
+    # of a particular Jekyll::Document object.
+    #
+    # dirname - The *special directory* for the Document.
+    #           e.g. "_posts" or "_drafts" for Documents from the `site.posts` collection.
+    def self.superdirs_regex(dirname)
+      @superdirs_regex ||= {}
+      @superdirs_regex[dirname] ||= %r!#{dirname}.*!
+    end
+
+    #
 
     # Create a new Document.
     #
@@ -27,6 +44,8 @@ module Jekyll
       @path = path
       @extname = File.extname(path)
       @collection = relations[:collection]
+      @type = @collection.label.to_sym
+
       @has_yaml_header = nil
 
       if draft?
@@ -36,7 +55,7 @@ module Jekyll
       end
 
       data.default_proc = proc do |_, key|
-        site.frontmatter_defaults.find(relative_path, collection.label, key)
+        site.frontmatter_defaults.find(relative_path, type, key)
       end
 
       trigger_hooks(:post_init)
@@ -60,12 +79,19 @@ module Jekyll
       data
     end
 
+    # Returns the document date. If metadata is not present then calculates it
+    # based on Jekyll::Site#time or the document file modification time.
+    #
+    # Return document date string.
     def date
       data["date"] ||= (draft? ? source_file_mtime : site.time)
     end
 
+    # Return document file modification time in the form of a Time object.
+    #
+    # Return document file modification Time object.
     def source_file_mtime
-      @source_file_mtime ||= File.mtime(path)
+      File.mtime(path)
     end
 
     # Returns whether the document is a draft. This is only the case if
@@ -90,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.
@@ -107,27 +133,35 @@ 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.
     # This method is useful when building the URL of the document.
     #
+    # NOTE: `String#gsub` removes all trailing periods (in comparison to `String#chomp`)
+    #
     # Examples:
-    #   When relative_path is "_methods/site/generate.md":
+    #   When relative_path is "_methods/site/generate...md":
     #     cleaned_relative_path
     #     # => "/site/generate"
     #
     # Returns the cleaned relative path of the document.
     def cleaned_relative_path
       @cleaned_relative_path ||=
-        relative_path[0..-extname.length - 1].sub(collection.relative_directory, "")
+        relative_path[0..-extname.length - 1]
+          .sub(collection.relative_directory, "")
+          .gsub(%r!\.*\z!, "")
     end
 
     # Determine whether the document is a YAML file.
     #
     # Returns true if the extname is either .yml or .yaml, false otherwise.
     def yaml_file?
-      %w(.yaml .yml).include?(extname)
+      YAML_FILE_EXTS.include?(extname)
     end
 
     # Determine whether the document is an asset file.
@@ -143,7 +177,7 @@ module Jekyll
     #
     # Returns true if extname == .sass or .scss, false otherwise.
     def sass_file?
-      %w(.sass .scss).include?(extname)
+      SASS_FILE_EXTS.include?(extname)
     end
 
     # Determine whether the document is a CoffeeScript file.
@@ -159,6 +193,8 @@ module Jekyll
     #   or if the document doesn't contain any Liquid Tags or Variables,
     #   true otherwise.
     def render_with_liquid?
+      return false if data["render_with_liquid"] == false
+
       !(coffeescript_file? || yaml_file? || !Utils.has_liquid_construct?(content))
     end
 
@@ -204,11 +240,11 @@ module Jekyll
     #
     # Returns the computed URL for the document.
     def url
-      @url ||= URL.new({
+      @url ||= URL.new(
         :template     => url_template,
         :placeholders => url_placeholders,
-        :permalink    => permalink,
-      }).to_s
+        :permalink    => permalink
+      ).to_s
     end
 
     def [](key)
@@ -221,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.
@@ -286,7 +324,7 @@ module Jekyll
     #
     # Returns the inspect string for this document.
     def inspect
-      "#<Jekyll::Document #{relative_path} collection=#{collection.label}>"
+      "#<#{self.class} #{relative_path} collection=#{collection.label}>"
     end
 
     # The string representation for this document.
@@ -303,6 +341,7 @@ module Jekyll
     #   equal or greater than the other doc's path. See String#<=> for more details.
     def <=>(other)
       return nil unless other.respond_to?(:data)
+
       cmp = data["date"] <=> other.data["date"]
       cmp = path <=> other.path if cmp.nil? || cmp.zero?
       cmp
@@ -314,16 +353,21 @@ 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 && 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
     #
     # Returns the document excerpt_separator
     def excerpt_separator
-      (data["excerpt_separator"] || site.config["excerpt_separator"]).to_s
+      @excerpt_separator ||= (data["excerpt_separator"] || site.config["excerpt_separator"]).to_s
     end
 
     # Whether to generate an excerpt
@@ -335,16 +379,12 @@ module Jekyll
 
     def next_doc
       pos = collection.docs.index { |post| post.equal?(self) }
-      if pos && pos < collection.docs.length - 1
-        collection.docs[pos + 1]
-      end
+      collection.docs[pos + 1] if pos && pos < collection.docs.length - 1
     end
 
     def previous_doc
       pos = collection.docs.index { |post| post.equal?(self) }
-      if pos && pos > 0
-        collection.docs[pos - 1]
-      end
+      collection.docs[pos - 1] if pos && pos.positive?
     end
 
     def trigger_hooks(hook_name, *args)
@@ -363,18 +403,11 @@ module Jekyll
       @related_posts ||= Jekyll::RelatedPosts.new(self).build
     end
 
-    # Override of normal respond_to? to match method_missing's logic for
-    # looking in @data.
-    def respond_to?(method, include_private = false)
-      data.key?(method.to_s) || super
-    end
-
     # Override of method_missing to check in @data for the key.
     def method_missing(method, *args, &blck)
       if data.key?(method.to_s)
-        Jekyll::Deprecator.deprecation_message "Document##{method} is now a key "\
-                           "in the #data hash."
-        Jekyll::Deprecator.deprecation_message "Called by #{caller(0..0)}."
+        Jekyll::Deprecator.deprecation_message "Document##{method} is now a key in the #data hash."
+        Jekyll.logger.warn "", "Called by #{caller(1..1)[0]}."
         data[method.to_s]
       else
         super
@@ -391,41 +424,47 @@ module Jekyll
     #
     # Returns nothing.
     def categories_from_path(special_dir)
-      superdirs = relative_path.sub(%r!#{special_dir}(.*)!, "")
-        .split(File::SEPARATOR)
-        .reject do |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
 
     def populate_categories
-      merge_data!({
-        "categories" => (
-          Array(data["categories"]) + Utils.pluralized_array_from_hash(
-            data, "category", "categories"
-          )
-        ).map(&:to_s).flatten.uniq,
-      })
+      categories = Array(data["categories"]) + Utils.pluralized_array_from_hash(
+        data, "category", "categories"
+      )
+      categories.map!(&:to_s)
+      categories.flatten!
+      categories.uniq!
+
+      merge_data!({ "categories" => categories })
     end
 
     def populate_tags
-      merge_data!({
-        "tags" => Utils.pluralized_array_from_hash(data, "tag", "tags").flatten,
-      })
+      tags = Utils.pluralized_array_from_hash(data, "tag", "tags")
+      tags.flatten!
+
+      merge_data!({ "tags" => tags })
     end
 
     private
+
     def merge_categories!(other)
       if other.key?("categories") && !other["categories"].nil?
-        if other["categories"].is_a?(String)
-          other["categories"] = other["categories"].split
+        other["categories"] = other["categories"].split if other["categories"].is_a?(String)
+
+        if data["categories"].is_a?(Array)
+          other["categories"] = data["categories"] | other["categories"]
         end
-        other["categories"] = (data["categories"] || []) | other["categories"]
       end
     end
 
-    private
     def merge_date!(source)
       if data.key?("date")
         data["date"] = Utils.parse_date(
@@ -435,26 +474,20 @@ module Jekyll
       end
     end
 
-    private
     def merge_defaults
-      defaults = @site.frontmatter_defaults.all(
-        relative_path,
-        collection.label.to_sym
-      )
+      defaults = @site.frontmatter_defaults.all(relative_path, type)
       merge_data!(defaults, :source => "front matter defaults") unless defaults.empty?
     end
 
-    private
     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
     end
 
-    private
     def read_post_data
       populate_title
       populate_categories
@@ -462,7 +495,6 @@ module Jekyll
       generate_excerpt
     end
 
-    private
     def handle_read_error(error)
       if error.is_a? Psych::SyntaxError
         Jekyll.logger.error "Error:", "YAML Exception reading #{path}: #{error.message}"
@@ -475,7 +507,6 @@ module Jekyll
       end
     end
 
-    private
     def populate_title
       if relative_path =~ DATE_FILENAME_MATCHER
         date, slug, ext = Regexp.last_match.captures
@@ -483,6 +514,14 @@ 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!`)
+      slug.gsub!(%r!\.*\z!, "")
 
       # Try to ensure the user gets a title.
       data["title"] ||= Utils.titleize_slug(slug)
@@ -491,18 +530,14 @@ module Jekyll
       data["ext"]   ||= ext
     end
 
-    private
     def modify_date(date)
       if !data["date"] || data["date"].to_i == site.time.to_i
         merge_data!({ "date" => date }, :source => "filename")
       end
     end
 
-    private
     def generate_excerpt
-      if generate_excerpt?
-        data["excerpt"] ||= Jekyll::Excerpt.new(self)
-      end
+      data["excerpt"] ||= Jekyll::Excerpt.new(self) if generate_excerpt?
     end
   end
 end

data/lib/jekyll/drops/collection_drop.rb

@@ -7,11 +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
+      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
@@ -24,8 +25,13 @@ module Jekyll
         fallback_data["excerpt"].to_s
       end
 
+      def name
+        fallback_data["name"] || @obj.basename
+      end
+
       def <=>(other)
         return nil unless other.is_a? DocumentDrop
+
         cmp = self["date"] <=> other["date"]
         cmp = self["path"] <=> other["path"] if cmp.nil? || cmp.zero?
         cmp

data/lib/jekyll/drops/drop.rb

@@ -6,24 +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 = if is_mutable
-                        is_mutable
-                      else
-                        false
-                      end
-      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`.
 
-      def self.mutable?
-        @is_mutable
+        # 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
+
+        # 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
@@ -34,7 +111,6 @@ module Jekyll
       # Returns nothing
       def initialize(obj)
         @obj = obj
-        @mutations = {} # only if mutable: true
       end
 
       # Access a method in the Drop or a field in the underlying hash data.
@@ -46,8 +122,8 @@ module Jekyll
       #
       # Returns the value for the given key, or nil if none exists
       def [](key)
-        if self.class.mutable? && @mutations.key?(key)
-          @mutations[key]
+        if self.class.mutable? && mutations.key?(key)
+          mutations[key]
         elsif self.class.invokable? key
           public_send key
         else
@@ -70,11 +146,12 @@ module Jekyll
       # and the key matches a method in which case it raises a
       # DropMutationException.
       def []=(key, val)
-        if respond_to?("#{key}=")
-          public_send("#{key}=", val)
+        setter = SETTER_KEYS_STASH[key] || "#{key}="
+        if respond_to?(setter)
+          public_send(setter, val)
         elsif respond_to?(key.to_s)
           if self.class.mutable?
-            @mutations[key] = val
+            mutations[key] = val
           else
             raise Errors::DropMutationException, "Key #{key} cannot be set in the drop."
           end
@@ -88,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
@@ -104,7 +178,8 @@ module Jekyll
       # Returns true if the given key is present
       def key?(key)
         return false if key.nil?
-        return true if self.class.mutable? && @mutations.key?(key)
+        return true if self.class.mutable? && mutations.key?(key)
+
         respond_to?(key) || fallback_data.key?(key)
       end
 
@@ -116,7 +191,7 @@ module Jekyll
       # Returns an Array of unique keys for content for the Drop.
       def keys
         (content_methods |
-          @mutations.keys |
+          mutations.keys |
           fallback_data.keys).flatten
       end
 
@@ -173,7 +248,7 @@ module Jekyll
       end
 
       def merge(other, &block)
-        self.dup.tap do |me|
+        dup.tap do |me|
           if block.nil?
             me.merge!(other)
           else
@@ -205,7 +280,14 @@ module Jekyll
         return self[key] if key?(key)
         raise KeyError, %(key not found: "#{key}") if default.nil? && block.nil?
         return yield(key) unless block.nil?
-        return default unless default.nil?
+
+        default unless default.nil?
+      end
+
+      private
+
+      def mutations
+        @mutations ||= {}
       end
     end
   end

data/lib/jekyll/drops/excerpt_drop.rb

@@ -7,9 +7,17 @@ module Jekyll
         @obj.doc.data["layout"]
       end
 
+      def date
+        @obj.doc.date
+      end
+
       def excerpt
         nil
       end
+
+      def name
+        @obj.doc.data["name"] || @obj.doc.basename
+      end
     end
   end
 end