jekyll-webmention_io 3.3.6 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 020334fc76fba2718d1567fc7938e4b09d3f9612023f32be752f41b88ded0fd9
-  data.tar.gz: bf9f07dd3cb7bc2fe266e92fab05f5122125fdf4012272e576d1095cf8a9cfde
+  metadata.gz: '09dd03eeea574cdb024da147de7b2be165209a645a600aa709a650975b10d1b0'
+  data.tar.gz: 8493598855950605e57eb6142fa4e4a9e3f9b5b09323b100ed6823192ef3ece1
 SHA512:
-  metadata.gz: 1876c839ad26beae83a09d2a41d066fcd2187d3914c2c5b3086a3582a878f0b90dd2f46a2929efb0cf51d71ef106cf3459a7016668d5b163a03d4e8e7c8be97e
-  data.tar.gz: e33a2f9291ea21f7c83b8e558b8f0c3e7b2a179442b4675b7d46c00b3df8300e553b039451e5731455f2662f1875a85b34cd62ac63f8441f0c97072d497fd984
+  metadata.gz: de0de587f76d245329a31d2800b7e9d4e53bfc7bbdf318e3adeaef0ade095c2ae865e670510e18d0ca77a32398f9eb7060b9a6acbf2afb78a4d62708576ab015
+  data.tar.gz: d3113c40d8d9674f5b842ce2f2ce777d33cfe3abab46ee1dc97474f2eb0788ea1cd7f8c60699dc0dcf10563cec3ac8963f3fc6715f64f0bfddabdba8b7455a53

data/lib/jekyll/commands/webmention.rb

@@ -26,28 +26,42 @@ module Jekyll
           WebmentionIO.log "msg", "Getting ready to send webmentions (this may take a while)."
 
           count = 0
+          max_attempts = WebmentionIO.max_attempts()
           cached_outgoing = WebmentionIO.get_cache_file_path "outgoing"
           if File.exist?(cached_outgoing)
             outgoing = WebmentionIO.load_yaml(cached_outgoing)
             outgoing.each do |source, targets|
               targets.each do |target, response|
                 # skip ones we’ve handled
-                next unless response == false
+                next unless response == false or response.instance_of? Integer
 
-                # convert protocol-less links
-                if target.index("//").zero?
-                  target = "http:#{target}"
-                end
+                # skip protocol-less links, we'll need to revisit this again later
+                next if target.index("//").zero?
+
+                # produce an escaped version of the target (in case of special
+                # characters, etc).
+                escaped = URI::Parser.new.escape(target);
 
                 # skip bad URLs
-                next unless WebmentionIO.uri_ok?(target)
+                next unless WebmentionIO.uri_ok?(escaped)
+
+                # give up if we've attempted this too many times
+                response = (response || 0) + 1
+
+                if ! max_attempts.nil? and response > max_attempts
+                  outgoing[source][target] = ""
+                  WebmentionIO.log "msg", "Giving up sending from #{source} to #{target}."
+                  next
+                else
+                  outgoing[source][target] = response
+                end
 
                 # get the endpoint
-                endpoint = WebmentionIO.get_webmention_endpoint(target)
+                endpoint = WebmentionIO.get_webmention_endpoint(escaped)
                 next unless endpoint
 
                 # get the response
-                response = WebmentionIO.webmention(source, target, endpoint)
+                response = WebmentionIO.webmention(source, target)
                 next unless response
 
                 # capture JSON responses in case site wants to do anything with them
@@ -60,9 +74,7 @@ module Jekyll
                 count += 1
               end
             end
-            if count.positive?
-              WebmentionIO.dump_yaml(cached_outgoing, outgoing)
-            end
+            WebmentionIO.dump_yaml(cached_outgoing, outgoing)
             WebmentionIO.log "msg", "#{count} webmentions sent."
           end # file exists (outgoing)
         end # def process

data/lib/jekyll/generators/compile_js.rb

@@ -18,7 +18,6 @@ module Jekyll
       end
     end
 
-    using StringInflection
     class CompileJS < Generator
       safe true
       priority :low
@@ -61,7 +60,7 @@ module Jekyll
       def add_webmention_types
         js_types = []
         WebmentionIO.types.each do |type|
