jekyll-highlight-cards 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14f9f3f5b5374e35f95524afc77c6edfc8a09469154924fa17859089b5df71c8
-  data.tar.gz: 896055006ef9a9ebe42e992c621ce0e666c487f8166be65b208ca7f173ef955d
+  metadata.gz: 2e7d4bb8027142ccb1dbf7e0327098460eb49fda5f10fa2619efeb9053fa1359
+  data.tar.gz: 9971cb5b3a34a9bfbfaf06539e973df20c5951fb5bac39649378c4909a03a759
 SHA512:
-  metadata.gz: 1fe96dece9fb642150e35571f1b7e8887b1d91236a16ea367d434846b550141dd08780e4532642db2e9103607fd5af70ae484ff85a018e30e678105113c45ca3
-  data.tar.gz: 224ec98ce539b1f7a00b9b8707b6552638c07ddacb8ff6ff87c988b5bed74c66c9c9bfd67dfa08ddf18ac072518b7418690c6b54a93dc71a83364045dce9d0c4
+  metadata.gz: d1183485eba6958f3d328b693207cfbccfd0dcef3da163511332c0ad16b39c30416b8c1bb41e767b9dc8ddee5d761f92ae26bb7b56f18ada1b5d1ef8a5bbfa21
+  data.tar.gz: 9d62f2b98e4923cdd73a75719718d92dd40b235dd0c61982e4222bc4a1f525b9593ddef3b10f3485ea56f30ad300e0be6310f8a6ccbfcc6ac50c1448092cd8d4

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [2.1.0](https://github.com/Texarkanine/jekyll-highlight-cards/compare/v2.0.0...v2.1.0) (2026-07-19)
+
+
+### Features
+
+* **test:** add Mutant mutation testing at 100% coverage ([#49](https://github.com/Texarkanine/jekyll-highlight-cards/issues/49)) ([e4e63dc](https://github.com/Texarkanine/jekyll-highlight-cards/commit/e4e63dc259ee767d0db31cb86e1b03e298f76f0d))
+
 ## [2.0.0](https://github.com/Texarkanine/jekyll-highlight-cards/compare/v1.1.2...v2.0.0) (2026-01-18)
 
 

data/jekyll-highlight-cards.gemspec

@@ -40,12 +40,14 @@ Gem::Specification.new do |spec|
 
   # Development dependencies
   spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "mutant", "~> 0.16"
+  spec.add_development_dependency "mutant-rspec", "~> 0.16"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.12"
   spec.add_development_dependency "rubocop", "~> 1.50"
   spec.add_development_dependency "rubocop-rake", "~> 0.6"
   spec.add_development_dependency "rubocop-rspec", "~> 3.8"
-  spec.add_development_dependency "simplecov", "~> 0.22"
-  spec.add_development_dependency "simplecov-cobertura", "~> 3.1"
+  spec.add_development_dependency "simplecov", "~> 1.0"
+  spec.add_development_dependency "simplecov-cobertura", "~> 4.0"
   spec.add_development_dependency "webmock", "~> 3.18"
 end

data/lib/jekyll-highlight-cards/archive_helper.rb

@@ -26,21 +26,12 @@ module JekyllHighlightCards
     # @return [String, nil] the archive URL, or nil if not found
     def archive_url_for(url)
       ArchiveHelper.archive_cache[url] ||= begin
-        log_info("Looking up archive for #{url}")
         archive_url = lookup_archive(url)
-        log_info("Archive URL: #{archive_url || ""}")
 
-        if archive_save_enabled?
-          log_info("Submitting to SavePageNow: #{url}")
-          archive_url = submit_archive(url) || archive_url
-          log_info("SavePageNow archived #{url} -> #{archive_url}")
-        end
+        archive_url = submit_archive(url) || archive_url if archive_save_enabled?
 
-        archive_url.to_s.empty? ? nil : archive_url
+        archive_url
       end
-    rescue StandardError => e
-      log_debug("Archive lookup failed for #{url}: #{e.message}")
-      nil
     end
 
     # Check if archiving is enabled via environment variables
@@ -72,14 +63,10 @@ module JekyllHighlightCards
     # @param url [String] the URL to look up
     # @return [String, nil] the archive URL if found, nil otherwise
     def lookup_archive(url)
-      log_debug("lookup_archive(#{url})")
-
       encoded_url = URI.encode_www_form_component(url)
       cdx_url_str = "https://web.archive.org/cdx/search/cdx?url=#{encoded_url}&output=json&filter=statuscode:200&limit=-1&fl=timestamp,original"
       cdx_url = URI.parse(cdx_url_str)
 
-      log_debug("CDX lookup URL: #{cdx_url_str}")
-
       response = Net::HTTP.start(
         cdx_url.host,
         cdx_url.port,
@@ -90,25 +77,15 @@ module JekyllHighlightCards
         http.request(Net::HTTP::Get.new(cdx_url.request_uri))
       end
 
-      unless response.is_a?(Net::HTTPSuccess)
-        log_debug("CDX lookup failed: #{response.code} #{response.message}")
-        return nil
-      end
+      return nil unless response.is_a?(Net::HTTPSuccess)
 
-      log_debug("CDX lookup found archived page...")
       rows = JSON.parse(response.body)
 
-      # First row is header, so we need at least 2 rows
-      return nil if rows.length <= 1
-
-      latest = rows.last
-      timestamp = latest[0]
-      archive_url = "https://web.archive.org/web/#{timestamp}/#{url}"
+      return nil if rows.size < 2
 
-      log_debug("CDX lookup found archived page: #{archive_url}")
-      archive_url
-    rescue StandardError => e
-      log_debug("CDX lookup error for #{url}: #{e.message}")
+      timestamp, = rows.last
+      "https://web.archive.org/web/#{timestamp}/#{url}"
+    rescue StandardError
       nil
     end
 
@@ -117,35 +94,29 @@ module JekyllHighlightCards
     # @param url [String] the URL to submit for archiving
     # @return [String, nil] the archive URL if successful, nil otherwise
     def submit_archive(url)
-      log_debug("submit_archive(#{url})")
-
       encoded_url = URI.encode_www_form_component(url)
       save_url = URI.parse("https://web.archive.org/save/#{encoded_url}")
 
-      response = Net::HTTP.start(
-        save_url.host,
-        save_url.port,
-        use_ssl: save_url.scheme == "https",
-        open_timeout: 10,
-        read_timeout: 30
-      ) do |http|
-        req = Net::HTTP::Get.new(save_url.request_uri, { "User-Agent" => archive_user_agent })
-        http.request(req)
+      response = begin
+        Net::HTTP.start(
+          save_url.host,
+          save_url.port,
+          use_ssl: save_url.scheme == "https",
+          open_timeout: 10,
+          read_timeout: 30
+        ) do |http|
+          req = Net::HTTP::Get.new(save_url.request_uri, { "User-Agent" => archive_user_agent })
+          http.request(req)
+        end
+      rescue StandardError
+        nil
       end
+      return nil if response.nil?
 
       location = response["content-location"]
+      return nil if location.to_s.empty?
 
-      if location && !location.empty?
-        archive_url = "https://web.archive.org#{location}"
-        log_info("SavePageNow archived #{url} -> #{archive_url}")
-        archive_url
-      else
-        log_debug("Archive submission returned no location for #{url}")
-        nil
-      end
-    rescue StandardError => e
-      log_debug("Archive submission error for #{url}: #{e.message}")
-      nil
+      "https://web.archive.org#{location}"
     end
   end
 end

data/lib/jekyll-highlight-cards/dimension_parser.rb

@@ -11,8 +11,7 @@ module JekyllHighlightCards
   # - Units: Supports px, em, %, etc. (e.g., "400pxx300px")
   #
   # @example
-  #   include DimensionParser
-  #   width, height = parse_dimensions("300x200")  #=> ["300", "200"]
+  #   width, height = DimensionParser.parse_dimensions("300x200")  #=> ["300", "200"]
   module DimensionParser
     # Parse dimension string into width and height components
     #
@@ -25,7 +24,7 @@ module JekyllHighlightCards
     #   parse_dimensions("x200")     #=> [nil, "200"]
     #   parse_dimensions("300")      #=> ["300", nil]
     #   parse_dimensions("400px")    #=> ["400px", nil]
-    def parse_dimensions(dim_str)
+    def self.parse_dimensions(dim_str)
       return [nil, nil] if dim_str.nil? || dim_str.empty?
 
       # Determine the separator:
@@ -34,29 +33,22 @@ module JekyllHighlightCards
       # - Otherwise, check if there's an 'x' that's a separator (not part of a unit like "px")
       #   An 'x' is a separator if it's at the end, followed by a digit, or at the start
       if dim_str.include?("xx")
-        # Find the position of "xx"
         idx = dim_str.index("xx")
-        # Split at the second 'x' (include first 'x' in width, skip both 'x's for height)
-        width = dim_str[0..idx].empty? ? nil : dim_str[0..idx]
+        width = dim_str[...(idx + 1)]
         height = dim_str[(idx + 2)..]
-        height = nil if height.nil? || height.empty?
+        height = nil if height.empty?
         [width, height]
-      elsif dim_str =~ /x\d/ || dim_str =~ /(?<![a-z])x$/i || dim_str.start_with?("x")
-        # Single 'x' separator in one of these cases:
-        # 1. Followed by a digit: "300x200", "10emx20em"
-        # 2. At end but NOT preceded by a letter: "300x"
-        # 3. At start: "x200"
-        # This matches "300x", "300x200", "x200", "10emx20em", but NOT "400px"
-        parts = dim_str.split("x", 2)
-        width = parts[0].empty? ? nil : parts[0]
-        height = parts[1].nil? || parts[1].empty? ? nil : parts[1]
+      elsif dim_str.match?(/x\d|(?<![a-z])x\z/) || dim_str.start_with?("x")
+        width_str, height_str = dim_str.split("x", 2)
+        width = width_str
+        width = nil if width.empty?
+        height = height_str
+        height = nil if height.empty?
         [width, height]
       else
         # No separator found - treat as width only
         [dim_str, nil]
       end
     end
-
-    module_function :parse_dimensions
   end
 end

data/lib/jekyll-highlight-cards/expression_evaluator.rb

@@ -19,14 +19,11 @@ module JekyllHighlightCards
     # @param allow_nil [Boolean] whether to allow nil results
     # @return [String, nil] evaluated value or nil if evaluation fails
     def evaluate_expression(token, context, allow_nil: true)
-      return nil if token.nil?
-      return "" if token.empty?
-
       # Strip outer quotes if present
       stripped = strip_outer_quotes(token)
 
       # If the original token was quoted, treat as literal string
-      if stripped != token
+      if !token.nil? && quote_wrapped?(token)
         return stripped if allow_nil
 
         return stripped.empty? ? nil : stripped
@@ -40,20 +37,16 @@ module JekyllHighlightCards
           result = template.render(context)
           return result if allow_nil
 
-          return result.to_s.empty? ? nil : result
-        rescue Liquid::SyntaxError, StandardError => e
-          log_debug("Failed to evaluate '#{token}' as Liquid expression: #{e.message}")
-          # Fall back to literal string
-          return token if allow_nil
+          return nil if result.empty?
 
-          return token.empty? ? nil : token
+          result
+        rescue Liquid::SyntaxError, StandardError => e
+          log_debug("Failed to evaluate '#{token}' as Liquid expression: #{e.class}: #{e}")
+          token
         end
+      else
+        token
       end
-
-      # Return as literal string
-      return token if allow_nil
-
-      token.empty? ? nil : token
     end
 
     # Check if an expression looks like a Liquid variable lookup
@@ -61,7 +54,7 @@ module JekyllHighlightCards
     # @param expression [String] the expression to check
     # @return [Boolean] true if expression contains Liquid syntax
     def variable_lookup?(expression)
-      return false if expression.nil? || expression.empty?
+      return false if expression.nil?
 
       expression.include?("{{") || expression.include?("{%")
     end
@@ -71,17 +64,23 @@ module JekyllHighlightCards
     # @param value [String] the string to process
     # @return [String] string with outer quotes removed if present
     def strip_outer_quotes(value)
-      return value if value.nil? || value.empty?
-
-      # Check for matching outer quotes
-      if ((value.start_with?('"') && value.end_with?('"')) ||
-         (value.start_with?("'") && value.end_with?("'"))) && (value.length > 1)
-        return value[1..-2]
-      end
+      return nil if value.nil?
+      return value[1..-2] if quote_wrapped?(value)
 
       value
     end
 
+    # Whether value has matching outer quotes and more than one character
+    #
+    # @param value [String] the string to inspect
+    # @return [Boolean]
+    def quote_wrapped?(value)
+      return false unless value.length >= 2
+
+      (value.start_with?('"') && value.end_with?('"')) ||
+        (value.start_with?("'") && value.end_with?("'"))
+    end
+
     # Log debug message
     #
     # @param message [String] message to log

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

@@ -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_tag.rb

@@ -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,71 +62,60 @@ 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
+      in_liquid = 0
+      escaped = false
 
-      markup.each_char do |char|
-        # Handle escape sequences when in quotes
+      "#{markup} ".each_char do |char|
         if escaped
-          current += char # Add the escaped character directly
+          current += char
           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
+          next
         end
 
-        # Track Liquid expression boundaries
         if char == "{" && !in_quotes
           in_liquid += 1
           current += char
-        elsif char == "}" && !in_quotes && in_liquid.positive?
+        elsif char == "}" && in_liquid.positive?
           in_liquid -= 1
           current += char
-        # Track quote boundaries
-        elsif ['"', "'"].include?(char) && !in_quotes && in_liquid.zero?
+        elsif char == '"' && !in_quotes
           in_quotes = true
           quote_char = char
           current += char
-        elsif char == quote_char && in_quotes
+        elsif char == quote_char
           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?
+          tokens << current
           current = ""
         else
           current += char
         end
       end
-      tokens << current unless current.empty?
+      tokens.reject!(&:empty?)
 
-      # First token is URL, remaining tokens may be title or archive parameter
-      result = {
-        url: tokens.shift,
-        title: nil,
-        archive: nil
-      }
+      result = {}
+      result[:url] = tokens.shift
 
-      # Process remaining tokens
+      title_tokens = []
       tokens.each do |token|
         if token.start_with?("archive:")
-          result[:archive] = token.sub(/^archive:/, "")
+          result[:archive] = token.delete_prefix("archive:")
         else
-          # Accumulate title tokens
-          result[:title] = result[:title].nil? ? token : "#{result[:title]} #{token}"
+          title_tokens << token
         end
       end
+      result[:title] = title_tokens.join(" ") unless title_tokens.empty?
 
       result
     end
@@ -141,9 +126,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 +135,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 +149,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)
     end
 
     # Build template variables hash for rendering
@@ -183,19 +161,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 +179,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_tag.rb

@@ -33,53 +33,35 @@ module JekyllHighlightCards
   #   {% polaroid /img.jpg link="https://example.com" image_link="https://other.com" %}
   class PolaroidTag < Liquid::Tag
     include ArchiveHelper
-    include DimensionParser
     include ExpressionEvaluator
     include TemplateRenderer
 
-    # Initialize the tag
-    #
-    # @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 polaroid tag
     #
     # @param context [Liquid::Context] the Liquid rendering context
     # @return [String] rendered HTML
     def render(context)
-      # Parse markup
       params = parse_markup(@markup, context)
 
-      # Validate required image_url
-      raise ArgumentError, "polaroid tag requires an image URL" if params[:image_url].nil? || params[:image_url].empty?
-
-      # Parse size parameter if present
-      width, height = parse_dimensions(params[:size]) if params[:size]
+      raise ArgumentError, "polaroid tag requires an image URL" if params.fetch(:image_url).empty?
 
-      # Determine link URL (defaults to image URL)
-      # Track if link was explicitly provided
-      explicit_link = !params[:link].nil? && !params[:link].empty?
-      link_url = params[:link] || params[:image_url]
+      width, height = DimensionParser.parse_dimensions(params[:size])
 
-      # Determine image link URL (can be overridden by image_link parameter)
-      # If image_link is provided, use it; otherwise use the standard link_url
-      image_link_url = if params[:image_link] && !params[:image_link].empty?
-                         params[:image_link]
-                       else
+      explicit_link = !params[:link].to_s.empty?
+      link_url = if params[:link].to_s.empty?
+                   params.fetch(:image_url)
+                 else
+                   params.fetch(:link)
+                 end
+      image_link_url = if params[:image_link].to_s.empty?
                          link_url
+                       else
+                         params.fetch(:image_link)
                        end
+      archive_url = resolve_archive(params[:archive], link_url)
 
-      # Resolve archive URL (archives the link URL, not the image)
-      archive_url = resolve_archive(params[:archive], context, link_url)
-
-      # Build template variables
       variables = build_template_variables(
-        params[:image_url],
+        params.fetch(:image_url),
         width,
         height,
         params[:title],
@@ -90,11 +72,7 @@ module JekyllHighlightCards
         archive_url
       )
 
-      # Get site from context
-      site = context.registers[:site]
-
-      # Render template
-      render_template(site, "polaroid", variables)
+      render_template(context.registers[:site], "polaroid", variables)
     end
 
     private
@@ -105,8 +83,6 @@ module JekyllHighlightCards
     # @param context [Liquid::Context] the Liquid context
     # @return [Hash] parsed parameters
     def parse_markup(markup, context)
-      # Split by whitespace, keeping quoted strings and Liquid expressions together
-      # Handles escaped quotes (\") and backslashes (\\) within quoted strings
       tokens = []
       current = ""
       in_quotes = false
@@ -114,82 +90,67 @@ module JekyllHighlightCards
       in_liquid = 0
       escaped = false
 
-      markup.each_char do |char|
-        # Handle escape sequences when in quotes
+      # Trailing space flushes the final token through the whitespace branch
+      "#{markup} ".each_char do |char|
         if escaped
-          current += char # Add the escaped character directly
+          current += char
           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
+          next
         end
 
-        # Track Liquid expression boundaries
         if char == "{" && !in_quotes
           in_liquid += 1
           current += char
-        elsif char == "}" && !in_quotes && in_liquid.positive?
+        elsif char == "}" && in_liquid.positive?
           in_liquid -= 1
           current += char
-        # Track quote boundaries
-        elsif ['"', "'"].include?(char) && !in_quotes && in_liquid.zero?
+        elsif ['"', "'"].include?(char) && !in_quotes
           in_quotes = true
           quote_char = char
           current += char
-        elsif char == quote_char && in_quotes
+        elsif char == quote_char
           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?
+          tokens << current
           current = ""
         else
           current += char
         end
       end
-      tokens << current unless current.empty?
 
-      # First token is image URL (required)
       image_url_token = tokens.shift
-      image_url = evaluate_expression(image_url_token, context, allow_nil: false)
+      image_url = evaluate_expression(image_url_token, context)
 
-      # Parse remaining tokens as key=value pairs
       result = { image_url: image_url }
       tokens.each do |token|
-        next unless token =~ /^(\w+)=(.+)$/
+        next unless token =~ /\A(\w+)=(.+)\z/
 
         key = Regexp.last_match(1).to_sym
         value_token = Regexp.last_match(2)
-
-        # Evaluate value as Liquid expression
-        result[key] = evaluate_expression(value_token, context, allow_nil: true)
+        result[key] = evaluate_expression(value_token, context)
       end
 
       result
     end
 
-    # Resolve archive URL (may be explicit, auto-lookup, or opt-out)
+    # Resolve archive URL (may be explicit, auto-lookup, or opt-out).
+    # Named archive params are already Liquid-evaluated in parse_markup.
     #
     # @param source [String, nil] the archive source
-    # @param context [Liquid::Context] the Liquid context (unused but kept for consistency)
     # @param url [String] the target URL to archive
     # @return [String, nil] resolved archive URL
-    def resolve_archive(source, context, url)
-      # Check for explicit opt-out
-      return nil if source&.downcase == "none"
-
-      # Check for explicit archive URL
-      return evaluate_expression(source, context, allow_nil: true) if source && !source.empty?
-
-      # Auto-lookup if enabled (archives the link URL, not the image)
-      return archive_url_for(url) if archive_enabled?
+    def resolve_archive(source, url)
+      return nil if source && source.downcase == "none"
+      return source unless source.to_s.empty?
 
-      nil
+      archive_enabled? && archive_url_for(url)
     end
 
     # Build template variables hash for rendering
@@ -215,12 +176,12 @@ module JekyllHighlightCards
       explicit_link,
       archive_url
     )
-      # Only set link_display if link was explicitly provided (not defaulted to image)
-      link_display = explicit_link && link_url ? strip_protocol(link_url) : nil
+      link_display = strip_protocol(link_url) if explicit_link
+      escaped_title = CGI.escapeHTML(title.to_s)
+      escaped_title = "&nbsp;" if escaped_title.empty?
 
       {
         "image_url" => image_url,
-        "link_url" => link_url,
         "image_link_url" => image_link_url,
         "title" => title,
         "alt" => alt,
@@ -229,12 +190,12 @@ module JekyllHighlightCards
         "width" => width,
         "height" => height,
         "escaped_image_url" => CGI.escapeHTML(image_url),
-        "escaped_link_url" => link_url ? CGI.escapeHTML(link_url) : nil,
-        "escaped_image_link_url" => image_link_url ? CGI.escapeHTML(image_link_url) : nil,
-        "escaped_title" => title && !title.empty? ? CGI.escapeHTML(title) : "&nbsp;",
-        "escaped_alt" => alt && !alt.empty? ? CGI.escapeHTML(alt) : "",
-        "escaped_link_display" => link_display && !link_display.empty? ? CGI.escapeHTML(link_display) : "&nbsp;",
-        "escaped_archive_url" => archive_url ? CGI.escapeHTML(archive_url) : nil
+        "escaped_link_url" => CGI.escapeHTML(link_url),
+        "escaped_image_link_url" => CGI.escapeHTML(image_link_url),
+        "escaped_title" => escaped_title,
+        "escaped_alt" => CGI.escapeHTML(alt.to_s),
+        "escaped_link_display" => link_display && CGI.escapeHTML(link_display),
+        "escaped_archive_url" => archive_url && CGI.escapeHTML(archive_url)
       }
     end
 
@@ -243,7 +204,7 @@ module JekyllHighlightCards
     # @param url [String] the URL
     # @return [String] URL without protocol
     def strip_protocol(url)
-      url.sub(%r{^https?://}, "")
+      url.sub(%r{\Ahttps?://}, "")
     end
   end
 end

data/lib/jekyll-highlight-cards/template_renderer.rb

@@ -27,13 +27,14 @@ module JekyllHighlightCards
         template = Liquid::Template.parse(template_content)
         template.render(variables)
       rescue Errno::ENOENT, Errno::EACCES => e
-        raise TemplateRenderError, "Failed to read template '#{template_name}' at #{template_path}: #{e.message}"
+        raise TemplateRenderError, "Failed to read template '#{template_name}' at #{template_path}: #{e.class}: #{e}"
       rescue Encoding::InvalidByteSequenceError => e
-        raise TemplateRenderError, "Invalid encoding in template '#{template_name}' at #{template_path}: #{e.message}"
+        raise TemplateRenderError,
+              "Invalid encoding in template '#{template_name}' at #{template_path}: #{e.class}: #{e}"
       rescue Liquid::SyntaxError, Liquid::Error => e
-        raise TemplateRenderError, "Liquid error in template '#{template_name}': #{e.message}"
+        raise TemplateRenderError, "Liquid error in template '#{template_name}': #{e.class}: #{e}"
       rescue StandardError => e
-        raise TemplateRenderError, "Unexpected error rendering template '#{template_name}': #{e.message}"
+        raise TemplateRenderError, "Unexpected error rendering template '#{template_name}': #{e.class}: #{e}"
       end
     end
 
@@ -57,6 +58,19 @@ module JekyllHighlightCards
       find_gem_template(relative_path)
     end
 
+    # Verify template path is safe (within allowed directory)
+    #
+    # @param allowed_dir [String] the allowed base directory
+    # @param template_path [String] the template path to check
+    # @return [String, nil] template path if safe, nil otherwise
+    def safe_template_path(allowed_dir, template_path)
+      return nil unless File.exist?(template_path)
+
+      expanded_dir = File.expand_path(allowed_dir)
+      expanded_path = File.expand_path(template_path)
+      template_path if expanded_path.start_with?(expanded_dir)
+    end
+
     private
 
     # Validate template name to prevent path traversal attacks
@@ -76,9 +90,11 @@ module JekyllHighlightCards
     # @param relative_path [String] relative path to template
     # @return [String, nil] path to template or nil
     def find_user_template(site, relative_path)
-      return nil unless site&.source
+      source = site&.source
+      # Empty source would File.join to "/_includes/..." — skip it explicitly.
+      return nil unless source.is_a?(String) && !source.empty?
 
-      includes_dir = File.join(site.source, "_includes")
+      includes_dir = File.join(source, "_includes")
       template_path = File.join(includes_dir, relative_path)
 
       safe_template_path(includes_dir, template_path)
@@ -95,19 +111,5 @@ module JekyllHighlightCards
 
       safe_template_path(includes_dir, template_path)
     end
-
-    # Verify template path is safe (within allowed directory)
-    #
-    # @param allowed_dir [String] the allowed base directory
-    # @param template_path [String] the template path to check
-    # @return [String, nil] template path if safe, nil otherwise
-    def safe_template_path(allowed_dir, template_path)
-      return nil unless File.exist?(template_path)
-
-      expanded_dir = File.expand_path(allowed_dir)
-      expanded_path = File.expand_path(template_path)
-
-      expanded_path.start_with?(expanded_dir) ? template_path : nil
-    end
   end
 end

data/lib/jekyll-highlight-cards/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JekyllHighlightCards
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-highlight-cards
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Texarkanine
@@ -63,6 +63,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: mutant
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: mutant-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -139,28 +167,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: simplecov-cobertura
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement