jekyll 4.1.1 → 4.2.2

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

data/lib/jekyll/filters/url_filters.rb

@@ -76,13 +76,16 @@ module Jekyll
 
         parts = [sanitized_baseurl, input]
         Addressable::URI.parse(
-          parts.compact.map { |part| ensure_leading_slash(part.to_s) }.join
+          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)

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.
@@ -307,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: " \
@@ -399,7 +400,6 @@ module Jekyll
 
     # `where` filter helper
     #
-    # rubocop:disable Metrics/PerceivedComplexity
     def compare_property_vs_target(property, target)
       case target
       when NilClass
@@ -421,10 +421,8 @@ module Jekyll
       false
     end
 
-    # 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
         property = property.to_s
@@ -464,8 +462,7 @@ module Jekyll
     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

data/lib/jekyll/frontmatter_defaults.rb

@@ -157,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
@@ -223,7 +223,7 @@ module Jekyll
           Jekyll.logger.warn set.to_s
           nil
         end
-      end.compact
+      end.tap(&:compact!)
     end
 
     # Sanitizes the given path by removing a leading slash

data/lib/jekyll/hooks.rb

@@ -22,22 +22,25 @@ module Jekyll
         :post_write  => [],
       },
       :pages     => {
-        :post_init   => [],
-        :pre_render  => [],
-        :post_render => [],
-        :post_write  => [],
+        :post_init    => [],
+        :pre_render   => [],
+        :post_convert => [],
+        :post_render  => [],
+        :post_write   => [],
       },
       :posts     => {
-        :post_init   => [],
-        :pre_render  => [],
-        :post_render => [],
-        :post_write  => [],
+        :post_init    => [],
+        :pre_render   => [],
+        :post_convert => [],
+        :post_render  => [],
+        :post_write   => [],
       },
       :documents => {
-        :post_init   => [],
-        :pre_render  => [],
-        :post_render => [],
-        :post_write  => [],
+        :post_init    => [],
+        :pre_render   => [],
+        :post_convert => [],
+        :post_render  => [],
+        :post_write   => [],
       },
       :clean     => {
         :on_obsolete => [],
@@ -67,10 +70,11 @@ module Jekyll
     # register a single hook to be called later, internal API
     def self.register_one(owner, event, priority, &block)
       @registry[owner] ||= {
-        :post_init   => [],
-        :pre_render  => [],
-        :post_render => [],
-        :post_write  => [],
+        :post_init    => [],
+        :pre_render   => [],
+        :post_convert => [],
+        :post_render  => [],
+        :post_write   => [],
       }
 
       unless @registry[owner][event]

data/lib/jekyll/layout.rb

@@ -58,5 +58,10 @@ module Jekyll
     def process(name)
       self.ext = File.extname(name)
     end
+
+    # Returns the object as a debug String.
+    def inspect
+      "#<#{self.class} @path=#{@path.inspect}>"
+    end
   end
 end

data/lib/jekyll/page.rb

@@ -64,12 +64,7 @@ module Jekyll
     #
     # Returns the String destination directory.
     def dir
-      if url.end_with?("/")
-        url
-      else
-        url_dir = File.dirname(url)
-        url_dir.end_with?("/") ? url_dir : "#{url_dir}/"
-      end
+      url.end_with?("/") ? url : url_dir
     end
 
     # The full path and filename of the post. Defined in the YAML of the post
@@ -121,6 +116,8 @@ module Jekyll
     # NOTE: `String#gsub` removes all trailing periods (in comparison to `String#chomp`)
     # Returns nothing.
     def process(name)
+      return unless name
+
       self.ext = File.extname(name)
       self.basename = name[0..-ext.length - 1].gsub(%r!\.*\z!, "")
     end
@@ -147,7 +144,7 @@ module Jekyll
 
     # The path to the page source file, relative to the site source
     def relative_path
-      @relative_path ||= File.join(*[@dir, @name].map(&:to_s).reject(&:empty?)).sub(%r!\A/!, "")
+      @relative_path ||= PathManager.join(@dir, @name).sub(%r!\A/!, "")
     end
 
     # Obtain destination path.
@@ -156,10 +153,13 @@ module Jekyll
     #
     # Returns the destination file path String.
     def destination(dest)
-      path = site.in_dest_dir(dest, URL.unescape_path(url))
-      path = File.join(path, "index") if url.end_with?("/")
-      path << output_ext unless path.end_with? output_ext
-      path
+      @destination ||= {}
+      @destination[dest] ||= begin
+        path = site.in_dest_dir(dest, URL.unescape_path(url))
+        path = File.join(path, "index") if url.end_with?("/")
+        path << output_ext unless path.end_with? output_ext
+        path
+      end
     end
 
     # Returns the object as a debug String.
@@ -192,11 +192,11 @@ module Jekyll
     def excerpt
       return @excerpt if defined?(@excerpt)
 
-      @excerpt = data["excerpt"]&.to_s
+      @excerpt = data["excerpt"] ? data["excerpt"].to_s : nil
     end
 
     def generate_excerpt?
-      !excerpt_separator.empty? && self.class == Jekyll::Page && html?
+      !excerpt_separator.empty? && instance_of?(Jekyll::Page) && html?
     end
 
     private
@@ -206,5 +206,12 @@ module Jekyll
 
       data["excerpt"] ||= Jekyll::PageExcerpt.new(self)
     end
+
+    def url_dir
+      @url_dir ||= begin
+        value = File.dirname(url)
+        value.end_with?("/") ? value : "#{value}/"
+      end
+    end
   end
 end

data/lib/jekyll/path_manager.rb

@@ -16,16 +16,59 @@ module Jekyll
     # This class cannot be initialized from outside
     private_class_method :new
 
-    # Wraps `File.join` to cache the frozen result.
-    # Reassigns `nil`, empty strings and empty arrays to a frozen empty string beforehand.
-    #
-    # Returns a frozen string.
-    def self.join(base, item)
-      base = "" if base.nil? || base.empty?
-      item = "" if item.nil? || item.empty?
-      @join ||= {}
-      @join[base] ||= {}
-      @join[base][item] ||= File.join(base, item).freeze
+    class << self
+      # Wraps `File.join` to cache the frozen result.
+      # Reassigns `nil`, empty strings and empty arrays to a frozen empty string beforehand.
+      #
+      # Returns a frozen string.
+      def join(base, item)
+        base = "" if base.nil? || base.empty?
+        item = "" if item.nil? || item.empty?
+        @join ||= {}
+        @join[base] ||= {}
+        @join[base][item] ||= File.join(base, item).freeze
+      end
+
+      # Ensures the questionable path is prefixed with the base directory
+      # and prepends the questionable path with the base directory if false.
+      #
+      # Returns a frozen string.
+      def sanitized_path(base_directory, questionable_path)
+        @sanitized_path ||= {}
+        @sanitized_path[base_directory] ||= {}
+        @sanitized_path[base_directory][questionable_path] ||= begin
+          if questionable_path.nil?
+            base_directory.freeze
+          else
+            sanitize_and_join(base_directory, questionable_path).freeze
+          end
+        end
+      end
+
+      private
+
+      def sanitize_and_join(base_directory, questionable_path)
+        clean_path = if questionable_path.start_with?("~")
+                       questionable_path.dup.insert(0, "/")
+                     else
+                       questionable_path
+                     end
+        clean_path = File.expand_path(clean_path, "/")
+        return clean_path if clean_path.eql?(base_directory)
+
+        # remove any remaining extra leading slashes not stripped away by calling
+        # `File.expand_path` above.
+        clean_path.squeeze!("/")
+        return clean_path if clean_path.start_with?(slashed_dir_cache(base_directory))
+
+        clean_path.sub!(%r!\A\w:/!, "/")
+        join(base_directory, clean_path)
+      end
+
+      def slashed_dir_cache(base_directory)
+        @slashed_dir_cache ||= {}
+        @slashed_dir_cache[base_directory] ||= base_directory.sub(%r!\z!, "/")
+      end
     end
   end
 end

data/lib/jekyll/reader.rb

@@ -164,8 +164,6 @@ module Jekyll
       entry_filter = EntryFilter.new(site)
 
       site.include.each do |entry|
-        next if entry == ".htaccess"
-
         entry_path = site.in_source_dir(entry)
         next if File.directory?(entry_path)
         next if entry_filter.symlink?(entry_path)
@@ -175,13 +173,20 @@ module Jekyll
     end
 
     def read_included_file(entry_path)
-      dir  = File.dirname(entry_path).sub(site.source, "")
-      file = Array(File.basename(entry_path))
       if Utils.has_yaml_header?(entry_path)
-        site.pages.concat(PageReader.new(site, dir).read(file))
+        conditionally_generate_entry(entry_path, site.pages, PageReader)
       else
-        site.static_files.concat(StaticFileReader.new(site, dir).read(file))
+        conditionally_generate_entry(entry_path, site.static_files, StaticFileReader)
       end
     end
+
+    def conditionally_generate_entry(entry_path, container, reader)
+      return if container.find { |item| site.in_source_dir(item.relative_path) == entry_path }
+
+      dir, files = File.split(entry_path)
+      dir.sub!(site.source, "")
+      files = Array(files)
+      container.concat(reader.new(site, dir).read(files))
+    end
   end
 end

data/lib/jekyll/readers/data_reader.rb

@@ -8,6 +8,7 @@ module Jekyll
       @site = site
       @content = {}
       @entry_filter = EntryFilter.new(site)
+      @source_dir = site.in_source_dir("/")
     end
 
     # Read all the files in <dir> and adds them to @content
@@ -53,6 +54,8 @@ module Jekyll
     #
     # Returns the contents of the data file.
     def read_data_file(path)
+      Jekyll.logger.debug "Reading:", path.sub(@source_dir, "")
+
       case File.extname(path).downcase
       when ".csv"
         CSV.read(path,

data/lib/jekyll/readers/post_reader.rb

@@ -57,7 +57,7 @@ module Jekyll
         Document.new(path,
                      :site       => @site,
                      :collection => @site.posts)
-      end.reject(&:nil?)
+      end.tap(&:compact!)
     end
 
     private

data/lib/jekyll/related_posts.rb

@@ -46,7 +46,7 @@ module Jekyll
     end
 
     def most_recent_posts
-      @most_recent_posts ||= (site.posts.docs.last(11).reverse - [post]).first(10)
+      @most_recent_posts ||= (site.posts.docs.last(11).reverse! - [post]).first(10)
     end
   end
 end

data/lib/jekyll/renderer.rb

@@ -36,7 +36,7 @@ module Jekyll
     #
     # Returns Array of Converter instances.
     def converters
-      @converters ||= site.converters.select { |c| c.matches(document.extname) }.sort
+      @converters ||= site.converters.select { |c| c.matches(document.extname) }.tap(&:sort!)
     end
 
     # Determine the extname the outputted file should have
@@ -66,7 +66,7 @@ module Jekyll
     # Render the document.
     #
     # Returns String rendered document output
-    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/AbcSize, Metrics/MethodLength
     def render_document
       info = {
         :registers        => { :site => site, :page => payload["page"] },
@@ -84,6 +84,10 @@ module Jekyll
       output = convert(output.to_s)
       document.content = output
 
+      Jekyll.logger.debug "Post-Convert Hooks:", document.relative_path
+      document.trigger_hooks(:post_convert)
+      output = document.content
+
       if document.place_in_layout?
         Jekyll.logger.debug "Rendering Layout:", document.relative_path
         output = place_in_layouts(output, payload, info)
@@ -91,7 +95,7 @@ module Jekyll
 
       output
     end
-    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/AbcSize, Metrics/MethodLength
 
     # Convert the document using the converters which match this renderer's document.
     #
@@ -251,7 +255,7 @@ module Jekyll
     def output_exts
       @output_exts ||= converters.map do |c|
         c.output_ext(document.extname)
-      end.compact
+      end.tap(&:compact!)
     end
 
     def liquid_options