jekyll-highlight-cards 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e7d4bb8027142ccb1dbf7e0327098460eb49fda5f10fa2619efeb9053fa1359
-  data.tar.gz: 9971cb5b3a34a9bfbfaf06539e973df20c5951fb5bac39649378c4909a03a759
+  metadata.gz: 48a4ccd9a729f6d5db3c458bdf9311abe63b595b370cb6577994e7c0da53d763
+  data.tar.gz: 4805a92c237413bcc17ddd0c2d1166bd5c7e606a9c2287b8f6e99939d42d6639
 SHA512:
-  metadata.gz: d1183485eba6958f3d328b693207cfbccfd0dcef3da163511332c0ad16b39c30416b8c1bb41e767b9dc8ddee5d761f92ae26bb7b56f18ada1b5d1ef8a5bbfa21
-  data.tar.gz: 9d62f2b98e4923cdd73a75719718d92dd40b235dd0c61982e4222bc4a1f525b9593ddef3b10f3485ea56f30ad300e0be6310f8a6ccbfcc6ac50c1448092cd8d4
+  metadata.gz: 3c01b9b3dc7adb48b1e20a5dce6af56f0ba2e0e1db4e490c7024c066a8ee8cf3dc9da0e3f65637aec448ecd3bd67b39169f4719536f0fd27352ab46a76303a95
+  data.tar.gz: 4d88a809394b5b4d77a73f385358d05c532ee38f0c22f26dada841b2c5aff61915fc4486bb61ab83ffc5c282b2b1226b7fde8c75c4654260f280e6e83d76193a

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [2.2.0](https://github.com/Texarkanine/jekyll-highlight-cards/compare/v2.1.0...v2.2.0) (2026-08-02)
+
+
+### Features
+
+* freeze-archives command and highlight_cards.noarchive skips ([#56](https://github.com/Texarkanine/jekyll-highlight-cards/issues/56)) ([a50d109](https://github.com/Texarkanine/jekyll-highlight-cards/commit/a50d109807a0709c47aeebab021b5b49bbd35d8f))
+
+
+### Bug Fixes
+
+* **archive:** skip non-archivable URLs [[#53](https://github.com/Texarkanine/jekyll-highlight-cards/issues/53)] ([#54](https://github.com/Texarkanine/jekyll-highlight-cards/issues/54)) ([928e6d8](https://github.com/Texarkanine/jekyll-highlight-cards/commit/928e6d8268318dbca85ec5d8143b1a1b67f6275a))
+
 ## [2.1.0](https://github.com/Texarkanine/jekyll-highlight-cards/compare/v2.0.0...v2.1.0) (2026-07-19)
 
 

data/README.md

@@ -11,6 +11,7 @@ A Jekyll plugin providing styled card components for links and images with Inter
 - **`{% polaroid %}`** - Polaroid-style image cards with titles, links, and archive support
 - **Markdown Image Sizing** - Extended syntax for image dimensions: `![alt](image.jpg =300x200)`
 - **Internet Archive Integration** - Automatic lookup and archival for both tags
+- **`jekyll freeze-archives`** - Opt-in command to freeze archive URLs into source
 - **Customizable** - Override HTML templates and CSS styles
 
 ## Installation
@@ -148,6 +149,41 @@ Or in your shell config:
 export JEKYLL_HIGHLIGHT_CARDS_ARCHIVE=1
 ```
 
+| Flag | Description |
+|------|-------------|
+| `JEKYLL_HIGHLIGHT_CARDS_ARCHIVE` | Enable build-time lookup to see if there is an IA snapshot available |
+| `JEKYLL_HIGHLIGHT_CARDS_ARCHIVE_SAVE` | Also submit the URL to SavePageNow (runs even when CDX already found a snapshot) |
+
+You can selectively skip archive attempts for URLs that match site-configured regexes. Patterns are matched against the full URL string; use anchors when needed.
+
+```yaml
+highlight_cards:
+  noarchive:
+    - ^https?://x\.com/.*
+    - \Ahttps://something\.example\.com/.*
+```
+
+### Freeze Archives Into Source
+
+To look up Internet Archive snapshots *once* (instead of on each build) and write them into your source tags, run the `freeze-archives` Jekyll subcommand:
+
+```bash
+# Rehearse first — reports planned edits, writes nothing
+bundle exec jekyll freeze-archives --dry-run
+
+# Write archive: / archive= into eligible tags
+bundle exec jekyll freeze-archives
+```
+
+Review the diff, then commit. The command does **not** commit for you, and it does **not** run as part of `jekyll build`.
+
+**How it differs from build-time lookup**
+
+- Invoking `freeze-archives` performs CDX lookup — you do **not** need `JEKYLL_HIGHLIGHT_CARDS_ARCHIVE=1`.
+- SavePageNow stays gated: set `JEKYLL_HIGHLIGHT_CARDS_ARCHIVE_SAVE=1` or pass `--save`.
+- Only **literal** http(s) URLs are frozen. Liquid targets like `{{ page.url }}` are skipped; build-time auto-lookup still covers those when enabled.
+- Tags that already have `archive:` / `archive=` / `archive:none` are left alone.
+
 ### CSS Styles
 
 **Default usage:**

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

@@ -17,14 +17,17 @@ module JekyllHighlightCards
     @archive_cache = {}
 
     class << self
-      attr_accessor :archive_cache
+      attr_accessor :archive_cache, :noarchive_regexp_cache
     end
 
     # Get archive URL for a given URL, with caching and optional submission
     #
     # @param url [String] the original URL to archive
+    # @param site [Jekyll::Site, nil] optional site for +highlight_cards.noarchive+ patterns
     # @return [String, nil] the archive URL, or nil if not found
-    def archive_url_for(url)
+    def archive_url_for(url, site: nil)
+      return nil unless archiveable_url?(url, site: site)
+
       ArchiveHelper.archive_cache[url] ||= begin
         archive_url = lookup_archive(url)
 
@@ -58,6 +61,51 @@ module JekyllHighlightCards
 
     private
 
+    # Whether +url+ is eligible for CDX lookup / SavePageNow submission.
+    #
+    # Requires an absolute http(s) URI with a host. Rejects Internet Archive
+    # hosts so Wayback / archive.org URLs are not re-submitted. Also rejects
+    # URLs matching any +highlight_cards.noarchive+ regex on +site+ config.
+    #
+    # @param url [String] candidate URL
+    # @param site [Jekyll::Site, nil] optional site for +highlight_cards.noarchive+
+    # @return [Boolean] true if the URL may be archived
+    def archiveable_url?(url, site: nil)
+      uri = URI.parse(url.to_s)
+      return false unless uri.is_a?(URI::HTTP) && uri.host
+      return false if %w[archive.org web.archive.org].include?(uri.host.downcase)
+      return false if noarchive_match?(url, site)
+
+      true
+    rescue URI::InvalidURIError
+      false
+    end
+
+    # Whether +url+ matches any +highlight_cards.noarchive+ pattern on +site+.
+    #
+    # @param url [String] candidate URL (full string matched)
+    # @param site [Jekyll::Site, nil]
+    # @return [Boolean]
+    # @raise [RegexpError] when a configured pattern is invalid
+    def noarchive_match?(url, site)
+      noarchive_patterns_for(site).any? { |pattern| pattern.match?(url.to_s) }
+    end
+
+    # Compile +highlight_cards.noarchive+ patterns from site config (memoized per site).
+    #
+    # @param site [Jekyll::Site, nil]
+    # @return [Array<Regexp>]
+    def noarchive_patterns_for(site)
+      return [] unless site
+
+      raw = site.config.dig("highlight_cards", "noarchive")
+      return [] if raw.nil? || Array(raw).empty?
+
+      cache = (ArchiveHelper.noarchive_regexp_cache ||= {})
+      cache_key = [site.object_id, raw]
+      cache[cache_key] ||= Array(raw).map { |pattern| Regexp.new(pattern.to_s) }
+    end
+
     # Look up the latest archived snapshot for a URL via Internet Archive CDX API
     #
     # @param url [String] the URL to look up

data/lib/jekyll-highlight-cards/commands/freeze_archives.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module JekyllHighlightCards
+  module Commands
+    # Opt-in Jekyll subcommand: +jekyll freeze-archives+
+    #
+    # Scans site source for archive-eligible +linkcard+ / +polaroid+ tags that
+    # lack an encoded archive, looks up Internet Archive, and surgically inserts
+    # successful hits into source. Does not run during +jekyll build+.
+    #
+    # @see https://jekyllrb.com/docs/plugins/commands/
+    class FreezeArchives < Jekyll::Command
+      class << self
+        # Register the +freeze-archives+ Mercenary subcommand
+        #
+        # @param prog [Mercenary::Program] the Jekyll CLI program
+        # @return [void]
+        def init_with_program(prog)
+          prog.command(:"freeze-archives") do |c|
+            c.syntax "freeze-archives [options]"
+            c.description "Freeze Internet Archive URLs into highlight-card source tags"
+
+            c.option "dry_run", "--dry-run", "Report planned edits without writing files"
+            c.option "save", "--save", "Enable SavePageNow when CDX has no snapshot"
+            c.option "config", "--config CONFIG_FILE[,CONFIG_FILE2,...]", Array,
+                     "Custom configuration file"
+            c.option "source", "-s", "--source SOURCE", "Custom source directory"
+
+            c.action do |_args, options|
+              process(options)
+            end
+          end
+        end
+
+        # Run freeze-archives against a configured site
+        #
+        # @param options [Hash] Mercenary/Jekyll options (+dry_run+, +save+, +source+, …)
+        # @return [Hash] summary counts +:frozen+, +:skipped+, +:miss+, +:written+
+        def process(options)
+          previous_save = ENV.fetch("JEKYLL_HIGHLIGHT_CARDS_ARCHIVE_SAVE", nil)
+          previous_log_level = Jekyll.logger.level
+          ENV["JEKYLL_HIGHLIGHT_CARDS_ARCHIVE_SAVE"] = "1" if options["save"]
+
+          site = Jekyll::Site.new(configuration_from_options(options))
+          # Hand-run tool: keep progress visible even if the site sets quiet: true
+          Jekyll.logger.log_level = :info unless options["quiet"]
+          site.read
+
+          summary = Runner.new(
+            dry_run: options["dry_run"],
+            logger: Jekyll.logger
+          ).run(site)
+
+          Jekyll.logger.info "freeze-archives:",
+                             "frozen=#{summary[:frozen]} skipped=#{summary[:skipped]} " \
+                             "miss=#{summary[:miss]} written=#{summary[:written]}"
+          summary
+        ensure
+          restore_save_env(previous_save, options)
+          Jekyll.logger.log_level = previous_log_level if previous_log_level
+        end
+
+        private
+
+        def restore_save_env(previous_save, options)
+          return unless options && options["save"]
+
+          if previous_save.nil?
+            ENV.delete("JEKYLL_HIGHLIGHT_CARDS_ARCHIVE_SAVE")
+          else
+            ENV["JEKYLL_HIGHLIGHT_CARDS_ARCHIVE_SAVE"] = previous_save
+          end
+        end
+      end
+
+      # Orchestrates locate → analyze → lookup → insert for one site
+      class Runner
+        include ArchiveHelper
+
+        def initialize(dry_run:, logger:)
+          @dry_run = dry_run
+          @logger = logger
+          @site = nil
+          @site_source = nil
+          @locator = JekyllHighlightCards::FreezeArchives::TagLocator.new
+          @inserter = JekyllHighlightCards::FreezeArchives::ArchiveInserter.new
+        end
+
+        # @param site [Jekyll::Site]
+        # @return [Hash] summary counts
+        def run(site)
+          @site = site
+          @site_source = site.source
+          @analyzer = JekyllHighlightCards::FreezeArchives::MarkupAnalyzer.new(site: site)
+          summary = { frozen: 0, skipped: 0, miss: 0, written: 0 }
+
+          source_files(site).each do |path|
+            process_file(path, summary)
+          end
+
+          summary
+        end
+
+        private
+
+        def source_files(site)
+          paths = site.pages.map { |page| resolve_source_path(site, page.path) }
+          site.collections.each_value do |collection|
+            paths.concat(collection.docs.map { |doc| resolve_source_path(site, doc.path) })
+          end
+
+          paths.compact.uniq.select do |path|
+            File.file?(path) && path.start_with?(site.source)
+          end
+        end
+
+        # Jekyll::Page#path is source-relative; Document#path is absolute.
+        def resolve_source_path(site, path)
+          return nil if path.to_s.empty?
+          return path if File.absolute_path?(path)
+
+          site.in_source_dir(path)
+        end
+
+        def process_file(path, summary)
+          content = File.read(path)
+          spans = @locator.locate(content)
+          return if spans.empty?
+
+          edits = []
+          spans.each do |span|
+            candidate = @analyzer.analyze(span[:tag], span[:markup])
+            unless candidate
+              summary[:skipped] += 1
+              next
+            end
+
+            target = candidate[:target_url]
+            @logger.info "freeze-archives:", "Looking up archive for #{target}"
+            archive_url = archive_url_for(target, site: @site)
+            unless archive_url
+              summary[:miss] += 1
+              @logger.info "freeze-archives:", "no archive for #{target}"
+              next
+            end
+
+            summary[:frozen] += 1
+            verb = @dry_run ? "would freeze" : "frozen"
+            @logger.info "freeze-archives:",
+                         "#{verb}: #{relative_source_path(path)} ← #{archive_url}"
+            edits << { span: span, archive_url: archive_url }
+          end
+
+          return if edits.empty? || @dry_run
+
+          # Apply from end of file so earlier ranges stay valid
+          updated = content
+          edits.sort_by { |e| -e[:span][:range].begin }.each do |edit|
+            updated = @inserter.insert(updated, edit[:span], edit[:archive_url])
+          end
+
+          return if updated == content
+
+          File.write(path, updated)
+          summary[:written] += 1
+        end
+
+        def relative_source_path(path)
+          source = @site_source.to_s
+          return path if source.empty?
+
+          prefix = source.end_with?("/") ? source : "#{source}/"
+          path.start_with?(prefix) ? path.delete_prefix(prefix) : path
+        end
+      end
+    end
+  end
+end

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

@@ -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

@@ -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

@@ -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/linkcard_markup.rb

@@ -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

@@ -62,62 +62,7 @@ module JekyllHighlightCards
     # @param markup [String] the tag markup
     # @return [Hash] parsed components
     def split_markup(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_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?)
-
-      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
+      LinkcardMarkup.split(markup)
     end
 
     # Resolve URL from token (may be Liquid expression or literal)
@@ -151,7 +96,7 @@ module JekyllHighlightCards
       # Check for explicit archive URL
       return evaluate_expression(source, context) if source && !source.empty?
 
-      archive_enabled? && archive_url_for(url)
+      archive_enabled? && archive_url_for(url, site: context.registers[:site])
     end
 
     # Build template variables hash for rendering

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

@@ -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

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

@@ -58,7 +58,12 @@ module JekyllHighlightCards
                        else
                          params.fetch(:image_link)
                        end
-      archive_url = resolve_archive(params[:archive], link_url)
+      archive_url = resolve_archive(
+        params[:archive],
+        link_url,
+        site: context.registers[:site],
+        explicit_link: explicit_link
+      )
 
       variables = build_template_variables(
         params.fetch(:image_url),
@@ -83,58 +88,13 @@ module JekyllHighlightCards
     # @param context [Liquid::Context] the Liquid context
     # @return [Hash] parsed parameters
     def parse_markup(markup, context)
-      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_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
-
-      image_url_token = tokens.shift
-      image_url = evaluate_expression(image_url_token, context)
+      parsed = PolaroidMarkup.parse(markup)
 
-      result = { image_url: image_url }
-      tokens.each do |token|
-        next unless token =~ /\A(\w+)=(.+)\z/
+      result = { image_url: evaluate_expression(parsed[:image_url], context) }
+      parsed.each do |key, value|
+        next if key == :image_url
 
-        key = Regexp.last_match(1).to_sym
-        value_token = Regexp.last_match(2)
-        result[key] = evaluate_expression(value_token, context)
+        result[key] = evaluate_expression(value, context)
       end
 
       result
@@ -145,12 +105,15 @@ module JekyllHighlightCards
     #
     # @param source [String, nil] the archive source
     # @param url [String] the target URL to archive
+    # @param site [Jekyll::Site, nil] site for +highlight_cards.noarchive+
+    # @param explicit_link [Boolean] whether +link=+ was provided (self-link is not an archive target)
     # @return [String, nil] resolved archive URL
-    def resolve_archive(source, url)
+    def resolve_archive(source, url, site: nil, explicit_link: true)
       return nil if source && source.downcase == "none"
       return source unless source.to_s.empty?
+      return nil unless explicit_link
 
-      archive_enabled? && archive_url_for(url)
+      archive_enabled? && archive_url_for(url, site: site)
     end
 
     # Build template variables hash for rendering

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

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

data/lib/jekyll-highlight-cards.rb

@@ -12,11 +12,17 @@ require_relative "jekyll-highlight-cards/dimension_parser"
 require_relative "jekyll-highlight-cards/expression_evaluator"
 require_relative "jekyll-highlight-cards/archive_helper"
 require_relative "jekyll-highlight-cards/template_renderer"
+require_relative "jekyll-highlight-cards/linkcard_markup"
+require_relative "jekyll-highlight-cards/polaroid_markup"
 
 # Require tags and hooks
 require_relative "jekyll-highlight-cards/linkcard_tag"
 require_relative "jekyll-highlight-cards/polaroid_tag"
 require_relative "jekyll-highlight-cards/image_sizing_hooks"
+require_relative "jekyll-highlight-cards/freeze_archives/markup_analyzer"
+require_relative "jekyll-highlight-cards/freeze_archives/tag_locator"
+require_relative "jekyll-highlight-cards/freeze_archives/archive_inserter"
+require_relative "jekyll-highlight-cards/commands/freeze_archives"
 
 # jekyll-highlight-cards: Styled card components for Jekyll
 #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-highlight-cards
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Texarkanine
@@ -223,10 +223,16 @@ files:
 - jekyll-highlight-cards.gemspec
 - lib/jekyll-highlight-cards.rb
 - lib/jekyll-highlight-cards/archive_helper.rb
+- lib/jekyll-highlight-cards/commands/freeze_archives.rb
 - lib/jekyll-highlight-cards/dimension_parser.rb
 - lib/jekyll-highlight-cards/expression_evaluator.rb
+- lib/jekyll-highlight-cards/freeze_archives/archive_inserter.rb
+- lib/jekyll-highlight-cards/freeze_archives/markup_analyzer.rb
+- lib/jekyll-highlight-cards/freeze_archives/tag_locator.rb
 - lib/jekyll-highlight-cards/image_sizing_hooks.rb
+- lib/jekyll-highlight-cards/linkcard_markup.rb
 - lib/jekyll-highlight-cards/linkcard_tag.rb
+- lib/jekyll-highlight-cards/polaroid_markup.rb
 - lib/jekyll-highlight-cards/polaroid_tag.rb
 - lib/jekyll-highlight-cards/template_renderer.rb
 - lib/jekyll-highlight-cards/version.rb