RubyGems - jekyll-highlight-cards - Versions diffs - 2.0.0 → 2.2.0 - Mend

jekyll-highlight-cards 2.0.0 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +19 -0
data/README.md +36 -0
data/jekyll-highlight-cards.gemspec +4 -2
data/lib/jekyll-highlight-cards/archive_helper.rb +73 -54
data/lib/jekyll-highlight-cards/commands/freeze_archives.rb +178 -0
data/lib/jekyll-highlight-cards/dimension_parser.rb +10 -18
data/lib/jekyll-highlight-cards/expression_evaluator.rb +22 -23
data/lib/jekyll-highlight-cards/freeze_archives/archive_inserter.rb +72 -0
data/lib/jekyll-highlight-cards/freeze_archives/markup_analyzer.rb +59 -0
data/lib/jekyll-highlight-cards/freeze_archives/tag_locator.rb +32 -0
data/lib/jekyll-highlight-cards/image_sizing_hooks.rb +53 -62
data/lib/jekyll-highlight-cards/linkcard_markup.rb +83 -0
data/lib/jekyll-highlight-cards/linkcard_tag.rb +13 -92
data/lib/jekyll-highlight-cards/polaroid_markup.rb +81 -0
data/lib/jekyll-highlight-cards/polaroid_tag.rb +43 -119
data/lib/jekyll-highlight-cards/template_renderer.rb +22 -20
data/lib/jekyll-highlight-cards/version.rb +1 -1
data/lib/jekyll-highlight-cards.rb +6 -0
metadata +39 -5

data/lib/jekyll-highlight-cards/freeze_archives/archive_inserter.rb ADDED Viewed

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+module JekyllHighlightCards
+  module FreezeArchives
+    # Surgically insert an archive token into a located tag span.
+    #
+    # Single-line tags splice after the last non-whitespace of the markup.
+    # Multiline tags add a new line before the closer, indented like the last
+    # content line (see creative-source-scan-rewrite).
+    class ArchiveInserter
+      # Insert archive URL into +content+ at +span+
+      #
+      # @param content [String] full file contents
+      # @param span [Hash] locator span with +:tag+, +:markup+, +:range+
+      # @param archive_url [String] Wayback (or other) archive URL to freeze
+      # @return [String] updated file contents
+      def insert(content, span, archive_url)
+        range = span.fetch(:range)
+        tag_text = content[range]
+        updated = rewrite_tag(tag_text, span.fetch(:tag), archive_url)
+        content[0...range.begin] + updated + content[range.end..]
+      end
+      private
+      def rewrite_tag(tag_text, tag, archive_url)
+        token = archive_token(tag, archive_url)
+        match = tag_text.match(/\A(?<head>[\s\S]*?)(?<closer>-?%})\z/)
+        raise ArgumentError, "tag span missing closing %}" unless match
+        head = match[:head]
+        closer = match[:closer]
+        if head.include?("\n")
+          insert_multiline(head, closer, token)
+        else
+          insert_single_line(head, closer, token)
+        end
+      end
+      def insert_single_line(head, closer, token)
+        # Preserve trailing whitespace before %}
+        trailing = head[/\s*\z/] || ""
+        body = head[0...(head.length - trailing.length)]
+        "#{body} #{token}#{trailing}#{closer}"
+      end
+      def insert_multiline(head, closer, token)
+        lines = head.split("\n", -1)
+        # Drop trailing whitespace-only segment before %} and keep its indent for the closer
+        closer_indent = ""
+        closer_indent = lines.pop if lines.last&.strip&.empty?
+        last_content = lines.reverse.find { |line| !line.strip.empty? }
+        indent = last_content ? last_content[/\A[ \t]*/] : ""
+        "#{lines.join("\n")}\n#{indent}#{token}\n#{closer_indent}#{closer}"
+      end
+      def archive_token(tag, archive_url)
+        case tag.to_s
+        when "linkcard"
+          "archive:#{archive_url}"
+        when "polaroid"
+          %(archive="#{archive_url.to_s.gsub('"', '\\"')}")
+        else
+          raise ArgumentError, "unsupported tag: #{tag}"
+        end
+      end
+    end
+  end
+end

