action_webhook 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cd12e0bb7797fc35e1f987a3af410dd2a4389477d8170f3ab3865aa333d3ecf
-  data.tar.gz: 2b5e65c5f463f643dd9081d7dc9d899d289211da93d4ccd5708797d193bb4066
+  metadata.gz: 54d0eddc17626872f1d795b8c25c4fda06719a1bfed4b185093c8803d442d2ad
+  data.tar.gz: ec2b67113640e9b1d7e4ddb397858a4d38724d01024f781b492906ed629dfc62
 SHA512:
-  metadata.gz: 382b8c38b35ea02f8a0dc1ba62ff4df47acf14e30b70188fe0a5ebc0a1558bb1d25e75715de907f1eaa1e8ac8ac29825575fb7db5081a30202f5314bad4831bf
-  data.tar.gz: 80d3a48160158dfe614404a146280dcadd22040b89d18d0f3d0461f0bf04db3819aacf5985e33bee0dfc8e257836ff74dc46c5774a9c0b5df72da1cb09eb6a69
+  metadata.gz: 5635f2e1541ecf586c52a37df1fb03b6e11e71585255cdbef8a01be30323e1d7a53f7f0ab053ff98dd7a8f3bc6e4e5d95dfbd1b0c1b86b3238577aa13bde0459
+  data.tar.gz: e97e0940c7bf16f20d4c6457d115a2054494af9c17fd9957c3f5537774a45374ee1c395a228de33689edac80ba9f3e3b367e82baa2a972b178b3ac9df5ac719e

data/lib/action_webhook/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionWebhook
   # Base class for defining and delivering webhooks
   #
@@ -31,31 +33,31 @@ module ActionWebhook
     include ActiveJob::SerializationAdapter::ObjectSerializer if defined?(ActiveJob::SerializationAdapter)
 
     # Delivery configuration
-     class_attribute :delivery_job, instance_writer: false, default: -> { "ActionWebhook::DeliveryJob".constantize }
+    class_attribute :delivery_job, instance_writer: false, default: -> { "ActionWebhook::DeliveryJob".constantize }
     class_attribute :deliver_later_queue_name, instance_writer: false
     class_attribute :default_headers, instance_writer: false, default: {}
     class_attribute :delivery_method, instance_writer: false, default: :deliver_now
     class_attribute :perform_deliveries, instance_writer: false, default: true
-    
+
     # 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_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
 
@@ -70,7 +72,7 @@ module ActionWebhook
     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)
@@ -81,14 +83,14 @@ module ActionWebhook
         # We've exhausted all retries
         invoke_callback(self.class.after_retries_exhausted_callback, response)
       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)
@@ -113,7 +115,7 @@ module ActionWebhook
       @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
@@ -125,20 +127,20 @@ module ActionWebhook
     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 [:@action_name, :@webhook_details, :@params, :@attempts].include?(ivar)
-        
+        next if %i[@action_name @webhook_details @params @attempts].include?(ivar)
+
         # Add to assigns with symbol key (without @)
-        assigns[ivar.to_s[1..-1].to_sym] = instance_variable_get(ivar)
+        assigns[ivar.to_s[1..].to_sym] = instance_variable_get(ivar)
       end
-      
+
       # Add passed variables
       assigns.merge!(variables)
-      
+
       # Render the template
       generate_json_from_template(@action_name, assigns)
     end
@@ -150,46 +152,44 @@ module ActionWebhook
     # @return [Array<Hash>] Array of response objects with status and body
     def post_webhook(webhook_details, payloads)
       responses = []
-      
+
       webhook_details.each_with_index do |detail, idx|
-        begin
-          # Ensure headers exists
-          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 > 0
-          
-          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
-          }
-        rescue => 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})")
-        end
+        # Ensure headers exists
+        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
+        }
+      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})")
       end
-      
+
       responses
     end
 
@@ -198,158 +198,165 @@ module ActionWebhook
     # @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(event_name, assigns = {})
+    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")
+          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) }
-      
+
       unless template_path
         raise ArgumentError, "Template not found for #{event_name} in paths:\n#{possible_paths.join("\n")}"
       end
-      
+
       template = ERB.new(File.read(template_path))
       json = template.result_with_hash(assigns)
       JSON.parse(json)
     rescue JSON::ParserError => e
       raise "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)
     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)
+        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)
+        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
-      
-      case self.class.retry_backoff
-      when :exponential
-        # 30s, 60s, 120s, etc.
-        delay = base_delay * (2 ** (@attempts - 1))
-      when :linear
-        # 30s, 60s, 90s, etc.
-        delay = base_delay * @attempts
-      else
-        delay = base_delay
-      end
-      
+
+      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,
-        'webhook_details' => @webhook_details,
-        'params' => @params,
-        'attempts' => @attempts,
-        'instance_variables' => collect_instance_variables,
-        'webhook_class' => self.class.name
+        "action_name" => @action_name.to_s,
+        "webhook_details" => @webhook_details,
+        "params" => @params,
+        "attempts" => @attempts,
+        "instance_variables" => collect_instance_variables,
+        "webhook_class" => self.class.name
       }
     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
