action_webhook 0.1.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54d0eddc17626872f1d795b8c25c4fda06719a1bfed4b185093c8803d442d2ad
-  data.tar.gz: ec2b67113640e9b1d7e4ddb397858a4d38724d01024f781b492906ed629dfc62
+  metadata.gz: 2063e93683fe64ce519f241843f17e33da9f29d671b965af97c0f97540a98ecc
+  data.tar.gz: 1f591bf9cfb727d9ab6e750338b708e4e24df2e782ea3f1a5096277f4311474d
 SHA512:
-  metadata.gz: 5635f2e1541ecf586c52a37df1fb03b6e11e71585255cdbef8a01be30323e1d7a53f7f0ab053ff98dd7a8f3bc6e4e5d95dfbd1b0c1b86b3238577aa13bde0459
-  data.tar.gz: e97e0940c7bf16f20d4c6457d115a2054494af9c17fd9957c3f5537774a45374ee1c395a228de33689edac80ba9f3e3b367e82baa2a972b178b3ac9df5ac719e
+  metadata.gz: 14ed8242d705d62f573fd884e83bc70479ed4397c4bb3fffd75fd178bdc929fe5d981c395abb99ab7d647c7f1aec3aeaf1685784b3d521e3e62ed2e073ee8c1c
+  data.tar.gz: 45c7362968926262d79f6dedb16f2391d30a2b64980e3a5d0116558360ee63fe416b54f33a17012b82e5b50d8a465a58d5f91e1b6fa1f05e185959a2ce547230

data/lib/action_webhook/base.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module ActionWebhook
   # Base class for defining and delivering webhooks
   #
@@ -24,11 +22,33 @@ module ActionWebhook
   #   # Send immediately
   #   UserWebhook.created(user).deliver_now
   #
-  #   # Send in background
+  #   # Send in background (uses default queue)
   #   UserWebhook.created(user).deliver_later
   #
+  #   # Send in background with specific queue
+  #   UserWebhook.created(user).deliver_later(queue: 'webhooks')
+  #
+  #   # Send in background with delay
+  #   UserWebhook.created(user).deliver_later(wait: 5.minutes)
+  #
+  #   # Send in background with specific queue and delay
+  #   UserWebhook.created(user).deliver_later(queue: 'webhooks', wait: 10.minutes)
+  #
+  # You can also configure the default queue at the class level:
+  #
+  #   class UserWebhook < ActionWebhook::Base
+  #     self.deliver_later_queue_name = 'webhooks'
+  #
+  #     def created(user)
+  #       @user = user
+  #       endpoints = WebhookSubscription.where(event: 'user.created').map do |sub|
+  #         { url: sub.url, headers: { 'Authorization' => "Bearer #{sub.token}" } }
+  #       end
+  #       deliver(endpoints)
+  #     end
+  #   end
+  #
   class Base
-    # Add these lines near the top of your class
     include GlobalID::Identification if defined?(GlobalID)
     include ActiveJob::SerializationAdapter::ObjectSerializer if defined?(ActiveJob::SerializationAdapter)
 
@@ -42,249 +62,101 @@ module ActionWebhook
     # Retry configuration
     class_attribute :max_retries, instance_writer: false, default: 3
     class_attribute :retry_delay, instance_writer: false, default: 30.seconds
-    class_attribute :retry_backoff, instance_writer: false, default: :exponential # :linear or :exponential
+    class_attribute :retry_backoff, instance_writer: false, default: :exponential
     class_attribute :retry_jitter, instance_writer: false, default: 5.seconds
 
     # Callbacks
     class_attribute :after_deliver_callback, instance_writer: false
     class_attribute :after_retries_exhausted_callback, instance_writer: false
 
-    # The webhook action that will be performed
-    attr_accessor :action_name
-
-    # The webhook details (URLs and headers) that will be used
-    attr_accessor :webhook_details
-
-    # Stores the execution params for later delivery
-    attr_accessor :params
-
-    # Current attempt number for retries
-    attr_accessor :attempts
+    attr_accessor :action_name, :webhook_details, :params, :attempts
 
-    # Creates a new webhook and initializes its settings
     def initialize
       @_webhook_message = {}
       @_webhook_defaults = {}
       @attempts = 0
     end
 