data/lib/jekyll-highlight-cards/freeze_archives/markup_analyzer.rb ADDED Viewed

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module JekyllHighlightCards
+  module FreezeArchives
+    # Classify `{% linkcard %}` / `{% polaroid %}` markup for freeze-archives.
+    #
+    # A freeze candidate is a tag that has a literal archiveable target URL and
+    # does not already encode an archive (`archive:` / `archive=` / `none`).
+    # Liquid-dynamic targets are skipped (build-time fallback remains).
+    class MarkupAnalyzer
+      include ArchiveHelper
+      include ExpressionEvaluator
+      # @param site [Jekyll::Site, nil] site for +highlight_cards.noarchive+
+      def initialize(site: nil)
+        @site = site
+      end
+      # Analyze tag markup for freeze eligibility
+      #
+      # @param tag [String] +"linkcard"+ or +"polaroid"+
+      # @param markup [String] contents between the tag name and +%}+
+      # @return [Hash, nil] +{ target_url: String }+ when freezable, else +nil+
+      def analyze(tag, markup)
+        case tag.to_s
+        when "linkcard"
+          analyze_linkcard(markup)
+        when "polaroid"
+          analyze_polaroid(markup)
+        end
+      end
+      private
+      def analyze_linkcard(markup)
+        parsed = LinkcardMarkup.split(markup)
+        return nil if parsed.key?(:archive)
+        candidate_for(strip_outer_quotes(parsed[:url]))
+      end
+      def analyze_polaroid(markup)
+        parsed = PolaroidMarkup.parse(markup)
+        return nil if parsed.key?(:archive)
+        return nil unless parsed.key?(:link)
+        candidate_for(strip_outer_quotes(parsed[:link]))
+      end
+      def candidate_for(target)
+        return nil if target.to_s.empty?
+        return nil if variable_lookup?(target)
+        return nil unless archiveable_url?(target, site: @site)
+        { target_url: target }
+      end
+    end
+  end
+end

data/lib/jekyll-highlight-cards/freeze_archives/tag_locator.rb ADDED Viewed

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module JekyllHighlightCards
+  module FreezeArchives
+    # Locate `{% linkcard %}` / `{% polaroid %}` spans in source text.
+    #
+    # Supports multiline tags. Returns structural spans for analysis/insert —
+    # does not decide freeze eligibility.
+    class TagLocator
+      # Optional +- after +{ %+ / before +%}+ is Liquid whitespace control —
+      # keep the trailing dash out of +:markup+ (leading dash stays in the opener).
+      TAG_PATTERN = /{%-?\s*(linkcard|polaroid)\s+([\s\S]*?)-?%}/
+      # Find highlight-card tag spans in +text+
+      #
+      # @param text [String] file contents
+      # @return [Array<Hash>] each hash has +:tag+, +:markup+, +:range+ (exclusive end)
+      def locate(text)
+        spans = []
+        text.to_s.scan(TAG_PATTERN) do
+          match = Regexp.last_match
+          spans << {
+            tag: match[1],
+            markup: match[2],
+            range: match.begin(0)...match.end(0)
+          }
+        end
+        spans
+      end
+    end
+  end
+end

data/lib/jekyll-highlight-cards/image_sizing_hooks.rb CHANGED Viewed

@@ -21,12 +21,27 @@ module JekyllHighlightCards
   # @note Images inside code fences and inline code are not processed
   # @note Sized images are automatically wrapped in <a> tags (if not already)
   module ImageSizingHooks
-    extend DimensionParser
     # Process document content before rendering
     # Converts ![alt](src =WxH) to ![alt](src)<!-- IMG_SIZE:W:H -->
     #
     # @param document [Jekyll::Document] the document being processed