-          js_types.push "'#{type}': '#{type.to_singular}'"
+          js_types.push "'#{type}': '#{ActiveSupport::Inflector.singularize(type)}'"
         end
         types_js = <<-EOF
           ;(function(window,JekyllWebmentionIO){

data/lib/jekyll/generators/queue_webmentions.rb

@@ -8,6 +8,8 @@
 #  This generator caches sites you mention so they can be mentioned
 #
 
+require "jsonpath"
+
 module Jekyll
   module WebmentionIO
     class QueueWebmentions < Generator
@@ -17,6 +19,7 @@ module Jekyll
       def generate(site)
         @site = site
         @site_url = site.config["url"].to_s
+        @syndication = site.config.dig("webmentions", "syndication")
 
         if @site.config['serving']
           Jekyll::WebmentionIO.log "msg", "Webmentions lookups are not run when running `jekyll serve`."
@@ -31,52 +34,180 @@ module Jekyll
           return
         end
 
-        if @site.config.dig("webmentions", "pause_lookups")
-          WebmentionIO.log "info", "Webmention lookups are currently paused."
-          return
-        end
+        compile_jsonpath_expressions() if ! @syndication.nil?
 
-        WebmentionIO.log "msg", "Beginning to gather webmentions you’ve made. This may take a while."
+        WebmentionIO.log "msg", "Collecting webmentions you’ve made. This may take a while."
 
         upgrade_outgoing_webmention_cache
 
-        posts = WebmentionIO.gather_documents(@site)
-
+        posts = WebmentionIO.gather_documents(@site).select { |p| ! p.data["draft"] }
         gather_webmentions(posts)
       end
 
       private
 
+      def compile_jsonpath_expressions()
+        @syndication.each do | target, config |
+          next if ! config.key? "response_mapping"
+
+          mapping = config["response_mapping"]
+
+          mapping.clone.each do | key, pattern |
+            begin
+              mapping[key] = JsonPath.new(pattern)
+            rescue StandardError => e
+              WebmentionIO.log "error", "Ignoring invalid JsonPath expression #{pattern}: #{e}"
+
+              mapping.delete(key)
+            end
+          end
+        end
+      end
+
+      def combine_values(a, b)
+        return case [ a.instance_of?(Array), b.instance_of?(Array) ]
+          when [ false, false ]
+            [ a, b ]
+          when [ false, true ]
+            [ a ] + b
+          when [ true, false ]
+            a << b
+          when [ true, true ]
+            a + b
+        end
+      end
+
+      def process_syndication(post, target, response)
+        # If this is a syndication target, and we have a response,
+        # and the syndication entry contains a response mapping, then
+        # go through that map and store the selected values into
+        # the page front matter.
+
+        response = JSON.generate(response)
+
+        target["response_mapping"].each do |key, pattern|
+          result = pattern.on(response)
+
+          if ! result
+            WebmentionIO.log "msg", "The path #{skey} doesn't exist in the response from #{target['endpoint']} for #{uri}"
+            next
+          elsif result.length == 1
+            result = result.first
+          end
+
+          if post.data[key].nil?
+            post.data[key] = result
+          else
+            post.data[key] = combine_values(post.data[key], result)
+          end
+        end
+      end
+
+      def get_collection_for_post(post)
+        @site.collections.each do |name, collection|
+          next if name == "posts"
+
+          return collection if collection.docs.include? post
+        end
+
+        return nil
+      end
+
+      def get_syndication_target(uri)
+        return nil if @syndication.nil?
+
+        @syndication.values.detect { |t| t["endpoint"] == uri }
+      end
+
       def gather_webmentions(posts)
         webmentions = WebmentionIO.read_cached_webmentions "outgoing"
 
         posts.each do |post|
-          uri = File.join(@site_url, post.url)
+          # Collect potential outgoing webmentions in this post.
           mentions = get_mentioned_uris(post)
-          if webmentions.key? uri
-            mentions.each do |mentioned_uri, response|
-              unless webmentions[uri].key? mentioned_uri
-                webmentions[uri][mentioned_uri] = response
+
+          mentions.each do |mentioned_uri, response|
+            # If this webmention was a product of a syndication instruction,
+            # this goes back into the configuration and pulls that syndication
+            # target config out.
+            #
+            # If this is just a normal webmention, this will return nil.
+            target = get_syndication_target(mentioned_uri)
+
+            fulluri = File.join(@site_url, post.url)
+            shorturi = post.data["shorturl"] || fulluri
+
+            # Old cached responses might use either the full or short URIs so
+            # we need to check for both.
+            cached_response =
+              webmentions.dig(shorturi, mentioned_uri) ||
+              webmentions.dig(fulluri, mentioned_uri)
+
+            if cached_response.nil?
+              if ! target.nil?
+                uri = target["shorturl"] ? shorturi : fulluri
+
+                if target.key? "fragment"
+                  uri += "#" + target["fragment"]
+                end
+              else
+                uri = fulluri
               end
+
+              webmentions[uri] ||= {}
+              webmentions[uri][mentioned_uri] = response
+            elsif ! target.nil? and target.key? "response_mapping"
+              process_syndication(post, target, cached_response)
             end
-          else
-            webmentions[uri] = mentions
           end
         end
 
-        WebmentionIO.cache_webmentions "outgoing", webmentions
+        # This check is moved down here because we still need the steps
+        # above to populate frontmatter during the site build, even
+        # if we're not going to modify the webmention cache.
+
+        if @site.config.dig("webmentions", "pause_lookups")
+          WebmentionIO.log "info", "Webmention lookups are currently paused."
+          return
+        else
+          WebmentionIO.cache_webmentions "outgoing", webmentions
+        end
       end
 
       def get_mentioned_uris(post)
+        collection = get_collection_for_post(post)
+
         uris = {}
+
+        syndication_targets = []
+        syndication_targets += post.data["syndicate_to"] || []
+
+        if ! collection.nil?
+          syndication_targets += collection.metadata["syndicate_to"] || []
+        end
+
+        syndication_targets.each do |endpoint|
+          if @syndication.key? endpoint
+            uris[@syndication[endpoint]["endpoint"]] = false
+          else
+            WebmentionIO.log "msg", "Found reference to syndication endpoint \"#{endpoint}\" without matching entry in configuration."
+          end
+        end
+
         if post.data["in_reply_to"]
           uris[post.data["in_reply_to"]] = false
         end
-        post.content.scan(/(?:https?:)?\/\/[^\s)#\[\]{}<>%|\^"]+/) do |match|
+
+        if post.data["bookmark_of"]
+          uris[post.data["bookmark_of"]] = false
+        end
+
+        post.content.scan(/(?:https?:)?\/\/[^\s)#\[\]{}<>%|\^"']+/) do |match|
           unless uris.key? match
             uris[match] = false
           end
         end
+
         return uris
       end
 

data/lib/jekyll/tags/webmention.rb

@@ -11,7 +11,6 @@ require "htmlbeautifier"
 
 module Jekyll
   module WebmentionIO
-    using StringInflection
     class WebmentionTag < Liquid::Tag
       def initialize(tag_name, text, tokens)
         super
@@ -50,7 +49,7 @@ module Jekyll
         if !WebmentionIO.types.include? type
           WebmentionIO.log "warn", "#{type} are not extractable"
         else
-          type = type.to_singular
+          type = ActiveSupport::Inflector.singularize(type)
           WebmentionIO.log "info", "Searching #{webmentions.length} webmentions for type==#{type}"
           if webmentions.is_a? Hash
             webmentions = webmentions.values

data/lib/jekyll/webmention_io/version.rb

@@ -2,6 +2,6 @@
 
 module Jekyll
   module WebmentionIO
-    VERSION = "3.3.6"
+    VERSION = "4.0.0"
   end
 end

data/lib/jekyll/webmention_io/webmention_item.rb

@@ -50,20 +50,6 @@ module Jekyll
         @content = determine_content
       end
 
-      def markdownify(string)
-        @converter ||= @site.find_converter_instance(Jekyll::Converters::Markdown)
-
-        if string
-          string = @converter.convert(string.to_s)
-          unless string.start_with?("<p")
-            string = string.sub(/^<[^>]+>/, "<p>").sub(/<\/[^>]+>$/, "</p>")
-          end
-          string.strip
-        else
-          string
-        end
-      end
-
       def determine_uri
         @raw["data"]["url"] || @raw["source"]
       end
@@ -164,13 +150,11 @@ module Jekyll
       end
 
       def determine_content
-        content = if %w(post reply link).include? @type
-                    @raw.dig("data", "content")
-                  else
-                    @raw.dig("activity", "sentence_html")
-                  end
-
-        markdownify(content)
+        if %w(post reply link).include? @type
+          @raw.dig("data", "content")
+        else
+          @raw.dig("activity", "sentence_html")
+        end
       end
     end
   end

data/lib/jekyll/webmention_io.rb

@@ -15,15 +15,30 @@ require "json"
 require "net/http"
 require "uri"
 require "openssl"
-require "string_inflection"
+require "active_support"
+require "indieweb/endpoints"
 require "webmention"
 
 module Jekyll
   module WebmentionIO
+    module UriState
+      UNSUPPORTED = "unsupported"
+      ERROR = "error"
+      FAILURE = "failure"
+      SUCCESS = "success"
+    end
+
+    module UriPolicy
+      BAN = "ban"
+      IGNORE = "ignore"
+      RETRY = "retry"
+    end
+
     class << self
       # define simple getters and setters
       attr_reader :config, :jekyll_config, :cache_files, :cache_folder,
-                  :file_prefix, :types, :supported_templates, :js_handler
+                  :file_prefix, :types, :supported_templates, :js_handler,
+                  :uri_whitelist, :uri_blacklist
       attr_writer :api_suffix
     end
 
@@ -68,6 +83,18 @@ module Jekyll
       end
 
       @js_handler = WebmentionIO::JSHandler.new(site)
+
+      @uri_whitelist = @config
+        .fetch("bad_uri_policy", {})
+        .fetch("whitelist", [])
+        .clone
+        .insert(-1, "^https?://webmention.io/")
+        .map { |expr| Regexp.new(expr) }
+
+      @uri_blacklist = @config
+        .fetch("bad_uri_policy", {})
+        .fetch("blacklist", [])
+        .map { |expr| Regexp.new(expr) }
     end
 
     # Setter
@@ -80,6 +107,10 @@ module Jekyll
       Jekyll.sanitized_path(@cache_folder, "#{@file_prefix}#{filename}")
     end
 
+    def self.max_attempts()
+      @config.dig("max_attempts")
+    end
+
     def self.get_cache_file_path(key)
       @cache_files[key] || false
     end
@@ -209,30 +240,45 @@ module Jekyll
     def self.get_webmention_endpoint(uri)
       # log "info", "Looking for webmention endpoint at #{uri}"
       begin
-        endpoint = Webmention::Client.supports_webmention?(uri)
+        endpoint = IndieWeb::Endpoints.get(uri)[:webmention]
         unless endpoint
           log("info", "Could not find a webmention endpoint at #{uri}")
-          uri_is_not_ok(uri)
+          update_uri_cache(uri, UriState::UNSUPPORTED)
         end
       rescue StandardError => e
         log "info", "Endpoint lookup failed for #{uri}: #{e.message}"
-        uri_is_not_ok(uri)
+        update_uri_cache(uri, UriState::FAILURE)
         endpoint = false
       end
       endpoint
     end
 
-    def self.webmention(source, target, endpoint)
+    def self.webmention(source, target)
       log "info", "Sending webmention of #{target} in #{source}"
       # return `curl -s -i -d \"source=#{source}&target=#{target}\" -o /dev/null #{endpoint}`
-      mention = Webmention::Client.send_mention(endpoint, source, target, true)
-      case mention.response
-      when Net::HTTPOK, Net::HTTPCreated, Net::HTTPAccepted
+      response = Webmention.send_webmention(source, target)
+
+      case response.code
+      when 200, 201, 202
         log "info", "Webmention successful!"
-        mention.response.body
+        update_uri_cache(target, UriState::SUCCESS)
+        response.body
       else
-        log "info", mention.inspect
+        log "info", response.inspect
         log "info", "Webmention failed, but will remain queued for next time"
+
+        if response.body
+          begin
+            body = JSON.parse(response.body)
+
+            if body.key? "error"
+              log "msg", "Endpoint returned error: #{body['error']}"
+            end
+          rescue
+          end
+        end
+
+        update_uri_cache(target, UriState::ERROR)
         false
       end
     end
@@ -289,12 +335,12 @@ module Jekyll
           redirect_to = redirect_to.relative? ? "#{original_uri.scheme}://#{original_uri.host}" + redirect_to.to_s : redirect_to.to_s
           return get_uri_source(redirect_to, redirect_limit - 1, original_uri)
         else
-          uri_is_not_ok(uri)
+          update_uri_cache(uri, UriState::FAILURE)
           return false
         end
       else
         log("warn", "too many redirects for #{original_uri}") if original_uri
-        uri_is_not_ok(uri)
+        update_uri_cache(uri, UriState::FAILURE)
         return false
       end
     end
@@ -345,37 +391,176 @@ module Jekyll
         return response
       rescue *EXCEPTIONS => e
         log "warn", "Got an error checking #{uri}: #{e}"
-        uri_is_not_ok(uri)
+        update_uri_cache(uri, UriState::FAILURE)
         return false
       end
     end
 
-    # Cache bad URLs for a bit
-    def self.uri_is_not_ok(uri)
+    # Given the provided state value (see UriState), retrieve the policy
+    # entry.  If no entry exists, return a new default entry that
+    # indicates unlimited retries.
+    def self.get_bad_uri_policy_entry(state)
+      settings = @config.fetch("bad_uri_policy", {})
+
+      default_policy = { "policy" => UriPolicy::RETRY }
+      policy_entry = nil
+
+      # Retrieve the policy entry, the default entry, or the canned default
+      policy_entry = settings.fetch(state) {
+        settings.fetch("default", default_policy)
+      }
+
+      # Convert shorthand entry to full policy record
+      if policy_entry.instance_of? String
+        policy_entry = { "policy" => policy_entry }
+      end
+
+      if policy_entry["policy"] == UriPolicy::RETRY and ! policy_entry.key? "retry_delay"
+        # If this is a retry policy and no delay is set, set up the default
+        # delay policy.  This inherits from the legacy cache_bad_uris_for
+        # setting to enable backward compatibility with older configurations.
+        #
+        # We do this here to make the rule enforcement logic a little tidier.
+
+        policy_entry["retry_delay"] = [ @config.fetch("cache_bad_uris_for", 1) * 24 ]
+      end
+
+      return policy_entry
+    end
+
+    # Retrieve the bad_uris cache entry for the given URI.  This method
+    # takes the cache and a URI instance (i.e. parsing must already be done).
+    #
+    # If the URI has no entry in the cache, returns nil and *not* a default
+    # entry.
+    def self.get_bad_uri_cache_entry(bad_uris, uri)
+      return nil if ! bad_uris.key? uri.host
+
+      entry = bad_uris[uri.host].clone
+
+      if entry.instance_of? String
+        # Older version of the bad URL cache, convert to new format with some
+        # "sensible" defaults.
+
+        entry = {
+          "state" => UriState::UNSUPPORTED,
+          "last_checked" => DateTime.parse(entry).to_time,
+          "attempts" => 1
+        }
+      else
+        # Otherwise, parse the check time into a real Time object before
+        # returning the entry.
+        #
+        # We convert to a Time object so we can do arithmetic on it later.
+
+        entry["last_checked"] = DateTime.parse(entry["last_checked"]).to_time
+      end
+
+      return entry
+    end
+
+    # Update the URI cache for this entry.
+    #
+    # If the state is UriState.SUCCESS or the URI is whitelisted or
+    # blacklisted, we delete any existing entries since no policy will
+    # apply.  This ensures we reset the policy state when a webmention
+    # succeeds.
+    #
+    # Otherwise, we either create or update an entry for the URI, recording
+    # the state and the current attempt counter.
+    def self.update_uri_cache(uri, state)
       uri = URI::Parser.new.parse(uri.to_s)
-      # Never cache webmention.io in here
-      return if uri.host == "webmention.io"
+      uri_str = uri.to_s
 
       cache_file = @cache_files["bad_uris"]
       bad_uris = load_yaml(cache_file)
-      bad_uris[uri.host] = Time.now.to_s
+
+      if state == UriState::SUCCESS or
+          @uri_whitelist.any? { |expr| expr.match uri_str } or
+          @uri_blacklist.any? { |expr| expr.match uri_str }
+
+        return if bad_uris.delete(uri.host).nil?
+      else
+        old_entry = get_bad_uri_cache_entry(bad_uris, uri) || {}
+
+        bad_uris[uri.host] = {
+          "state" => state,
+          "attempts" => old_entry.fetch("attempts", 0) + 1,
+          "last_checked" => Time.now.to_s
+        }
+      end
+
       dump_yaml(cache_file, bad_uris)
     end
 
+    # Check if we should attempt to send a webmention to the given URI based
+    # on the error handling policy and the last attempt.
     def self.uri_ok?(uri)
       uri = URI::Parser.new.parse(uri.to_s)
       now = Time.now.to_s
+      uri_str = uri.to_s
+
+      # If the URI is whitelisted, it's always ok!
+      return true if @uri_whitelist.any? { |expr| expr.match uri_str }
+
+      # If the URI is blacklisted, it's never ok!
+      return false if @uri_blacklist.any? { |expr| expr.match uri_str }
+
       bad_uris = load_yaml(@cache_files["bad_uris"])
-      if bad_uris.key? uri.host
-        last_checked = DateTime.parse(bad_uris[uri.host])
-        cache_bad_uris_for = @config["cache_bad_uris_for"] || 1 # in days
-        recheck_at = last_checked.next_day(cache_bad_uris_for).to_s
-        return false if recheck_at > now
+      entry = get_bad_uri_cache_entry(bad_uris, uri)
+
+      # If the entry isn't in our cache yet, then it's ok.
+      return true if entry.nil?
+
+      # Okay, the last time we tried to send a webmention to this URI it
+      # failed, so depending on what happened and the policy, we need to
+      # decide what to do.
+      #
+      # First pull the retry policy given the type of the last error for the URI
+      policy_entry = get_bad_uri_policy_entry(entry["state"])
+      policy = policy_entry["policy"]
+
+      if policy == UriPolicy::BAN
+        return false
+      elsif policy == UriPolicy::IGNORE
+        return true
+      elsif policy == UriPolicy::RETRY
+        now = Time.now
+
+        attempts = entry["attempts"]
+        max_attempts = policy_entry["max_attempts"]
+
+        if ! max_attempts.nil? and attempts >= max_attempts
+          # If there's a retry limit and we've hit it, URI is not ok.
+          log "msg", "Skipping #{uri}, attempted #{attempts} times and max is #{max_attempts}"
+
+          return false
+        end
+
+        retry_delay = policy_entry["retry_delay"]
+
+        # Sneaky trick.  By clamping to the array length, the last entry in
+        # the retry_delay list is used for all remaining retries.
+        delay = retry_delay[(attempts - 1).clamp(0, retry_delay.length - 1)]
+
+        recheck_at = (entry["last_checked"] + delay * 3600)
+
+        if recheck_at.to_r > now.to_r
+          log "msg", "Skipping #{uri}, next attempt will happen after #{recheck_at}"
+
+          return false
+        end
+      else
+        log "error", "Invalid bad URI policy type: #{policy}"
       end
+
       return true
     end
 
-    private_class_method :get_http_response, :uri_is_not_ok
+    private_class_method :get_http_response,
+                         :get_bad_uri_policy_entry,
+                         :get_bad_uri_cache_entry,
+                         :update_uri_cache
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-webmention_io
 version: !ruby/object:Gem::Version
-  version: 3.3.6
+  version: 4.0.0
 platform: ruby
 authors:
 - Aaron Gustafson
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-22 00:00:00.000000000 Z
+date: 2023-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -48,30 +48,42 @@ dependencies:
   name: openssl
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
-  name: string_inflection
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '7.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.4.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '7.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.4.3
 - !ruby/object:Gem::Dependency
   name: htmlbeautifier
   requirement: !ruby/object:Gem::Requirement
@@ -106,14 +118,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.6
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: jsonpath
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.6
+        version: 1.0.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -148,14 +174,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -276,7 +302,7 @@ homepage: https://github.com/aarongustafson/jekyll-webmention_io
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -291,8 +317,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: A Jekyll plugin for sending & receiving webmentions via Webmention.io.
 test_files: []