unisender-ruby 0.1.0

data/lib/unisender/operations/inputs_1.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Inputs operations from the official UniSender API.
+  class Client
+    # https://www.unisender.com/ru/support/api/inputs/createfield/
+    def create_field(name:, type:, public_name: nil)
+      params = { name:, type:, public_name: }
+      invoke("createField", params, required: %w[name type])
+    end
+
+    # https://www.unisender.com/ru/support/api/inputs/deletefield/
+    def delete_field(id:)
+      params = { id: }
+      invoke("deleteField", params, required: %w[id])
+    end
+
+    # https://www.unisender.com/ru/support/api/inputs/deletetag/
+    def delete_tag(id:)
+      params = { id: }
+      invoke("deleteTag", params, required: %w[id])
+    end
+
+    # https://www.unisender.com/ru/support/api/inputs/getfields/
+    # rubocop:disable-next Naming/AccessorMethodName -- Mirrors the documented operation.
+    def get_fields
+      invoke("getFields", {})
+    end
+
+    # https://www.unisender.com/ru/support/api/inputs/gettags/
+    # rubocop:disable-next Naming/AccessorMethodName -- Mirrors the documented operation.
+    def get_tags
+      invoke("getTags", {})
+    end
+
+    # https://www.unisender.com/ru/support/api/inputs/updatefield/
+    def update_field(id:, name:, public_name: nil)
+      params = { id:, name:, public_name: }
+      invoke("updateField", params, required: %w[id name])
+    end
+
+    # https://www.unisender.com/ru/support/api/inputs/getcontactfieldvalues/
+    def get_contact_field_values(email:, field_ids:)
+      params = { email:, field_ids: }
+      invoke("getContactFieldValues", params, required: %w[email field_ids], comma: %w[field_ids])
+    end
+  end
+end

data/lib/unisender/operations/messages_1.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Messages operations from the official UniSender API.
+  class Client
+    # https://www.unisender.com/ru/support/api/messages/cancel-campaign/
+    def cancel_campaign(campaign_id:)
+      params = { campaign_id: }
+      invoke("cancelCampaign", params, required: %w[campaign_id])
+    end
+
+    # https://www.unisender.com/ru/support/api/messages/check-email/
+    def check_email(email_id:)
+      params = { email_id: }
+      invoke("checkEmail", params, required: %w[email_id], comma: %w[email_id])
+    end
+
+    # https://www.unisender.com/ru/support/api/messages/check-sms/
+    def check_sms(sms_id:)
+      params = { sms_id: }
+      invoke("checkSms", params, required: %w[sms_id])
+    end
+
+    # https://www.unisender.com/ru/support/api/messages/createcampaign/
+    # rubocop:disable-next Metrics/ParameterLists -- Mirrors the documented operation.
+    def create_campaign(message_id:, start_time: nil, timezone: nil, track_read: nil, track_links: nil,
+                        contacts: nil, contacts_url: nil, track_ga: nil, payment_limit: nil, payment_currency: nil,
+                        ga_medium: nil, ga_source: nil, ga_campaign: nil, ga_content: nil, ga_term: nil)
+      params = { message_id:, start_time:, timezone:, track_read:, track_links:, contacts:, contacts_url:,
+                 track_ga:, payment_limit:, payment_currency:, ga_medium:, ga_source:, ga_campaign:,
+                 ga_content:, ga_term: }
+      invoke("createCampaign", params, required: %w[message_id], comma: %w[contacts])
+    end
+
+    # https://www.unisender.com/ru/support/api/messages/createemailmessage/
+    # rubocop:disable-next Metrics/ParameterLists -- Mirrors the documented operation.
+    def create_email_message(sender_name:, sender_email:, list_id:, subject: nil, body: nil, text_body: nil,
+                             generate_text: nil, tag: nil, attachments: nil, lang: nil, template_id: nil,
+                             system_template_id: nil,
+                             wrap_type: nil, categories: nil)
+      params = { sender_name:, sender_email:, list_id:, subject:, body:, text_body:, generate_text:, tag:,
+                 attachments:, lang:, template_id:, system_template_id:, wrap_type:, categories: }
+      invoke("createEmailMessage", params, required: %w[sender_name sender_email list_id], comma: %w[categories])
+    end
+
+    # https://www.unisender.com/ru/support/api/messages/createsmsmessage/
+    def create_sms_message(sender:, body:, list_id:, tag: nil)
+      params = { sender:, body:, list_id:, tag: }
+      invoke("createSmsMessage", params, required: %w[sender body list_id])
+    end
+
+    # https://www.unisender.com/ru/support/api/messages/deletemessage/
+    def delete_message(message_id:)
+      params = { message_id: }
+      invoke("deleteMessage", params, required: %w[message_id])
+    end
+  end
+end