-      
+      @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|
+      data["instance_variables"].each do |name, value|
         instance_variable_set("@#{name}", value)
       end
     end
-    
+
     private
-    
+
     # Collects all non-system instance variables for serialization
     def collect_instance_variables
       result = {}
       instance_variables.each do |ivar|
         # Skip internal instance variables
         next if ivar.to_s.start_with?("@_")
-        next if [:@action_name, :@webhook_details, :@params, :@attempts].include?(ivar)
-        
+        next if %i[@action_name @webhook_details @params @attempts].include?(ivar)
+
         # Add to result without @
-        result[ivar.to_s[1..-1]] = instance_variable_get(ivar)
+        result[ivar.to_s[1..]] = instance_variable_get(ivar)
       end
       result
     end
-    
+
     # Find the engine root path
     def engine_root
       return nil unless defined?(Rails::Engine)
-      
+
       mod = self.class.module_parent
       while mod != Object
-        constants = mod.constants.select { |c| 
+        constants = mod.constants.select do |c|
           const = mod.const_get(c)
           const.is_a?(Class) && const < Rails::Engine
-        }
-        
+        end
+
         return mod.const_get(constants.first).root.to_s if constants.any?
+
         mod = mod.module_parent
       end
-      
+
       nil
     end
-    
+
     # Similarly update enqueue_delivery:
     def enqueue_delivery(delivery_method, options = {})
       options = options.dup
       queue = options.delete(:queue) || self.class.deliver_later_queue_name
-      
+
       args = [delivery_method.to_s]
-      
+
       # 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
       serialized_webhook = serialize
-      
+
       # Use the delivery job to perform the delivery with serialized data
       if queue
         job_class.set(queue: queue).perform_later(*args, serialized_webhook)
@@ -358,12 +365,12 @@ module ActionWebhook
         job_class.perform_later(*args, serialized_webhook) unless options[:wait]
       end
     end
-    
+
     # Logger for webhook errors
     def logger
       Rails.logger
     end
-    
+
     # Class methods
     class << self
       # Handle method calls on the class
@@ -371,7 +378,7 @@ module ActionWebhook
         if public_instance_methods(false).include?(method_name)
           # Create a new instance
           webhook = new
-          
+
           # Call the instance method
           webhook.send(method_name, *args, &block)
         else
@@ -382,35 +389,35 @@ module ActionWebhook
       def respond_to_missing?(method_name, include_private = false)
         public_instance_methods(false).include?(method_name) || super
       end
-      
+
       # Test delivery collection
       def deliveries
         @deliveries ||= []
       end
-      
+
       # Reset the test delivery collection
       def clear_deliveries
         @deliveries = []
       end
-      
+
       # Register callback for successful delivery
       def after_deliver(method_name = nil, &block)
         self.after_deliver_callback = block_given? ? block : method_name
       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
       end
     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
@@ -423,9 +430,9 @@ module ActionWebhook
         @webhook.deliver_now
       end
     end
-    
+
     def deliver_later(options = {})
       @webhook.deliver_later(options)
     end
   end
-end
+end

data/lib/action_webhook/delivery_job.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionWebhook
   # Job responsible for delivering webhooks in the background
   class DeliveryJob < ActiveJob::Base
@@ -9,10 +11,10 @@ module ActionWebhook
     # @param serialized_webhook [Hash] The serialized webhook data
     def perform(delivery_method, serialized_webhook)
       # Reconstruct the webhook from serialized data
-      webhook_class = serialized_webhook['webhook_class'].constantize
+      webhook_class = serialized_webhook["webhook_class"].constantize
       webhook = webhook_class.new
       webhook.deserialize(serialized_webhook)
-      
+
       # Invoke the specified delivery method
       webhook.send(delivery_method)
     end
@@ -22,9 +24,9 @@ module ActionWebhook
       # Log the error
       Rails.logger.error("ActionWebhook delivery failed: #{exception.message}")
       Rails.logger.error(exception.backtrace.join("\n"))
-      
+
       # Re-raise the exception if in development or test
       raise exception if Rails.env.development? || Rails.env.test?
     end
   end
-end
+end

data/lib/action_webhook/version.rb

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

data/lib/action_webhook.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_job"
 require "httparty"
 
@@ -7,4 +9,4 @@ require "action_webhook/base"
 
 module ActionWebhook
   class Error < StandardError; end
-end
+end

metadata

@@ -1,42 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: action_webhook
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Vinay Uttam Vemparala
 bindir: bin
 cert_chain: []
-date: 2025-04-25 00:00:00.000000000 Z
+date: 2025-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: httparty
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: 0.18.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: 0.18.1
 - !ruby/object:Gem::Dependency
-  name: httparty
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.1
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.1
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement