jekyll-highlight-cards 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14f9f3f5b5374e35f95524afc77c6edfc8a09469154924fa17859089b5df71c8
-  data.tar.gz: 896055006ef9a9ebe42e992c621ce0e666c487f8166be65b208ca7f173ef955d
+  metadata.gz: 48a4ccd9a729f6d5db3c458bdf9311abe63b595b370cb6577994e7c0da53d763
+  data.tar.gz: 4805a92c237413bcc17ddd0c2d1166bd5c7e606a9c2287b8f6e99939d42d6639
 SHA512:
-  metadata.gz: 1fe96dece9fb642150e35571f1b7e8887b1d91236a16ea367d434846b550141dd08780e4532642db2e9103607fd5af70ae484ff85a018e30e678105113c45ca3
-  data.tar.gz: 224ec98ce539b1f7a00b9b8707b6552638c07ddacb8ff6ff87c988b5bed74c66c9c9bfd67dfa08ddf18ac072518b7418690c6b54a93dc71a83364045dce9d0c4
+  metadata.gz: 3c01b9b3dc7adb48b1e20a5dce6af56f0ba2e0e1db4e490c7024c066a8ee8cf3dc9da0e3f65637aec448ecd3bd67b39169f4719536f0fd27352ab46a76303a95
+  data.tar.gz: 4d88a809394b5b4d77a73f385358d05c532ee38f0c22f26dada841b2c5aff61915fc4486bb61ab83ffc5c282b2b1226b7fde8c75c4654260f280e6e83d76193a

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # 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)
+
+
+### 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/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/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

@@ -17,30 +17,24 @@ 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
-        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
@@ -67,19 +61,60 @@ 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
     # @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 +125,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 +142,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/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/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