data/lib/unisender/operations/messages_2.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Messages operations from the official UniSender API.
+  class Client
+    # https://www.unisender.com/ru/support/api/messages/get-actual-message-version/
+    def get_actual_message_version(message_id:)
+      params = { message_id: }
+      invoke("getActualMessageVersion", params, required: %w[message_id])
+    end
+
+    # https://www.unisender.com/ru/support/api/messages/getwebversion/
+    def get_web_version(campaign_id:)
+      params = { campaign_id: }
+      invoke("getWebVersion", params, required: %w[campaign_id])
+    end
+
+    # https://www.unisender.com/ru/support/api/messages/sendemail/
+    # rubocop:disable-next Metrics/ParameterLists -- Mirrors the documented operation.
+    def send_email(email:, sender_name:, sender_email:, subject:, body:, list_id:, attachments: nil, lang: nil,
+                   track_read: nil, track_links: nil, cc: nil, headers: nil, images_as: nil, ref_key: nil,
+                   error_checking: nil, metadata: nil)
+      params = { email:, sender_name:, sender_email:, subject:, body:, list_id:, attachments:, lang:,
+                 track_read:, track_links:, cc:, headers:, images_as:, ref_key:, error_checking:, metadata: }
+      invoke("sendEmail", params, required: %w[email sender_name sender_email subject body list_id])
+    end
+
+    # https://www.unisender.com/ru/support/api/messages/sendsms/
+    def send_sms(phone:, sender:, text:)
+      params = { phone:, sender:, text: }
+      invoke("sendSms", params, required: %w[phone sender text])
+    end
+
+    # https://www.unisender.com/ru/support/api/messages/sendtestemail/
+    def send_test_email(email:, id:)
+      params = { email:, id: }
+      invoke("sendTestEmail", params, required: %w[email id], comma: %w[email])
+    end
+
+    # https://www.unisender.com/ru/support/api/messages/updateemailmessage/
+    # rubocop:disable-next Metrics/ParameterLists -- Mirrors the documented operation.
+    def update_email_message(id:, sender_name: nil, sender_email: nil, subject: nil, body: nil, list_id: nil,
+                             text_body: nil, lang: nil, categories: nil)
+      params = { id:, sender_name:, sender_email:, subject:, body:, list_id:, text_body:, lang:, categories: }
+      invoke("updateEmailMessage", params, required: %w[id], comma: %w[categories])
+    end
+
+    # https://www.unisender.com/ru/support/api/messages/updateoptinemail/
+    def update_opt_in_email(sender_name:, sender_email:, subject:, body:, list_id:)
+      params = { sender_name:, sender_email:, subject:, body:, list_id: }
+      invoke("updateOptInEmail", params, required: %w[sender_name sender_email subject body list_id])
+    end
+  end
+end

data/lib/unisender/operations/messages_3.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Messages operations from the official UniSender API.
+  class Client
+    # https://www.unisender.com/ru/support/api/messages/getsenderdomainlist/
+    def get_sender_domain_list(username:, domain: nil, limit: nil, offset: nil)
+      params = { username:, domain:, limit:, offset: }
+      PaginatedOperations.call(self, :get_sender_domain_list, params)
+    end
+  end
+end

data/lib/unisender/operations/notes_1.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Notes operations from the official UniSender API.
+  class Client
+    # https://www.unisender.com/ru/support/api/notes/createsubscibernote/
+    def create_subscriber_note(subscriber_id:, content:)
+      params = { subscriber_id:, content: }
+      invoke("createSubscriberNote", params, required: %w[subscriber_id content])
+    end
+
+    # https://www.unisender.com/ru/support/api/notes/updatesubcribernote/
+    def update_subscriber_note(id:, content:)
+      params = { id:, content: }
+      invoke("updateSubscriberNote", params, required: %w[id content])
+    end
+
+    # https://www.unisender.com/ru/support/api/notes/deletesubscribernote/
+    def delete_subscriber_note(id:)
+      params = { id: }
+      invoke("deleteSubscriberNote", params, required: %w[id])
+    end
+
+    # https://www.unisender.com/ru/support/api/notes/getsubscribernote/
+    def get_subscriber_note(id:)
+      params = { id: }
+      invoke("getSubscriberNote", params, required: %w[id])
+    end
+
+    # https://www.unisender.com/ru/support/api/notes/getsubscribernotes/
+    # rubocop:disable-next Metrics/ParameterLists -- Mirrors the documented operation.
+    def get_subscriber_notes(subscriber_id:, limit: nil, offset: nil, order_type: nil, order_by: nil,
+                             is_pinned: nil)
+      params = { subscriber_id:, limit:, offset:, order_type:, order_by:, is_pinned: }
+      PaginatedOperations.call(self, :get_subscriber_notes, params)
+    end
+  end
+end

data/lib/unisender/operations/statistics_1.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Statistics operations from the official UniSender API.
+  class Client
+    # https://www.unisender.com/ru/support/api/statistics/get-campaign-common-stats/
+    def get_campaign_common_stats(campaign_id:)
+      params = { campaign_id: }
+      invoke("getCampaignCommonStats", params, required: %w[campaign_id])
+    end
+
+    # https://www.unisender.com/ru/support/api/statistics/getcampaigndeliverystats/
+    def get_campaign_delivery_stats(campaign_id:, notify_url: nil, changed_since: nil, field_ids: nil)
+      params = { campaign_id:, notify_url:, changed_since:, field_ids: }
+      invoke("async/getCampaignDeliveryStats", params, required: %w[campaign_id])
+    end
+
+    # https://www.unisender.com/ru/support/api/statistics/getcampaignstatus/
+    def get_campaign_status(campaign_id:)
+      params = { campaign_id: }
+      invoke("getCampaignStatus", params, required: %w[campaign_id])
+    end
+
+    # https://www.unisender.com/ru/support/api/statistics/getmessages/
+    def get_messages(date_from:, date_to:, limit: nil, offset: nil)
+      params = { date_from:, date_to:, limit:, offset: }
+      PaginatedOperations.call(self, :get_messages, params)
+    end
+
+    # https://www.unisender.com/ru/support/api/statistics/getvisitedlinks/
+    def get_visited_links(campaign_id:, group: nil)
+      params = { campaign_id:, group: }
+      invoke("getVisitedLinks", params, required: %w[campaign_id])
+    end
+
+    # https://www.unisender.com/ru/support/api/statistics/listmessages/
+    def list_messages(date_from:, date_to:, limit: nil, offset: nil)
+      params = { date_from:, date_to:, limit:, offset: }
+      PaginatedOperations.call(self, :list_messages, params)
+    end
+
+    # https://www.unisender.com/ru/support/api/statistics/getcampaigns/
+    def get_campaigns(from:, to: nil, limit: nil, offset: nil)
+      params = { from:, to:, limit:, offset: }
+      PaginatedOperations.call(self, :get_campaigns, params)
+    end
+  end
+end

data/lib/unisender/operations/statistics_2.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Statistics operations from the official UniSender API.
+  class Client
+    # https://www.unisender.com/ru/support/api/statistics/getmessage/
+    def get_message(id:)
+      params = { id: }
+      invoke("getMessage", params, required: %w[id])
+    end
+
+    # https://www.unisender.com/ru/support/api/statistics/../contacts/exportcontacts/
+    def get_task_result(task_uuid:)
+      params = { task_uuid: }
+      invoke("async/getTaskResult", params, required: %w[task_uuid])
+    end
+  end
+end

data/lib/unisender/operations/templates_1.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Templates operations from the official UniSender API.
+  class Client
+    # https://www.unisender.com/ru/support/api/templates/createemailtemplate/
+    # rubocop:disable-next Metrics/ParameterLists -- Mirrors the documented operation.
+    def create_email_template(title:, subject:, body:, description: nil, text_body: nil, lang: nil)
+      params = { title:, subject:, body:, description:, text_body:, lang: }
+      invoke("createEmailTemplate", params, required: %w[title subject body])
+    end
+
+    # https://www.unisender.com/ru/support/api/templates/deletetemplate/
+    def delete_template(template_id:)
+      params = { template_id: }
+      invoke("deleteTemplate", params, required: %w[template_id])
+    end
+
+    # https://www.unisender.com/ru/support/api/templates/gettemplate/
+    def get_template(template_id: nil, system_template_id: nil)
+      params = { template_id:, system_template_id: }
+      invoke("getTemplate", params)
+    end
+
+    # https://www.unisender.com/ru/support/api/templates/gettemplates/
+    def get_templates(type: nil, date_from: nil, date_to: nil, limit: nil, offset: nil)
+      params = { type:, date_from:, date_to:, limit:, offset: }
+      PaginatedOperations.call(self, :get_templates, params)
+    end
+
+    # https://www.unisender.com/ru/support/api/templates/listtemplates/
+    def list_templates(type: nil, date_from: nil, date_to: nil, limit: nil, offset: nil)
+      params = { type:, date_from:, date_to:, limit:, offset: }
+      PaginatedOperations.call(self, :list_templates, params)
+    end
+
+    # https://www.unisender.com/ru/support/api/templates/updateemailtemplate/
+    # rubocop:disable-next Metrics/ParameterLists -- Mirrors the documented operation.
+    def update_email_template(template_id:, title: nil, description: nil, subject: nil, body: nil,
+                              text_body: nil, lang: nil)
+      params = { template_id:, title:, description:, subject:, body:, text_body:, lang: }
+      invoke("updateEmailTemplate", params, required: %w[template_id])
+    end
+  end
+end

data/lib/unisender/paginated_operations.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Shared contracts for the operations that support offset pagination.
+  module PaginatedOperations
+    # @type var empty: Array[Symbol]
+    empty = []
+    empty.freeze
+    # @type var definitions: Hash[String, [String, Array[Symbol], Array[Symbol], Integer?]]
+    definitions = {
+      "get_campaigns" => ["getCampaigns", %i[from].freeze, %i[from to limit offset].freeze, 10_000],
+      "get_messages" => ["getMessages", %i[date_from date_to].freeze, %i[date_from date_to limit offset].freeze, 100],
+      "list_messages" => ["listMessages", %i[date_from date_to].freeze, %i[date_from date_to limit offset].freeze, 100],
+      "get_templates" => ["getTemplates", empty, %i[type date_from date_to limit offset].freeze, 100],
+      "list_templates" => ["listTemplates", empty, %i[type date_from date_to limit offset].freeze, 100],
+      "get_sender_domain_list" => ["getSenderDomainList", %i[username].freeze,
+                                   %i[username domain limit offset].freeze, 100],
+      "get_subscriber_notes" => ["getSubscriberNotes", %i[subscriber_id].freeze,
+                                 %i[subscriber_id limit offset order_type order_by is_pinned].freeze, nil]
+    }
+    DEFINITIONS = definitions.transform_values(&:freeze).freeze
+    private_constant :DEFINITIONS
+
+    def self.call(client, method, params)
+      wire, required, allowed, = definition(method)
+      raise ArgumentError, "Unknown operation parameter" unless params.keys.all? { |key| allowed.include?(key) }
+
+      Validation.required!(params, required.map(&:to_s))
+      Validation.operation!(wire, params)
+      client.request(wire, params:) # : Response[objects]
+    end
+
+    def self.page_limit(method)
+      definition(method).last
+    end
+
+    def self.definition(method)
+      DEFINITIONS.fetch(method.to_s) { raise ArgumentError, "Unsupported paginated method" }
+    end
+    private_class_method :definition
+  end
+end

data/lib/unisender/pagination.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Offset pagination is supported only for operations that document it.
+  class Pagination
+    def initialize(client, method, page_size, max_pages, params)
+      @client = client
+      @method = method.to_s
+      @page_size = page_size
+      @max_pages = max_pages
+      @params = params.dup
+    end
+
+    def each
+      Enumerator.new do |pages|
+        validate!(PaginatedOperations.page_limit(@method))
+        fetch_pages(pages, initial_offset)
+      end
+    end
+
+    private
+
+    def initial_offset
+      offset = @params.fetch(:offset, 0)
+      raise ArgumentError, "offset must be nonnegative" unless offset.is_a?(Integer) && offset >= 0
+
+      offset
+    end
+
+    def fetch_pages(pages, offset)
+      @max_pages.times do
+        response = PaginatedOperations.call(@client, @method, @params.merge(limit: @page_size, offset:))
+        count = page_length(response)
+        pages << response
+        return if count < @page_size
+
+        offset += count
+      end
+      raise PaginationError, "Pagination page limit reached"
+    end
+
+    def validate!(maximum)
+      validate_limit!(maximum)
+      raise ArgumentError, "max_pages must be positive" unless @max_pages.is_a?(Integer) && @max_pages.positive?
+      raise ArgumentError, "Use page_size instead of limit" if @params.key?(:limit)
+    end
+
+    def validate_limit!(maximum)
+      raise ArgumentError, "Invalid page_size" unless @page_size.is_a?(Integer) && @page_size.positive?
+      raise ArgumentError, "page_size exceeds the method limit" if maximum && @page_size > maximum
+    end
+
+    def page_length(response)
+      result = response.result
+      raise InvalidResponseError, "Expected paginated result array" unless result.is_a?(Array)
+      return result.size unless @method == "get_sender_domain_list"
+
+      result.sum do |group|
+        raise InvalidResponseError, "Expected sender domain groups" unless group.is_a?(Hash)
+
+        domains = group["domains"]
+        raise InvalidResponseError, "Expected sender domain groups" unless domains.is_a?(Array)
+
+        domains.size
+      end
+    end
+  end
+end

data/lib/unisender/protocol.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Keeps HTTP failures separate from the API's success/error envelope.
+  module Protocol
+    def self.parse(http, method: nil)
+      data = decode(http)
+      response = Response.new(data:, status: http.status, headers: http.headers)
+      raise HTTPError, response, cause: nil unless (200..299).cover?(http.status)
+      raise APIError, response, cause: nil if data.key?("error")
+      raise InvalidResponseError, "Missing API result", cause: nil unless result?(data, method)
+
+      response
+    end
+
+    # These method pages document success objects without the usual result envelope.
+    # https://www.unisender.com/ru/support/api/messages/sendtestemail/
+    # https://www.unisender.com/ru/support/api/inputs/updatefield/
+    def self.result?(data, method)
+      return true if data.key?("result")
+
+      case method
+      when "sendTestEmail" then data["message"].is_a?(String)
+      when "updateField" then data["id"].is_a?(Integer)
+      else false
+      end
+    end
+
+    def self.decode(http)
+      # @type var data: json
+      data = JSON.parse(http.body)
+      unless data.is_a?(Hash)
+        raise InvalidResponseError, "Expected a JSON object", cause: nil if (200..299).cover?(http.status)
+
+        return {}
+      end
+
+      data.delete("result") if data.key?("error")
+      data
+    rescue JSON::ParserError, EncodingError
+      raise InvalidResponseError, "Invalid JSON response", cause: nil if (200..299).cover?(http.status)
+
+      {}
+    end
+  end
+end

data/lib/unisender/response.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Unisender
+  # Complete HTTP response at the transport boundary.
+  HTTPResponse = Data.define(:status, :headers, :body)
+
+  # Transport metadata with a payload-free inspection representation.
+  class HTTPResponse
+    def inspect
+      "#<Unisender::HTTPResponse status=#{status}>"
+    end
+
+    alias to_s inspect
+  end
+
+  # A successful response. JSON values retain their original types and string keys.
+  class Response
+    # @type var empty: Array[json]
+    empty = []
+    EMPTY_WARNINGS = empty.freeze
+
+    attr_reader :data, :status, :headers
+
+    def initialize(data:, status:, headers:)
+      @data = immutable_hash(data)
+      @status = status
+      @headers = headers.to_h { |key, value| [key.dup.freeze, value.dup.freeze] }.freeze
+      freeze
+    end
+
+    # The parser retains JSON; named operation signatures describe its upstream shape.
+    # @type method result: () -> json
+    def result
+      @data.fetch("result", @data)
+    end
+
+    def warnings
+      @data.fetch("warnings", EMPTY_WARNINGS)
+    end
+
+    def inspect
+      "#<Unisender::Response status=#{@status}>"
+    end
+
+    private
+
+    def immutable_hash(value)
+      value.to_h { |key, item| [key.dup.freeze, immutable(item)] }.freeze
+    end
+
+    def immutable(value)
+      case value
+      when Hash
+        immutable_hash(value)
+      when Array
+        value.map { |item| immutable(item) }.freeze
+      else
+        value.dup.freeze
+      end
+    end
+  end
+end

data/lib/unisender/retry_policy.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Unisender
+  # Explicit retry policy; never retries a request that can change server state.
+  class RetryPolicy
+    READ_ONLY = %w[
+      getLists getTotalContactsCount getContactCount isContactInLists getContact checkEmail checkSms
+      getActualMessageVersion getWebVersion getSenderDomainList getCampaignCommonStats getCampaignStatus
+      getMessages getVisitedLinks listMessages getCampaigns getMessage getTemplate getTemplates listTemplates
+      getFields getTags getContactFieldValues getSubscriberNote getSubscriberNotes async/getTaskResult
+    ].freeze
+    TRANSIENT_CODES = %w[retry_later api_call_limit_exceeded_for_api_key api_call_limit_exceeded_for_ip].freeze
+
+    def initialize(max_retries: 0, max_elapsed: 60, clock: nil, sleeper: nil, random: nil)
+      validate!(max_retries, max_elapsed)
+      @max_retries = max_retries
+      @max_elapsed = max_elapsed
+      @clock = clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+      @sleeper = sleeper || ->(delay) { sleep(delay) }
+      @random = random || -> { rand }
+      freeze
+    end
+
+    def call(operation)
+      started = @clock.call
+      attempts = 0
+      begin
+        yield
+      rescue Error => e
+        raise unless READ_ONLY.include?(operation) && attempts < @max_retries && transient?(e)
+
+        raise unless wait?(e, attempts, started + @max_elapsed)
+
+        attempts += 1
+        retry
+      end
+    end
+
+    private
+
+    def validate!(max_retries, max_elapsed)
+      unless max_retries.is_a?(Integer) && (0..2).cover?(max_retries)
+        raise ArgumentError, "max_retries must be between 0 and 2"
+      end
+      return if max_elapsed.is_a?(Numeric) && max_elapsed.positive? && max_elapsed.finite?
+
+      raise ArgumentError, "max_elapsed must be positive and finite"
+    end
+
+    def wait?(error, attempts, deadline)
+      delay = [(2.0**attempts) + @random.call, retry_after(error)].max
+      return false if delay > 30 || @clock.call + delay >= deadline
+
+      @sleeper.call(delay)
+      @clock.call < deadline
+    end
+
+    def transient?(error)
+      case error
+      when APIError then TRANSIENT_CODES.include?(error.code)
+      when HTTPError then [429, 502, 503, 504].include?(error.response.status)
+      when TimeoutError then true
+      when TransportError then error.retryable?
+      else false
+      end
+    end
+
+    def retry_after(error)
+      return 0.0 unless error.is_a?(HTTPError)
+
+      value = error.response.headers["retry-after"]
+      return 0.0 unless value
+      return value.to_f if value.match?(/\A\d+(?:\.\d+)?\z/)
+
+      [Time.httpdate(value) - Time.now, 0.0].max
+    rescue ArgumentError
+      0.0
+    end
+  end
+end