-    # Synchronously delivers the webhook
     def deliver_now
       @attempts += 1
       response = process_webhook
 
-      # Call success callback if defined
-      if response.all? { |r| r[:success] }
-        invoke_callback(self.class.after_deliver_callback, response)
-      elsif @attempts < self.class.max_retries
-        # Schedule a retry with backoff
-        retry_with_backoff
-      else
-        # We've exhausted all retries
-        invoke_callback(self.class.after_retries_exhausted_callback, response)
+      # Separate successful and failed responses
+      successful_responses = response.select { |r| r[:success] }
+      failed_responses = response.reject { |r| r[:success] }
+
+      # Invoke success callback for successful deliveries
+      invoke_callback(self.class.after_deliver_callback, successful_responses) if successful_responses.any?
+
+      # Handle failed responses
+      if failed_responses.any? && @attempts < self.class.max_retries
+        # Extract failed webhook details for retry
+        failed_webhook_details = failed_responses.map { |r| @webhook_details.find { |detail| detail[:url] == r[:url] } }.compact
+        retry_with_backoff(failed_webhook_details)
+      elsif failed_responses.any?
+        # All retries exhausted for failed URLs
+        invoke_callback(self.class.after_retries_exhausted_callback, failed_responses)
       end
 
       response
     end
 
-    # Helper method to invoke a callback that might be a symbol or a proc
-    def invoke_callback(callback, response)
-      return unless callback
-
-      case callback
-      when Symbol
-        send(callback, response)
-      when Proc
-        callback.call(self, response)
-      end
-    end
-
-    # Enqueues the webhook delivery via ActiveJob
     def deliver_later(options = {})
       enqueue_delivery(:deliver_now, options)
     end
 
-    # Prepares the webhook for delivery using the current method as template name
-    # and instance variables as template data
-    #
-    # @param webhook_details [Array<Hash>] Array of hashes with :url and :headers keys
-    # @param params [Hash] Optional parameters to store for later delivery
-    # @return [DeliveryMessenger] A messenger object for further delivery options
     def deliver(webhook_details, params = {})
-      # Determine action name from the caller
       @action_name = caller_locations(1, 1)[0].label.to_sym
       @webhook_details = webhook_details
       @params = params
 
-      # Return self for chaining with delivery methods
       DeliveryMessenger.new(self)
     end
 
-    # Renders a template based on the action name
-    #
-    # @param variables [Hash] Optional variables to add to template context
-    # @return [Hash] The JSON payload
     def build_payload(variables = {})
-      # Combine instance variables and passed variables
-      assigns = {}
-
-      # Extract instance variables
-      instance_variables.each do |ivar|
-        # Skip internal instance variables
-        next if ivar.to_s.start_with?("@_")
-        next if %i[@action_name @webhook_details @params @attempts].include?(ivar)
-
-        # Add to assigns with symbol key (without @)
-        assigns[ivar.to_s[1..].to_sym] = instance_variable_get(ivar)
-      end
-
-      # Add passed variables
+      assigns = extract_instance_variables
       assigns.merge!(variables)
-
-      # Render the template
       generate_json_from_template(@action_name, assigns)
     end
 
-    # Posts payload(s) to the given webhook endpoints
-    #
-    # @param webhook_details [Array<Hash>] An array of hashes containing `url` and `headers`
-    # @param payloads [Array<Hash>] One payload for each webhook
-    # @return [Array<Hash>] Array of response objects with status and body
-    def post_webhook(webhook_details, payloads)
+    def post_webhook(webhook_details, payload)
       responses = []
 
-      webhook_details.each_with_index do |detail, idx|
-        # Ensure headers exists
+      webhook_details.each do |detail|
         detail[:headers] ||= {}
+        headers = build_headers(detail[:headers])
 
-        # Merge default headers
-        headers = default_headers.merge(detail[:headers])
-
-        # Add content type if not present
-        headers["Content-Type"] = "application/json" unless headers.key?("Content-Type")
-
-        # Add attempt tracking in headers
-        headers["X-Webhook-Attempt"] = @attempts.to_s if @attempts.positive?
-
-        response = HTTParty.post(
-          detail[:url],
-          body: payloads[idx].to_json,
-          headers: headers,
-          timeout: 10 # Add reasonable timeout
-        )
-
-        responses << {
-          success: response.success?,
-          status: response.code,
-          body: response.body,
-          url: detail[:url],
-          attempt: @attempts
-        }
+        response = send_webhook_request(detail[:url], payload, headers)
+        responses << build_response_hash(response, detail[:url])
+        log_webhook_result(response, detail[:url])
       rescue StandardError => e
-        responses << {
-          success: false,
-          error: e.message,
-          url: detail[:url],
-          attempt: @attempts
-        }
-        logger.error("Webhook delivery failed: #{e.message} for URL: #{detail[:url]} (Attempt #{@attempts})")
+        responses << build_error_response_hash(e, detail[:url])
+        log_webhook_error(e, detail[:url])
       end
 
       responses
     end
 
-    # Renders a JSON payload from a `.json.erb` template
-    #
-    # @param event_name [Symbol] the name of the webhook method (e.g. `:created`)
-    # @param assigns [Hash] local variables to pass into the template
-    # @return [Hash] the parsed JSON payload
     def generate_json_from_template(input_event_name, assigns = {})
       event_name = extract_method_name(input_event_name.to_s)
-      webhook_class_name = self.class.name.underscore
-
-      # Possible template locations
-      possible_paths = [
-        # Main app templates
-        File.join(Rails.root.to_s, "app/webhooks/#{webhook_class_name}/#{event_name}.json.erb"),
-
-        # Engine templates
-        engine_root && File.join(engine_root, "app/webhooks/#{webhook_class_name}/#{event_name}.json.erb"),
-
-        # Namespaced templates in engine
-        engine_root && self.class.module_parent != Object &&
-          File.join(engine_root,
-                    "app/webhooks/#{self.class.module_parent.name.underscore}/#{webhook_class_name.split("/").last}/#{event_name}.json.erb")
-      ].compact
-
-      # Find the first template that exists
-      template_path = possible_paths.find { |path| File.exist?(path) }
+      template_path = find_template_path(event_name)
 
-      unless template_path
-        raise ArgumentError, "Template not found for #{event_name} in paths:\n#{possible_paths.join("\n")}"
-      end
+      raise ArgumentError, "Template not found for #{event_name}" unless template_path
 
-      template = ERB.new(File.read(template_path))
-      json = template.result_with_hash(assigns)
-      JSON.parse(json)
+      render_json_template(template_path, assigns)
     rescue JSON::ParserError => e
-      raise "Invalid JSON in template #{event_name}: #{e.message}"
+      raise ArgumentError, "Invalid JSON in template #{event_name}: #{e.message}"
     end
 
     def extract_method_name(path)
       path.include?("#") ? path.split("#").last : path
     end
 
-    # Process the webhook to generate and send the payload
     def process_webhook
-      # Render the message
-      payloads = [build_payload]
-
-      # Post the webhook
-      post_webhook(webhook_details, payloads)
+      payload = build_payload
+      post_webhook(webhook_details, payload)
     end
 
-    # Schedule a retry with appropriate backoff delay
-    # Modify the retry_with_backoff method:
-    def retry_with_backoff
-      delay = calculate_backoff_delay
-
-      logger.info("Scheduling webhook retry #{@attempts + 1}/#{self.class.max_retries} in #{delay} seconds")
-
-      # Get the actual job class by evaluating the proc
-      job_class = self.class.delivery_job.is_a?(Proc) ? self.class.delivery_job.call : self.class.delivery_job
-
-      # Serialize the webhook and pass the serialized data instead of the object
-      serialized_webhook = serialize
-
-      # Re-enqueue with the calculated delay
-      if deliver_later_queue_name
-        job_class.set(queue: deliver_later_queue_name, wait: delay).perform_later("deliver_now", serialized_webhook)
-      else
-        job_class.set(wait: delay).perform_later("deliver_now", serialized_webhook)
-      end
-    end
-
-    # Calculate delay based on retry strategy
-    def calculate_backoff_delay
-      base_delay = self.class.retry_delay
-
-      delay = case self.class.retry_backoff
-              when :exponential
-                # 30s, 60s, 120s, etc.
-                base_delay * (2**(@attempts - 1))
-              when :linear
-                # 30s, 60s, 90s, etc.
-                base_delay * @attempts
-              else
-                base_delay
-              end
-
-      # Add jitter to prevent thundering herd problem
-      jitter = rand(self.class.retry_jitter)
-      delay + jitter
-    end
-
-    # For ActiveJob serialization
     def serialize
       {
         "action_name" => @action_name.to_s,
@@ -296,143 +168,283 @@ module ActionWebhook
       }
     end
 
-    # Restores state from serialized data
     def deserialize(data)
       @action_name = data["action_name"].to_sym
       @webhook_details = data["webhook_details"]
       @params = data["params"]
       @attempts = data["attempts"] || 0
 
-      # Restore instance variables
-      data["instance_variables"].each do |name, value|
-        instance_variable_set("@#{name}", value)
+      restore_instance_variables(data["instance_variables"])
+    end
+
+    class << self
+      def method_missing(method_name, *args, &block)
+        if public_instance_methods(false).include?(method_name)
+          webhook = new
+          webhook.send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        public_instance_methods(false).include?(method_name) || super
+      end
+
+      def deliveries
+        @deliveries ||= []
+      end
+
+      def clear_deliveries
+        @deliveries = []
+      end
+
+      def after_deliver(method_name = nil, &block)
+        self.after_deliver_callback = block_given? ? block : method_name
+      end
+
+      def after_retries_exhausted(method_name = nil, &block)
+        self.after_retries_exhausted_callback = block_given? ? block : method_name
       end
     end
 
     private
 
-    # Collects all non-system instance variables for serialization
-    def collect_instance_variables
-      result = {}
+    EXCLUDED_INSTANCE_VARIABLES = %w[@action_name @webhook_details @params @attempts].freeze
+
+    def invoke_callback(callback, response)
+      return unless callback
+
+      case callback
+      when Symbol
+        send(callback, response)
+      when Proc
+        callback.call(self, response)
+      end
+    end
+
+    def extract_instance_variables
+      assigns = {}
       instance_variables.each do |ivar|
-        # Skip internal instance variables
         next if ivar.to_s.start_with?("@_")
-        next if %i[@action_name @webhook_details @params @attempts].include?(ivar)
+        next if EXCLUDED_INSTANCE_VARIABLES.include?(ivar.to_s)
 
-        # Add to result without @
-        result[ivar.to_s[1..]] = instance_variable_get(ivar)
+        assigns[ivar.to_s[1..].to_sym] = instance_variable_get(ivar)
       end
-      result
+      assigns
     end
 
-    # Find the engine root path
-    def engine_root
-      return nil unless defined?(Rails::Engine)
+    def build_headers(detail_headers)
+      headers = default_headers.merge(detail_headers)
+      headers["Content-Type"] = "application/json" unless headers.key?("Content-Type")
+      headers["X-Webhook-Attempt"] = @attempts.to_s if @attempts.positive?
+      headers
+    end
 
-      mod = self.class.module_parent
-      while mod != Object
-        constants = mod.constants.select do |c|
-          const = mod.const_get(c)
-          const.is_a?(Class) && const < Rails::Engine
-        end
+    def send_webhook_request(url, payload, headers)
+      HTTParty.post(url, body: payload.to_json, headers: headers, timeout: 10)
+    end
 
-        return mod.const_get(constants.first).root.to_s if constants.any?
+    def build_response_hash(response, url)
+      {
+        success: response.success?,
+        status: response.code,
+        body: response.body,
+        url: url,
+        attempt: @attempts
+      }
+    end
 
-        mod = mod.module_parent
+    def build_error_response_hash(error, url)
+      {
+        success: false,
+        error: error.message,
+        url: url,
+        attempt: @attempts
+      }
+    end
+
+    def log_webhook_result(response, url)
+      if response.success?
+        logger.info("Webhook delivered successfully: #{url} (Status: #{response.code}, Attempt: #{@attempts})")
+      else
+        logger.warn("Webhook delivery failed with HTTP error: #{url} (Status: #{response.code}, Attempt: #{@attempts})")
       end
+    end
 
-      nil
+    def log_webhook_error(error, url)
+      logger.error("Webhook delivery failed: #{error.message} for URL: #{url} (Attempt: #{@attempts})")
     end
 
-    # Similarly update enqueue_delivery:
-    def enqueue_delivery(delivery_method, options = {})
-      options = options.dup
-      queue = options.delete(:queue) || self.class.deliver_later_queue_name
+    def find_template_path(event_name)
+      webhook_class_name = self.class.name.underscore
+      possible_paths = build_template_paths(webhook_class_name, event_name)
+      possible_paths.find { |path| File.exist?(path) }
+    end
 
-      args = [delivery_method.to_s]
+    def build_template_paths(webhook_class_name, event_name)
+      [
+        File.join(Rails.root.to_s, "app/webhooks/#{webhook_class_name}/#{event_name}.json.erb"),
+        engine_template_path(webhook_class_name, event_name),
+        namespaced_engine_template_path(webhook_class_name, event_name)
+      ].compact
+    end
 
-      # Get the actual job class by evaluating the proc
-      job_class = self.class.delivery_job.is_a?(Proc) ? self.class.delivery_job.call : self.class.delivery_job
+    def engine_template_path(webhook_class_name, event_name)
+      return unless engine_root
 
-      # Serialize the webhook
-      serialized_webhook = serialize
+      File.join(engine_root, "app/webhooks/#{webhook_class_name}/#{event_name}.json.erb")
+    end
 
-      # Use the delivery job to perform the delivery with serialized data
-      if queue
-        job_class.set(queue: queue).perform_later(*args, serialized_webhook)
-      else
-        job_class.set(wait: options[:wait]).perform_later(*args, serialized_webhook) if options[:wait]
-        job_class.perform_later(*args, serialized_webhook) unless options[:wait]
-      end
+    def namespaced_engine_template_path(webhook_class_name, event_name)
+      return unless engine_root && self.class.module_parent != Object
+
+      parent_name = self.class.module_parent.name.underscore
+      class_name = webhook_class_name.split("/").last
+      File.join(engine_root, "app/webhooks/#{parent_name}/#{class_name}/#{event_name}.json.erb")
     end
 
-    # Logger for webhook errors
-    def logger
-      Rails.logger
+    def render_json_template(template_path, assigns)
+      template = ERB.new(File.read(template_path))
+      json = template.result_with_hash(assigns)
+      JSON.parse(json)
     end
 
-    # Class methods
-    class << self
-      # Handle method calls on the class
-      def method_missing(method_name, *args, &block)
-        if public_instance_methods(false).include?(method_name)
-          # Create a new instance
-          webhook = new
+    def collect_instance_variables
+      result = {}
+      instance_variables.each do |ivar|
+        next if ivar.to_s.start_with?("@_")
+        next if EXCLUDED_INSTANCE_VARIABLES.include?(ivar.to_s)
 
-          # Call the instance method
-          webhook.send(method_name, *args, &block)
-        else
-          super
-        end
+        result[ivar.to_s[1..]] = instance_variable_get(ivar)
       end
+      result
+    end
 
-      def respond_to_missing?(method_name, include_private = false)
-        public_instance_methods(false).include?(method_name) || super
+    def restore_instance_variables(variables)
+      variables.each do |name, value|
+        instance_variable_set("@#{name}", value)
       end
+    end
 
-      # Test delivery collection
-      def deliveries
-        @deliveries ||= []
+    def retry_with_backoff(failed_webhook_details = nil)
+      # Use failed webhook details if provided, otherwise retry all
+      retry_details = failed_webhook_details || @webhook_details
+
+      delay = calculate_backoff_delay
+      logger.info("Scheduling webhook retry #{@attempts + 1}/#{self.class.max_retries} for #{retry_details.size} URLs in #{delay} seconds")
+
+      job_class = resolve_job_class
+      serialized_webhook = serialize
+
+      # Update the webhook details to only include failed URLs
+      serialized_webhook["webhook_details"] = retry_details
+
+      enqueue_retry_job(job_class, serialized_webhook, delay)
+    end
+
+    def calculate_backoff_delay
+      base_delay = self.class.retry_delay
+      multiplier = case self.class.retry_backoff
+                   when :exponential
+                     2**(@attempts - 1)
+                   when :linear
+                     @attempts
+                   else
+                     1
+                   end
+
+      base_delay * multiplier + rand(self.class.retry_jitter)
+    end
+
+    def resolve_job_class
+      self.class.delivery_job.is_a?(Proc) ? self.class.delivery_job.call : self.class.delivery_job
+    end
+
+    def enqueue_retry_job(job_class, serialized_webhook, delay)
+      if deliver_later_queue_name
+        job_class.set(queue: deliver_later_queue_name, wait: delay).perform_later("deliver_now", serialized_webhook)
+      else
+        job_class.set(wait: delay).perform_later("deliver_now", serialized_webhook)
       end