+    SIZED_MARKDOWN_PATTERN = /!\[([^\]]*)\]\(([^)]+)[ \t]+=([^)]+)\)/
+    SIZED_IMG_HTML_PATTERN = /(\s*)(<img[ \t]+[^>]*>)\s*<!--\s*IMG_SIZE:([^:]*):([^:]*)\s*-->/
+    # @param prefix [String] HTML preceding an image tag
+    # @return [Integer] unclosed anchor tags in +prefix+
+    def self.unclosed_anchor_count(prefix)
+      prefix.scan("<a ").length + prefix.scan("<a\t").length - prefix.scan("</a>").length
+    end
+    def self.markdown_inline_check_position(full_match)
+      full_match.begin(0)
+    end
+    def self.img_link_prefix(output, match)
+      output[0, match.begin(2)]
+    end
     def self.process_pre_render(document)
       content = document.content
       return unless content
@@ -42,23 +57,24 @@ module JekyllHighlightCards
         end
         # Process the line to convert sized images
-        processed_line = line.dup
+        processed_line = line
         # Match ![alt](src =dimensions) pattern
         # Use gsub with block to check each match
-        processed_line.gsub!(/!\[([^\]]*)\]\(([^)]+)\s+=([^)]+)\)/) do |match|
-          match_start = Regexp.last_match.begin(0)
+        processed_line.gsub!(SIZED_MARKDOWN_PATTERN) do |match|
+          full_match = Regexp.last_match
+          match_start = markdown_inline_check_position(full_match)
           # Skip if inside inline code
           if in_inline_code?(line, match_start)
             match
           else
-            alt = Regexp.last_match(1)
-            src = Regexp.last_match(2).strip
-            size = Regexp.last_match(3).strip
+            alt = full_match[1]
+            src = full_match[2].strip
+            size = full_match[3].strip
             # Parse dimensions using DimensionParser
-            width, height = parse_dimensions(size)
+            width, height = DimensionParser.parse_dimensions(size)
             # Build marker comment
             "![#{alt}](#{src})<!-- IMG_SIZE:#{width}:#{height} -->"
@@ -83,82 +99,63 @@ module JekyllHighlightCards
       output = output.dup
       # Match <img><!-- IMG_SIZE:W:H --> patterns
-      output.gsub!(/(<img\s+[^>]*>)\s*<!--\s*IMG_SIZE:([^:]*):([^:]*)\s*-->/) do
-        img_tag = Regexp.last_match(1)
-        width = Regexp.last_match(2).to_s.strip
-        height = Regexp.last_match(3).to_s.strip
+      output.gsub!(SIZED_IMG_HTML_PATTERN) do
+        match = Regexp.last_match
+        img_tag = match[2]
+        width = match[3].strip
+        height = match[4].strip
-        # Build attributes to add
         attrs = []
-        attrs << %(width="#{width}") unless width.to_s.empty?
-        attrs << %(height="#{height}") unless height.to_s.empty?
+        attrs << %(width="#{width}") unless width.empty?
+        attrs << %(height="#{height}") unless height.empty?
-        # Add attributes to img tag
         modified_img = if attrs.any?
                          img_tag.sub("<img", "<img #{attrs.join(" ")}")
                        else
                          img_tag
                        end
-        # Extract src for auto-linking
         src = img_tag[/src=["']([^"']+)["']/, 1]
+        next modified_img if src.nil?
-        # Skip auto-linking if src is missing or malformed
-        next modified_img if src.nil? || src.empty?
+        prefix = img_link_prefix(output, match)
-        # Check if image is already in a link (look back in output)
-        # Simple heuristic: check if there's an <a> tag before this image without a closing </a>
-        img_position = Regexp.last_match.begin(0)
-        prefix = output[0...img_position]
-        # Count <a> and </a> tags before this image
-        open_count = prefix.scan(/<a\s+/).length
-        close_count = prefix.scan(%r{</a>}).length
-        already_linked = (open_count > close_count)
+        already_linked = unclosed_anchor_count(prefix).positive?
         # Auto-link if not already linked
         if already_linked
           modified_img
         else
-          %(<a href="#{CGI.escapeHTML(src)}">#{modified_img}</a>)
+          %(<a href="#{CGI.escapeHTML(CGI.unescapeHTML(src))}">#{modified_img}</a>)
         end
       end
       document.output = output
     end
+    def self.fence_count_before(lines, line_idx)
+      lines.first(line_idx).count { |line| line.start_with?("```", "~~~") }
+    end
     # Check if a line is inside a code fence
     #
     # @param lines [Array<String>] all lines in the document
     # @param line_idx [Integer] the current line index
     # @return [Boolean] true if inside code fence
     def self.in_code_fence?(lines, line_idx)
-      # Check for fenced code blocks (backticks or tildes)
-      fence_count = 0
-      (0...line_idx).each do |i|
-        # Match both backtick and tilde fences
-        fence_count += 1 if lines[i] =~ /^(`{3,}|~{3,})/
-      end
-      # Odd count means we're inside a fence
-      return true if fence_count.odd?
-      # Check for indented code blocks
-      # A line is in an indented code block if there's a contiguous run
-      # of indented lines (4+ spaces or tab) leading up to it
-      return false if line_idx.zero?
-      # Check if current line and previous lines are indented
-      idx = line_idx
-      while idx.positive?
-        line = lines[idx]
-        # If line starts with 4+ spaces or tab, it's indented code
-        break unless line =~ /^(    |\t)/
-        idx -= 1
-      end
+      return true if fence_count_before(lines, line_idx).odd?
+      return false unless line_idx.positive?
-      # If we found a contiguous run of indented lines reaching current line
-      idx < line_idx
+      lines.slice(line_idx).start_with?("    ", "\t")
+    end
+    # Count backtick characters before a position in a line
+    #
+    # @param line [String] the line of text
+    # @param position [Integer] the position in the line
+    # @return [Integer] number of backticks before +position+
+    def self.backtick_count_before(line, position)
+      line[0, position].count("`")
     end
     # Check if text position is inside inline code
@@ -167,13 +164,7 @@ module JekyllHighlightCards
     # @param position [Integer] the position in the line
     # @return [Boolean] true if inside inline code
     def self.in_inline_code?(line, position)
-      # Count backticks before the position
-      backtick_count = 0
-      line[0...position].each_char do |char|
-        backtick_count += 1 if char == "`"
-      end
-      # Odd count means we're inside inline code
-      backtick_count.odd?
+      backtick_count_before(line, position).odd?
     end
   end
 end

data/lib/jekyll-highlight-cards/linkcard_markup.rb ADDED Viewed

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+module JekyllHighlightCards
+  # Shared structural parser for `{% linkcard %}` markup.
+  #
+  # Used by {LinkcardTag} at render time and by freeze-archives analysis
+  # without Liquid evaluation. Tokens are returned as written in source.
+  module LinkcardMarkup
+    module_function
+    # Parse linkcard markup into URL, title, and archive components
+    #
+    # @param markup [String] the tag markup (contents between tag name and `%}`)
+    # @return [Hash] keys +:url+, optional +:title+, optional +:archive+ (unevaluated)
+    def split(markup)
+      tokens = tokenize(markup)
+      result = {}
+      result[:url] = tokens.shift
+      title_tokens = []
+      tokens.each do |token|
+        if token.start_with?("archive:")
+          result[:archive] = token.delete_prefix("archive:")
+        else
+          title_tokens << token
+        end
+      end
+      result[:title] = title_tokens.join(" ") unless title_tokens.empty?
+      result
+    end
+    # Tokenize markup respecting quotes and Liquid brace depth
+    #
+    # @param markup [String] the tag markup
+    # @return [Array<String>] non-empty tokens
+    def tokenize(markup)
+      tokens = []
+      current = ""
+      in_quotes = false
+      quote_char = nil
+      in_liquid = 0
+      escaped = false
+      "#{markup} ".each_char do |char|
+        if escaped
+          current += char
+          escaped = false
+          next
+        end
+        if char == "\\" && in_quotes
+          escaped = true
+          next
+        end
+        if char == "{" && !in_quotes
+          in_liquid += 1
+          current += char
+        elsif char == "}" && in_liquid.positive? && !in_quotes
+          in_liquid -= 1
+          current += char
+        elsif char == '"' && !in_quotes
+          in_quotes = true
+          quote_char = char
+          current += char
+        elsif char == quote_char
+          in_quotes = false
+          current += char
+          quote_char = nil
+        elsif char.match?(/\s/) && !in_quotes && in_liquid.zero?
+          tokens << current
+          current = ""
+        else
+          current += char
+        end
+      end
+      tokens.reject!(&:empty?)
+      tokens
+    end
+  end
+end

data/lib/jekyll-highlight-cards/linkcard_tag.rb CHANGED Viewed

@@ -26,10 +26,6 @@ module JekyllHighlightCards
     # @param tag_name [String] the name of the tag
     # @param markup [String] the tag markup containing parameters
     # @param tokens [Array] parse tokens (unused)
-    def initialize(tag_name, markup, tokens)
-      super
-      @markup = markup.strip
-    end
     # Render the linkcard tag
     #
@@ -40,7 +36,7 @@ module JekyllHighlightCards
       parsed = split_markup(@markup)
       # Resolve URL (required)
-      url = resolve_url(parsed[:url], context)
+      url = resolve_url(parsed.fetch(:url), context)
       raise ArgumentError, "linkcard tag requires a URL" if url.nil? || url.empty?
       # Resolve title (optional)
@@ -66,73 +62,7 @@ module JekyllHighlightCards
     # @param markup [String] the tag markup
     # @return [Hash] parsed components
     def split_markup(markup)
-      # Split by whitespace, keeping quoted strings and Liquid expressions together
-      # Handles escaped quotes (\") and backslashes (\\) within quoted strings
-      tokens = []
-      current = ""
-      in_quotes = false
-      quote_char = nil
-      in_liquid = 0 # Track nested Liquid expressions
-      escaped = false # Track if next character is escaped
-      markup.each_char do |char|
-        # Handle escape sequences when in quotes
-        if escaped
-          current += char # Add the escaped character directly
-          escaped = false
-          next
-        end
-        # Check for escape character when in quotes
-        if char == "\\" && in_quotes
-          escaped = true
-          next # Don't add backslash to output, it's just the escape marker
-        end
-        # Track Liquid expression boundaries
-        if char == "{" && !in_quotes
-          in_liquid += 1
-          current += char
-        elsif char == "}" && !in_quotes && in_liquid.positive?
-          in_liquid -= 1
-          current += char
-        # Track quote boundaries
-        elsif ['"', "'"].include?(char) && !in_quotes && in_liquid.zero?
-          in_quotes = true
-          quote_char = char
-          current += char
-        elsif char == quote_char && in_quotes
-          in_quotes = false
-          current += char
-          quote_char = nil
-        # Split on whitespace only if not in quotes or Liquid expression
-        elsif char.match?(/\s/) && !in_quotes && in_liquid.zero?
-          tokens << current unless current.empty?
-          current = ""
-        else
-          current += char
-        end
-      end
-      tokens << current unless current.empty?
-      # First token is URL, remaining tokens may be title or archive parameter
-      result = {
-        url: tokens.shift,
-        title: nil,
-        archive: nil
-      }
-      # Process remaining tokens
-      tokens.each do |token|
-        if token.start_with?("archive:")
-          result[:archive] = token.sub(/^archive:/, "")
-        else
-          # Accumulate title tokens
-          result[:title] = result[:title].nil? ? token : "#{result[:title]} #{token}"
-        end
-      end
-      result
+      LinkcardMarkup.split(markup)
     end
     # Resolve URL from token (may be Liquid expression or literal)
@@ -141,9 +71,7 @@ module JekyllHighlightCards
     # @param context [Liquid::Context] the Liquid context
     # @return [String] resolved URL
     def resolve_url(token, context)
-      return nil if token.nil? || token.empty?
-      evaluate_expression(token, context, allow_nil: false)
+      evaluate_expression(token, context)
     end
     # Resolve title from source (may be Liquid expression or literal)
@@ -152,9 +80,7 @@ module JekyllHighlightCards
     # @param context [Liquid::Context] the Liquid context
     # @return [String, nil] resolved title
     def resolve_title(source, context)
-      return nil if source.nil? || source.empty?
-      evaluate_expression(source, context, allow_nil: true)
+      evaluate_expression(source, context)
     end
     # Resolve archive URL (may be explicit, auto-lookup, or opt-out)
@@ -168,12 +94,9 @@ module JekyllHighlightCards
       return nil if source && source.downcase == "none"
       # Check for explicit archive URL
-      return evaluate_expression(source, context, allow_nil: true) if source && !source.empty?
-      # Auto-lookup if enabled
-      return archive_url_for(url) if archive_enabled?
+      return evaluate_expression(source, context) if source && !source.empty?
-      nil
+      archive_enabled? && archive_url_for(url, site: context.registers[:site])
     end
     # Build template variables hash for rendering
@@ -183,19 +106,17 @@ module JekyllHighlightCards
     # @param archive_url [String, nil] the archive URL
     # @return [Hash] template variables with raw and escaped versions
     def build_template_variables(url, title, archive_url)
-      display_url = strip_protocol(url)
-      display_url = display_url.sub(%r{/$}, "")
+      display_url = strip_protocol(url).delete_suffix("/")
-      {
-        "url" => url,
-        "display_url" => display_url,
+      variables = {
         "title" => title,
         "archive_url" => archive_url,
         "escaped_url" => CGI.escapeHTML(url),
-        "escaped_display_url" => CGI.escapeHTML(display_url),
-        "escaped_title" => title ? CGI.escapeHTML(title) : nil,
-        "escaped_archive_url" => archive_url ? CGI.escapeHTML(archive_url) : nil
+        "escaped_display_url" => CGI.escapeHTML(display_url)
       }
+      variables["escaped_title"] = CGI.escapeHTML(title) if title
+      variables["escaped_archive_url"] = CGI.escapeHTML(archive_url) if archive_url
+      variables
     end
     # Strip protocol from URL for display
@@ -203,7 +124,7 @@ module JekyllHighlightCards
     # @param url [String] the URL
     # @return [String] URL without protocol
     def strip_protocol(url)
-      url.sub(%r{^https?://}, "")
+      url.delete_prefix("https://").delete_prefix("http://")
     end
   end
 end

data/lib/jekyll-highlight-cards/polaroid_markup.rb ADDED Viewed

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+module JekyllHighlightCards
+  # Shared structural parser for `{% polaroid %}` markup.
+  #
+  # Used by {PolaroidTag} at render time (with Liquid evaluation applied by the
+  # tag) and by freeze-archives analysis on unevaluated tokens.
+  module PolaroidMarkup
+    module_function
+    # Parse polaroid markup into image URL and named parameters (unevaluated)
+    #
+    # @param markup [String] the tag markup (contents between tag name and `%}`)
+    # @return [Hash] +:image_url+ plus any +key=value+ params as symbols (raw tokens)
+    def parse(markup)
+      tokens = tokenize(markup)
+      image_url_token = tokens.shift
+      result = { image_url: image_url_token }
+      tokens.each do |token|
+        next unless token =~ /\A(\w+)=(.+)\z/
+        key = Regexp.last_match(1).to_sym
+        value_token = Regexp.last_match(2)
+        result[key] = value_token
+      end
+      result
+    end
+    # Tokenize markup respecting quotes (single or double) and Liquid brace depth
+    #
+    # @param markup [String] the tag markup
+    # @return [Array<String>] tokens (may include empty strings from leading whitespace)
+    def tokenize(markup)
+      tokens = []
+      current = ""
+      in_quotes = false
+      quote_char = nil
+      in_liquid = 0
+      escaped = false
+      # Trailing space flushes the final token through the whitespace branch
+      "#{markup} ".each_char do |char|
+        if escaped
+          current += char
+          escaped = false
+          next
+        end
+        if char == "\\" && in_quotes
+          escaped = true
+          next
+        end
+        if char == "{" && !in_quotes
+          in_liquid += 1
+          current += char
+        elsif char == "}" && in_liquid.positive? && !in_quotes
+          in_liquid -= 1
+          current += char
+        elsif ['"', "'"].include?(char) && !in_quotes
+          in_quotes = true
+          quote_char = char
+          current += char
+        elsif char == quote_char
+          in_quotes = false
+          current += char
+          quote_char = nil
+        elsif char.match?(/\s/) && !in_quotes && in_liquid.zero?
+          tokens << current
+          current = ""
+        else
+          current += char
+        end
+      end
+      tokens
+    end
+  end
+end