jekyll 3.9.3 → 4.4.1

data/lib/jekyll/tags/highlight.rb

@@ -10,7 +10,7 @@ module Jekyll
       # forms: name, name=value, or name="<quoted list>"
       #
       # <quoted list> is a space-separated list of numbers
-      SYNTAX = %r!^([a-zA-Z0-9.+#_-]+)((\s+\w+(=(\w+|"([0-9]+\s)*[0-9]+"))?)*)$!
+      SYNTAX = %r!^([a-zA-Z0-9.+#_-]+)((\s+\w+(=(\w+|"([0-9]+\s)*[0-9]+"))?)*)$!.freeze
 
       def initialize(tag_name, markup, tokens)
         super
@@ -18,29 +18,31 @@ module Jekyll
           @lang = Regexp.last_match(1).downcase
           @highlight_options = parse_options(Regexp.last_match(2))
         else
-          raise SyntaxError, <<-MSG
-Syntax Error in tag 'highlight' while parsing the following markup:
+          raise SyntaxError, <<~MSG
+            Syntax Error in tag 'highlight' while parsing the following markup:
 
-  #{markup}
+            #{markup}
 
-Valid syntax: highlight <lang> [linenos]
-MSG
+            Valid syntax: highlight <lang> [linenos] [mark_lines="3 4 5"]
+
+            See https://jekyllrb.com/docs/liquid/tags/#code-snippet-highlighting for more details.
+          MSG
         end
       end
 
+      LEADING_OR_TRAILING_LINE_TERMINATORS = %r!\A(\n|\r)+|(\n|\r)+\z!.freeze
+
       def render(context)
         prefix = context["highlighter_prefix"] || ""
         suffix = context["highlighter_suffix"] || ""
-        code = super.to_s.gsub(%r!\A(\n|\r)+|(\n|\r)+\z!, "")
-
-        is_safe = !!context.registers[:site].safe
+        code = super.to_s.gsub(LEADING_OR_TRAILING_LINE_TERMINATORS, "")
 
         output =
           case context.registers[:site].highlighter
-          when "pygments"
-            render_pygments(code, is_safe)
           when "rouge"
             render_rouge(code)
+          when "pygments"
+            render_pygments(code, context)
           else
             render_codehighlighter(code)
           end
@@ -49,23 +51,9 @@ MSG
         prefix + rendered_output + suffix
       end
 
-      def sanitized_opts(opts, is_safe)
-        if is_safe
-          Hash[[
-            [:startinline, opts.fetch(:startinline, nil)],
-            [:hl_lines,    opts.fetch(:hl_lines, nil)],
-            [:linenos,     opts.fetch(:linenos, nil)],
-            [:encoding,    opts.fetch(:encoding, "utf-8")],
-            [:cssclass,    opts.fetch(:cssclass, nil)],
-          ].reject { |f| f.last.nil? }]
-        else
-          opts
-        end
-      end
-
       private
 
-      OPTIONS_REGEX = %r!(?:\w="[^"]*"|\w=\w|\w)+!
+      OPTIONS_REGEX = %r!(?:\w="[^"]*"|\w=\w|\w)+!.freeze
 
       def parse_options(input)
         options = {}
@@ -75,7 +63,7 @@ MSG
         input.scan(OPTIONS_REGEX) do |opt|
           key, value = opt.split("=")
           # If a quoted list, convert to array
-          if value && value.include?('"')
+          if value&.include?('"')
             value.delete!('"')
             value = value.split
           end
@@ -86,41 +74,44 @@ MSG
         options
       end
 
-      def render_pygments(code, is_safe)
-        Jekyll::External.require_with_graceful_fail("pygments") unless defined?(Pygments)
+      def render_pygments(code, _context)
+        Jekyll.logger.warn "Warning:", "Highlight Tag no longer supports rendering with Pygments."
+        Jekyll.logger.warn "", "Using the default highlighter, Rouge, instead."
+        render_rouge(code)
+      end
 
-        highlighted_code = Pygments.highlight(
-          code,
-          :lexer   => @lang,
-          :options => sanitized_opts(@highlight_options, is_safe)
-        )
+      def render_rouge(code)
+        require "rouge"
+        formatter = Rouge::Formatters::HTML.new
+        formatter = line_highlighter_formatter(formatter) if @highlight_options[:mark_lines]
+        formatter = table_formatter(formatter) if @highlight_options[:linenos]
 
-        if highlighted_code.nil?
-          Jekyll.logger.error <<-MSG
-There was an error highlighting your code:
+        lexer = Rouge::Lexer.find_fancy(@lang, code) || Rouge::Lexers::PlainText
+        formatter.format(lexer.lex(code))
+      end
 
-#{code}
+      def line_highlighter_formatter(formatter)
+        Rouge::Formatters::HTMLLineHighlighter.new(
+          formatter,
+          :highlight_lines => mark_lines
+        )
+      end
 
-While attempting to convert the above code, Pygments.rb returned an unacceptable value.
-This is usually a timeout problem solved by running `jekyll build` again.
-MSG
-          raise ArgumentError, "Pygments.rb returned an unacceptable value "\
-          "when attempting to highlight some code."
-        end
+      def mark_lines
+        value = @highlight_options[:mark_lines]
+        return value.map(&:to_i) if value.is_a?(Array)
 
-        highlighted_code.sub('<div class="highlight"><pre>', "").sub("</pre></div>", "")
+        raise SyntaxError, "Syntax Error for mark_lines declaration. Expected a " \
+                           "double-quoted list of integers."
       end
 
-      def render_rouge(code)
-        formatter = Jekyll::Utils::Rouge.html_formatter(
-          :line_numbers => @highlight_options[:linenos],
-          :wrap         => false,
+      def table_formatter(formatter)
+        Rouge::Formatters::HTMLTable.new(
+          formatter,
           :css_class    => "highlight",
           :gutter_class => "gutter",
           :code_class   => "code"
         )
-        lexer = ::Rouge::Lexer.find_fancy(@lang, code) || Rouge::Lexers::PlainText
-        formatter.format(lexer.lex(code))
       end
 
       def render_codehighlighter(code)
@@ -128,12 +119,8 @@ MSG
       end
 
       def add_code_tag(code)
-        code_attributes = [
-          "class=\"language-#{@lang.to_s.tr("+", "-")}\"",
-          "data-lang=\"#{@lang}\"",
-        ].join(" ")
-        "<figure class=\"highlight\"><pre><code #{code_attributes}>"\
-        "#{code.chomp}</code></pre></figure>"
+        code_attrs = %(class="language-#{@lang.tr("+", "-")}" data-lang="#{@lang}")
+        %(<figure class="highlight"><pre><code #{code_attrs}>#{code.chomp}</code></pre></figure>)
       end
     end
   end

data/lib/jekyll/tags/include.rb

@@ -2,37 +2,29 @@
 
 module Jekyll
   module Tags
-    class IncludeTagError < StandardError
-      attr_accessor :path
-
-      def initialize(msg, path)
-        super(msg)
-        @path = path
-      end
-    end
-
     class IncludeTag < Liquid::Tag
       VALID_SYNTAX = %r!
         ([\w-]+)\s*=\s*
-        (?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|([\w\.-]+))
-      !x
+        (?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|([\w.-]+))
+      !x.freeze
       VARIABLE_SYNTAX = %r!
-        (?<variable>[^{]*(\{\{\s*[\w\-\.]+\s*(\|.*)?\}\}[^\s{}]*)+)
+        (?<variable>[^{]*(\{\{\s*[\w\-.]+\s*(\|.*)?\}\}[^\s{}]*)+)
         (?<params>.*)
-      !mx
+      !mx.freeze
 
-      FULL_VALID_SYNTAX = %r!\A\s*(?:#{VALID_SYNTAX}(?=\s|\z)\s*)*\z!
-      VALID_FILENAME_CHARS = %r!^[\w/.\-()+~\#@]+$!
-      INVALID_SEQUENCES = %r![./]{2,}!
+      FULL_VALID_SYNTAX = %r!\A\s*(?:#{VALID_SYNTAX}(?=\s|\z)\s*)*\z!.freeze
+      VALID_FILENAME_CHARS = %r!^[\w/.\-()+~\#@]+$!.freeze
+      INVALID_SEQUENCES = %r![./]{2,}!.freeze
 
       def initialize(tag_name, markup, tokens)
         super
-        matched = markup.strip.match(VARIABLE_SYNTAX)
+        markup  = markup.strip
+        matched = markup.match(VARIABLE_SYNTAX)
         if matched
           @file = matched["variable"].strip
           @params = matched["params"].strip
         else
-          @file, @params = markup.strip.split(%r!\s+!, 2)
+          @file, @params = markup.split(%r!\s+!, 2)
         end
         validate_params if @params
         @tag_name = tag_name
@@ -44,51 +36,47 @@ module Jekyll
 
       def parse_params(context)
         params = {}
-        markup = @params
-
-        while (match = VALID_SYNTAX.match(markup))
-          markup = markup[match.end(0)..-1]
-
-          value = if match[2]
-                    match[2].gsub(%r!\\"!, '"')
-                  elsif match[3]
-                    match[3].gsub(%r!\\'!, "'")
-                  elsif match[4]
-                    context[match[4]]
+        @params.scan(VALID_SYNTAX) do |key, d_quoted, s_quoted, variable|
+          value = if d_quoted
+                    d_quoted.include?('\\"') ? d_quoted.gsub('\\"', '"') : d_quoted
+                  elsif s_quoted
+                    s_quoted.include?("\\'") ? s_quoted.gsub("\\'", "'") : s_quoted
+                  elsif variable
+                    context[variable]
                   end
 
-          params[match[1]] = value
+          params[key] = value
         end
         params
       end
 
       def validate_file_name(file)
-        if file =~ INVALID_SEQUENCES || file !~ VALID_FILENAME_CHARS
-          raise ArgumentError, <<-MSG
-Invalid syntax for include tag. File contains invalid characters or sequences:
+        if INVALID_SEQUENCES.match?(file) || !VALID_FILENAME_CHARS.match?(file)
+          raise ArgumentError, <<~MSG
+            Invalid syntax for include tag. File contains invalid characters or sequences:
 
-  #{file}
+              #{file}
 
-Valid syntax:
+            Valid syntax:
 
-  #{syntax_example}
+              #{syntax_example}
 
-MSG
+          MSG
         end
       end
 
       def validate_params
-        unless @params =~ FULL_VALID_SYNTAX
-          raise ArgumentError, <<-MSG
-Invalid syntax for include tag:
+        unless FULL_VALID_SYNTAX.match?(@params)
+          raise ArgumentError, <<~MSG
+            Invalid syntax for include tag:
 
-  #{@params}
+            #{@params}
 
-Valid syntax:
+            Valid syntax:
 
-  #{syntax_example}
+            #{syntax_example}
 
-MSG
+          MSG
         end
       end
 
@@ -99,13 +87,7 @@ MSG
 
       # Render the variable if required
       def render_variable(context)
-        if @file =~ VARIABLE_SYNTAX
-          partial = context.registers[:site]
-            .liquid_renderer
-            .file("(variable)")
-            .parse(@file)
-          partial.render!(context)
-        end
+        Liquid::Template.parse(@file).render(context) if VARIABLE_SYNTAX.match?(@file)
       end
 
       def tag_includes_dirs(context)
@@ -115,7 +97,7 @@ MSG
       def locate_include_file(context, file, safe)
         includes_dirs = tag_includes_dirs(context)
         includes_dirs.each do |dir|
-          path = File.join(dir.to_s, file.to_s)
+          path = PathManager.join(dir, file)
           return path if valid_include_file?(path, dir.to_s, safe)
         end
         raise IOError, could_not_locate_message(file, includes_dirs, safe)
@@ -147,17 +129,12 @@ MSG
       end
 
       def add_include_to_dependency(site, path, context)
-        page = context.registers[:page]
-        return unless page
-        return unless page.key?("path")
-
-        absolute_path = \
-          if page["collection"]
-            site.in_source_dir(site.config["collections_dir"], page["path"])
-          else
-            site.in_source_dir(page["path"])
-          end
-        site.regenerator.add_dependency(absolute_path, path)
+        if context.registers[:page]&.key?("path")
+          site.regenerator.add_dependency(
+            site.in_source_dir(context.registers[:page]["path"]),
+            path
+          )
+        end
       end
 
       def load_cached_partial(path, context)
@@ -202,8 +179,8 @@ MSG
       private
 
       def could_not_locate_message(file, includes_dirs, safe)
-        message = "Could not locate the included file '#{file}' in any of "\
-          "#{includes_dirs}. Ensure it exists in one of those directories and"
+        message = "Could not locate the included file '#{file}' in any of #{includes_dirs}. " \
+                  "Ensure it exists in one of those directories and"
         message + if safe
                     " is not a symlink as those are not allowed in safe mode."
                   else
@@ -212,30 +189,87 @@ MSG
       end
     end
 
+    # Do not inherit from this class.
+    # TODO: Merge into the `Jekyll::Tags::IncludeTag` in v5.0
+    class OptimizedIncludeTag < IncludeTag
+      def render(context)
+        @site ||= context.registers[:site]
+
+        file = render_variable(context) || @file
+        validate_file_name(file)
+
+        @site.inclusions[file] ||= locate_include_file(file)
+        inclusion = @site.inclusions[file]
+
+        add_include_to_dependency(inclusion, context) if @site.config["incremental"]
+
+        context.stack do
+          context["include"] = parse_params(context) if @params
+          inclusion.render(context)
+        end
+      end
+
+      private
+
+      def locate_include_file(file)
+        @site.includes_load_paths.each do |dir|
+          path = PathManager.join(dir, file)
+          return Inclusion.new(@site, dir, file) if valid_include_file?(path, dir)
+        end
+        raise IOError, could_not_locate_message(file, @site.includes_load_paths, @site.safe)
+      end
+
+      def valid_include_file?(path, dir)
+        File.file?(path) && !outside_scope?(path, dir)
+      end
+
+      def outside_scope?(path, dir)
+        @site.safe && !realpath_prefixed_with?(path, dir)
+      end
+
+      def realpath_prefixed_with?(path, dir)
+        File.realpath(path).start_with?(dir)
+      rescue StandardError
+        false
+      end
+
+      def add_include_to_dependency(inclusion, context)
+        page = context.registers[:page]
+        return unless page&.key?("path")
+
+        absolute_path = \
+          if page["collection"]
+            @site.in_source_dir(@site.config["collections_dir"], page["path"])
+          else
+            @site.in_source_dir(page["path"])
+          end
+
+        @site.regenerator.add_dependency(absolute_path, inclusion.path)
+      end
+    end
+
     class IncludeRelativeTag < IncludeTag
       def tag_includes_dirs(context)
         Array(page_path(context)).freeze
       end
 
       def page_path(context)
-        if context.registers[:page].nil?
-          context.registers[:site].source
-        else
-          site = context.registers[:site]
-          page_payload  = context.registers[:page]
-          resource_path = \
-            if page_payload["collection"].nil?
-              page_payload["path"]
-            else
-              File.join(site.config["collections_dir"], page_payload["path"])
-            end
-          resource_path.sub!(%r!/#excerpt\z!, "")
-          site.in_source_dir File.dirname(resource_path)
-        end
+        page, site = context.registers.values_at(:page, :site)
+        return site.source unless page
+
+        site.in_source_dir File.dirname(resource_path(page, site))
+      end
+
+      private
+
+      def resource_path(page, site)
+        path = page["path"]
+        path = File.join(site.config["collections_dir"], path) if page["collection"]
+        path.delete_suffix("/#excerpt")
       end
     end
   end
 end
 
-Liquid::Template.register_tag("include", Jekyll::Tags::IncludeTag)
+Liquid::Template.register_tag("include", Jekyll::Tags::OptimizedIncludeTag)
 Liquid::Template.register_tag("include_relative", Jekyll::Tags::IncludeRelativeTag)

data/lib/jekyll/tags/link.rb

@@ -3,9 +3,11 @@
 module Jekyll
   module Tags
     class Link < Liquid::Tag
+      include Jekyll::Filters::URLFilters
+
       class << self
         def tag_name
-          self.name.split("::").last.downcase
+          name.split("::").last.downcase
         end
       end
 
@@ -16,19 +18,22 @@ module Jekyll
       end
 
       def render(context)
+        @context = context
         site = context.registers[:site]
+        relative_path = Liquid::Template.parse(@relative_path).render(context)
+        relative_path_with_leading_slash = PathManager.join("", relative_path)
 
         site.each_site_file do |item|
-          return item.url if item.relative_path == @relative_path
+          return relative_url(item) if item.relative_path == relative_path
           # This takes care of the case for static files that have a leading /
-          return item.url if item.relative_path == "/#{@relative_path}"
+          return relative_url(item) if item.relative_path == relative_path_with_leading_slash
         end
 
-        raise ArgumentError, <<-MSG
-Could not find document '#{@relative_path}' in tag '#{self.class.tag_name}'.
+        raise ArgumentError, <<~MSG
+          Could not find document '#{relative_path}' in tag '#{self.class.tag_name}'.
 
-Make sure the document exists and the path is correct.
-MSG
+          Make sure the document exists and the path is correct.
+        MSG
       end
     end
   end

data/lib/jekyll/tags/post_url.rb

@@ -3,7 +3,7 @@
 module Jekyll
   module Tags
     class PostComparer
-      MATCHER = %r!^(.+/)*(\d+-\d+-\d+)-(.*)$!
+      MATCHER = %r!^(.+/)*(\d+-\d+-\d+)-(.*)$!.freeze
 
       attr_reader :path, :date, :slug, :name
 
@@ -13,17 +13,18 @@ module Jekyll
         all, @path, @date, @slug = *name.sub(%r!^/!, "").match(MATCHER)
         unless all
           raise Jekyll::Errors::InvalidPostNameError,
-            "'#{name}' does not contain valid date and/or title."
+                "'#{name}' does not contain valid date and/or title."
         end
 
-        escaped_slug = Regexp.escape(slug)
-        @name_regex = %r!^_posts/#{path}#{date}-#{escaped_slug}\.[^.]+|
-          ^#{path}_posts/?#{date}-#{escaped_slug}\.[^.]+!x
+        basename_pattern = "#{date}-#{Regexp.escape(slug)}\\.[^.]+"
+        @name_regex = %r!^_posts/#{path}#{basename_pattern}|^#{path}_posts/?#{basename_pattern}!
       end
 
       def post_date
-        @post_date ||= Utils.parse_date(date,
-          "\"#{date}\" does not contain valid date and/or title.")
+        @post_date ||= Utils.parse_date(
+          date,
+          "'#{date}' does not contain valid date and/or title."
+        )
       end
 
       def ==(other)
@@ -38,6 +39,7 @@ module Jekyll
       end
 
       private
+
       # Construct the directory-aware post slug for a Jekyll::Post
       #
       # other - the Jekyll::Post
@@ -48,53 +50,54 @@ module Jekyll
         if path.nil? || path == ""
           other.data["slug"]
         else
-          path + "/" + other.data["slug"]
+          "#{path}/#{other.data["slug"]}"
         end
       end
     end
 
     class PostUrl < Liquid::Tag
+      include Jekyll::Filters::URLFilters
+
       def initialize(tag_name, post, tokens)
         super
         @orig_post = post.strip
         begin
           @post = PostComparer.new(@orig_post)
         rescue StandardError => e
-          raise Jekyll::Errors::PostURLError, <<-MSG
-Could not parse name of post "#{@orig_post}" in tag 'post_url'.
-
-Make sure the post exists and the name is correct.
-
-#{e.class}: #{e.message}
-MSG
+          raise Jekyll::Errors::PostURLError, <<~MSG
+            Could not parse name of post "#{@orig_post}" in tag 'post_url'.
+             Make sure the post exists and the name is correct.
+             #{e.class}: #{e.message}
+          MSG
         end
       end
 
       def render(context)
+        @context = context
         site = context.registers[:site]
 
-        site.posts.docs.each do |p|
-          return p.url if @post == p
+        site.posts.docs.each do |document|
+          return relative_url(document) if @post == document
         end
 
         # New matching method did not match, fall back to old method
         # with deprecation warning if this matches
 
-        site.posts.docs.each do |p|
-          next unless @post.deprecated_equality p
-          Jekyll::Deprecator.deprecation_message "A call to "\
-            "'{% post_url #{@post.name} %}' did not match " \
-            "a post using the new matching method of checking name " \
-            "(path-date-slug) equality. Please make sure that you " \
-            "change this tag to match the post's name exactly."
-          return p.url
-        end
+        site.posts.docs.each do |document|
+          next unless @post.deprecated_equality document
 
-        raise Jekyll::Errors::PostURLError, <<-MSG
-Could not find post "#{@orig_post}" in tag 'post_url'.
+          Jekyll::Deprecator.deprecation_message(
+            "A call to '{% post_url #{@post.name} %}' did not match a post using the new " \
+            "matching method of checking name (path-date-slug) equality. Please make sure " \
+            "that you change this tag to match the post's name exactly."
+          )
+          return relative_url(document)
+        end
 
-Make sure the post exists and the name is correct.
-MSG
+        raise Jekyll::Errors::PostURLError, <<~MSG
+          Could not find post "#{@orig_post}" in tag 'post_url'.
+          Make sure the post exists and the name is correct.
+        MSG
       end
     end
   end