+    end
 
-      # Reset the test delivery collection
-      def clear_deliveries
-        @deliveries = []
+    def engine_root
+      return nil unless defined?(Rails::Engine)
+
+      find_engine_root_for_module(self.class.module_parent)
+    end
+
+    def find_engine_root_for_module(mod)
+      while mod != Object
+        engine_constant = find_engine_constant(mod)
+        return mod.const_get(engine_constant).root.to_s if engine_constant
+
+        mod = mod.module_parent
       end
 
-      # Register callback for successful delivery
-      def after_deliver(method_name = nil, &block)
-        self.after_deliver_callback = block_given? ? block : method_name
+      nil
+    end
+
+    def find_engine_constant(mod)
+      mod.constants.find do |c|
+        const = mod.const_get(c)
+        const.is_a?(Class) && const < Rails::Engine
       end
+    end
 
-      # Register callback for when retries are exhausted
-      def after_retries_exhausted(method_name = nil, &block)
-        self.after_retries_exhausted_callback = block_given? ? block : method_name
+    def enqueue_delivery(delivery_method, options = {})
+      options = options.dup
+      queue = options.delete(:queue) || self.class.deliver_later_queue_name
+      job_class = resolve_job_class
+      serialized_webhook = serialize
+
+      enqueue_job(job_class, delivery_method.to_s, serialized_webhook, queue, options)
+    end
+
+    def enqueue_job(job_class, delivery_method, serialized_webhook, queue, options)
+      if queue
+        job_class.set(queue: queue).perform_later(delivery_method, serialized_webhook)
+      elsif options[:wait]
+        job_class.set(wait: options[:wait]).perform_later(delivery_method, serialized_webhook)
+      else
+        job_class.perform_later(delivery_method, serialized_webhook)
       end
     end
+
+    def logger
+      Rails.logger
+    end
   end
 
-  # Delivery messenger for ActionMailer-like API
   class DeliveryMessenger
     def initialize(webhook)
       @webhook = webhook
     end
 
     def deliver_now
-      if @webhook.respond_to?(:perform_deliveries) && !@webhook.perform_deliveries
-        # Skip delivery
-        nil
-      elsif @webhook.class.delivery_method == :test
-        # Test delivery
-        ActionWebhook::Base.deliveries << @webhook
-      else
-        # Normal delivery
-        @webhook.deliver_now
-      end
+      return nil if skip_delivery?
+      return test_delivery if test_mode?
+
+      @webhook.deliver_now
     end
 
     def deliver_later(options = {})
       @webhook.deliver_later(options)
     end
+
+    private
+
+    def skip_delivery?
+      @webhook.respond_to?(:perform_deliveries) && !@webhook.perform_deliveries
+    end
+
+    def test_mode?
+      @webhook.class.delivery_method == :test
+    end
+
+    def test_delivery
+      ActionWebhook::Base.deliveries << @webhook
+    end
   end
 end

data/lib/action_webhook/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActionWebhook
-  VERSION = "0.1.1"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: action_webhook
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Vinay Uttam Vemparala
 bindir: bin
 cert_chain: []
-date: 2025-05-27 00:00:00.000000000 Z
+date: 2025-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -24,33 +24,53 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.18.1
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: globalid
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
 description: A Rails library for triggering webhooks. Inspired by ActionMailer from
   Rails
 email:
@@ -63,13 +83,13 @@ files:
 - lib/action_webhook/base.rb
 - lib/action_webhook/delivery_job.rb
 - lib/action_webhook/version.rb
-homepage: https://github.com/vinayuttam/action_webhook.git
+homepage: https://github.com/vinayuttam/action_webhook
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/vinayuttam/action_webhook.git
-  source_code_uri: https://github.com/vinayuttam/action_webhook.git
-  changelog_uri: https://github.com/vinayuttam/action_webhook.git/blob/main/CHANGELOG.md
+  homepage_uri: https://github.com/vinayuttam/action_webhook
+  source_code_uri: https://github.com/vinayuttam/action_webhook/tree/main
+  changelog_uri: https://github.com/vinayuttam/action_webhook/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib