mega-pure-kit 0.0.1

data/stripe-19.3.0/lib/stripe/api_resource.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Stripe
+  class APIResource < StripeObject
+    include Stripe::APIOperations::Request
+
+    # A flag that can be set a behavior that will cause this resource to be
+    # encoded and sent up along with an update of its parent resource. This is
+    # usually not desirable because resources are updated individually on their
+    # own endpoints, but there are certain cases, replacing a customer's source
+    # for example, where this is allowed.
+    attr_accessor :save_with_parent
+
+    # TODO: (major) Remove OBJECT_NAME and stop using const_get here
+    # This is a workaround to avoid breaking users who have defined their own
+    # APIResource subclasses with a custom OBJECT_NAME. We should never fallback
+    # on this case otherwise.
+    OBJECT_NAME = ""
+    def self.object_name
+      const_get(:OBJECT_NAME)
+    end
+
+    def self.class_name
+      name.split("::")[-1]
+    end
+
+    def self.resource_url
+      if name.include?("Stripe::V2")
+        raise NotImplementedError,
+              "V2 resources do not have a defined URL. Please use the StripeClient " \
+              "to make V2 requests"
+      end
+
+      if self == APIResource
+        raise NotImplementedError,
+              "APIResource is an abstract class. You should perform actions " \
+              "on its subclasses (Charge, Customer, etc.)"
+      end
+      # Namespaces are separated in object names with periods (.) and in URLs
+      # with forward slashes (/), so replace the former with the latter.
+      "/v1/#{object_name.downcase.tr('.', '/')}s"
+    end
+
+    # A metaprogramming call that specifies that a field of a resource can be
+    # its own type of API resource (say a nested card under an account for
+    # example), and if that resource is set, it should be transmitted to the
+    # API on a create or update. Doing so is not the default behavior because
+    # API resources should normally be persisted on their own RESTful
+    # endpoints.
+    def self.save_nested_resource(name)
+      define_method(:"#{name}=") do |value|
+        super(value)
+
+        # The parent setter will perform certain useful operations like
+        # converting to an APIResource if appropriate. Refresh our argument
+        # value to whatever it mutated to.
+        value = send(name)
+
+        # Note that the value may be subresource, but could also be a scalar
+        # (like a tokenized card's ID for example), so we check the type before
+        # setting #save_with_parent here.
+        value.save_with_parent = true if value.is_a?(APIResource)
+
+        value
+      end
+    end
+
+    # Adds a custom method to a resource class. This is used to add support for
+    # non-CRUDL API requests, e.g. capturing charges. custom_method takes the
+    # following parameters:
+    # - name: the name of the custom method to create (as a symbol)
+    # - http_verb: the HTTP verb for the API request (:get, :post, or :delete)
+    # - http_path: the path to append to the resource's URL. If not provided,
+    #              the name is used as the path
+    #
+    # For example, this call:
+    #     custom_method :capture, http_verb: post
+    # adds a `capture` class method to the resource class that, when called,
+    # will send a POST request to `/v1/<object_name>/capture`.
+    def self.custom_method(name, http_verb:, http_path: nil)
+      Util.custom_method self, self, name, http_verb, http_path
+    end
+
+    def resource_url
+      unless (id = self["id"])
+        raise InvalidRequestError.new(
+          "Could not determine which URL to request: #{self.class} instance " \
+          "has invalid ID: #{id.inspect}",
+          "id"
+        )
+      end
+      "#{self.class.resource_url}/#{CGI.escape(id)}"
+    end
+
+    def refresh
+      if self.class.name.include?("Stripe::V2")
+        raise NotImplementedError,
+              "It is not possible to refresh v2 objects. Please retrieve the object using the StripeClient instead."
+      end
+
+      opts = RequestOptions.extract_opts_from_hash(@retrieve_opts || {})
+      @retrieve_opts = {} # Make sure to clear the retrieve options
+      @obj = @requestor.execute_request_initialize_from(:get, resource_url, :api, self, params: @retrieve_params,
+                                                                                        opts: opts)
+      initialize_from(
+        @obj.last_response.data,
+        @obj.instance_variable_get(:@opts),
+        @obj.last_response,
+        api_mode: :v1,
+        requestor: @requestor
+      )
+    end
+
+    # Retrieve by passing id like `retrieve(id)`
+    # If passing parameters, pass a single map with parameters and the `id` as well.
+    # For example: retrieve({id: some_id, some_param: some_param_value})
+    def self.retrieve(id, opts = {})
+      if name.include?("Stripe::V2")
+        raise NotImplementedError,
+              "It is not possible to retrieve v2 objects on the resource. Please use the StripeClient instead."
+      end
+
+      instance = new(id)
+      # Explicitly send options for the retrieve call, to preserve custom headers
+      # This is so we can pass custom headers from this static function
+      # to the instance variable method call
+      # The custom headers will be cleaned up with the rest of the RequestOptions
+      instance.instance_variable_set(:@retrieve_opts, Util.normalize_opts(opts))
+      instance.refresh
+    end
+
+    def request_stripe_object(method:, path:, params:, base_address: :api, opts: {})
+      APIRequestor.active_requestor.execute_request_initialize_from(method, path, base_address, self,
+                                                                    params: params, opts: opts)
+    end
+
+    protected def request_stream(method:, path:, params:, base_address: :api, opts: {},
+                                 &read_body_chunk_block)
+      resp, = execute_resource_request_stream(
+        method, path, base_address, params, opts, &read_body_chunk_block
+      )
+      resp
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/api_resource_test_helpers.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Stripe
+  # The base class for nested TestHelpers classes in resource objects.
+  # The APIResourceTestHelpers handles URL generation and custom method
+  # support for test-helper methods.
+  #
+  #  class MyAPIResource < APIResource
+  #    class TestHelpers < APIResourceTestHelpers
+  class APIResourceTestHelpers
+    include Stripe::APIOperations::Request
+
+    def initialize(resource)
+      @resource = resource
+    end
+
+    def self.resource_class
+      nil
+    end
+
+    # Adds a custom method to a test helper. This is used to add support for
+    # non-CRUDL API requests, e.g. capturing charges. custom_method takes the
+    # following parameters:
+    # - name: the name of the custom method to create (as a symbol)
+    # - http_verb: the HTTP verb for the API request (:get, :post, or :delete)
+    # - http_path: the path to append to the resource's URL. If not provided,
+    #              the name is used as the path
+    #
+    # For example, this call:
+    #     custom_method :capture, http_verb: post
+    # adds a `capture` class method to the resource class that, when called,
+    # will send a POST request to `/v1/<object_name>/capture`.
+    def self.custom_method(name, http_verb:, http_path: nil)
+      Util.custom_method resource_class, self, name, http_verb, http_path
+    end
+
+    def self.resource_url
+      "/v1/test_helpers/" \
+        "#{resource_class.object_name.downcase.tr('.', '/')}s"
+    end
+
+    def resource_url
+      unless (id = @resource["id"])
+        raise InvalidRequestError.new(
+          "Could not determine which URL to request: #{self.class} instance " \
+          "has invalid ID: #{id.inspect}",
+          "id"
+        )
+      end
+      "#{self.class.resource_url}/#{CGI.escape(id)}"
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/api_version.rb

@@ -0,0 +1,9 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module ApiVersion
+    CURRENT = "2026-06-24.dahlia"
+    CURRENT_MAJOR = "dahlia"
+  end
+end

data/stripe-19.3.0/lib/stripe/connection_manager.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Stripe
+  # Manages connections across multiple hosts which is useful because the
+  # library may connect to multiple hosts during a typical session (main API,
+  # Connect, Uploads). Ruby doesn't provide an easy way to make this happen
+  # easily, so this class is designed to track what we're connected to and
+  # manage the lifecycle of those connections.
+  #
+  # Note that this class in itself is *not* thread safe. We expect it to be
+  # instantiated once per thread.
+  class ConnectionManager
+    # Timestamp (in seconds procured from the system's monotonic clock)
+    # indicating when the connection manager last made a request. This is used
+    # by `APIRequestor` to determine whether a connection manager should be
+    # garbage collected or not.
+    attr_reader :last_used
+    attr_reader :config
+
+    def initialize(config = Stripe.config)
+      @config = config
+      @active_connections = {}
+      @last_used = Util.monotonic_time
+
+      # A connection manager may be accessed across threads as one thread makes
+      # requests on it while another is trying to clear it (either because it's
+      # trying to garbage collect the manager or trying to clear it because a
+      # configuration setting has changed). That's probably thread-safe already
+      # because of Ruby's GIL, but just in case the library's running on JRuby
+      # or the like, use a mutex to synchronize access in this connection
+      # manager.
+      @mutex = Mutex.new
+    end
+
+    # Finishes any active connections by closing their TCP connection and
+    # clears them from internal tracking.
+    def clear
+      @mutex.synchronize do
+        @active_connections.each_value(&:finish)
+        @active_connections = {}
+      end
+    end
+
+    # Gets a connection for a given URI. This is for internal use only as it's
+    # subject to change (we've moved between HTTP client schemes in the past
+    # and may do it again).
+    #
+    # `uri` is expected to be a string.
+    def connection_for(uri)
+      @mutex.synchronize do
+        u = URI.parse(uri)
+        connection = @active_connections[[u.host, u.port]]
+
+        if connection.nil?
+          connection = create_connection(u)
+          connection.start
+
+          @active_connections[[u.host, u.port]] = connection
+        end
+
+        connection
+      end
+    end
+
+    # Executes an HTTP request to the given URI with the given method. Also
+    # allows a request body, headers, and query string to be specified.
+    def execute_request(method, uri, body: nil, headers: nil, query: nil,
+                        &block)
+      # Perform some basic argument validation because it's easy to get
+      # confused between strings and hashes for things like body and query
+      # parameters.
+      raise ArgumentError, "method should be a symbol" \
+        unless method.is_a?(Symbol)
+      raise ArgumentError, "uri should be a string" \
+        unless uri.is_a?(String)
+      raise ArgumentError, "body should be a string" \
+        if body && !body.is_a?(String)
+      raise ArgumentError, "headers should be a hash" \
+        if headers && !headers.is_a?(Hash)
+      raise ArgumentError, "query should be a string" \
+        if query && !query.is_a?(String)
+
+      @last_used = Util.monotonic_time
+
+      connection = connection_for(uri)
+
+      u = URI.parse(uri)
+      path = if query
+               u.path + "?" + query
+             else
+               u.path
+             end
+
+      method_name = method.to_s.upcase
+      has_response_body = method_name != "HEAD"
+      request = Net::HTTPGenericRequest.new(
+        method_name,
+        (body ? true : false),
+        has_response_body,
+        path,
+        headers
+      )
+
+      Util.log_debug("ConnectionManager starting request",
+                     method_name: method_name,
+                     path: path,
+                     process_id: Process.pid,
+                     thread_object_id: Thread.current.object_id,
+                     connection_manager_object_id: object_id,
+                     connection_object_id: connection.object_id,
+                     log_timestamp: Util.monotonic_time)
+
+      resp = @mutex.synchronize do
+        # The block parameter is special here. If a block is provided, the block
+        # is invoked with the Net::HTTPResponse. However, the body will not have
+        # been read yet in the block, and can be streamed by calling
+        # HTTPResponse#read_body.
+        connection.request(request, body, &block)
+      end
+
+      Util.log_debug("ConnectionManager request complete",
+                     method_name: method_name,
+                     path: path,
+                     process_id: Process.pid,
+                     thread_object_id: Thread.current.object_id,
+                     connection_manager_object_id: object_id,
+                     connection_object_id: connection.object_id,
+                     response_object_id: resp.object_id,
+                     log_timestamp: Util.monotonic_time)
+
+      resp
+    end
+
+    #
+    # private
+    #
+
+    # `uri` should be a parsed `URI` object.
+    private def create_connection(uri)
+      # These all come back as `nil` if no proxy is configured.
+      proxy_host, proxy_port, proxy_user, proxy_pass = proxy_parts
+
+      connection = Net::HTTP.new(uri.host, uri.port,
+                                 proxy_host, proxy_port,
+                                 proxy_user, proxy_pass)
+
+      # Time in seconds within which Net::HTTP will try to reuse an already
+      # open connection when issuing a new operation. Outside this window, Ruby
+      # will transparently close and re-open the connection without trying to
+      # reuse it.
+      #
+      # Ruby's default of 2 seconds is almost certainly too short. Here I've
+      # reused Go's default for `DefaultTransport`.
+      connection.keep_alive_timeout = 30
+
+      connection.open_timeout = config.open_timeout
+      connection.read_timeout = config.read_timeout
+      connection.write_timeout = config.write_timeout if connection.respond_to?(:write_timeout=)
+
+      connection.use_ssl = uri.scheme == "https"
+
+      if config.verify_ssl_certs
+        connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        connection.cert_store = config.ca_store
+      else
+        connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        warn_ssl_verify_none
+      end
+
+      connection
+    end
+
+    # `Net::HTTP` somewhat awkwardly requires each component of a proxy URI
+    # (host, port, etc.) rather than the URI itself. This method simply parses
+    # out those pieces to make passing them into a new connection a little less
+    # ugly.
+    private def proxy_parts
+      if config.proxy.nil?
+        [nil, nil, nil, nil]
+      else
+        u = URI.parse(config.proxy)
+        [u.host, u.port, u.user, u.password]
+      end
+    end
+
+    private def warn_ssl_verify_none
+      return if @verify_ssl_warned
+
+      @verify_ssl_warned = true
+      warn("WARNING: Running without SSL cert verification. " \
+           "You should never do this in production. " \
+           "Execute `Stripe.verify_ssl_certs = true` to enable " \
+           "verification.")
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/error_object.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Stripe
+  # Represents an error object as returned by the API.
+  #
+  # @see https://stripe.com/docs/api/errors
+  class ErrorObject < StripeObject
+    # Unlike other objects, we explicitly declare getter methods here. This
+    # is because the API doesn't return `null` values for fields on this
+    # object, rather the fields are omitted entirely. Not declaring the getter
+    # methods would cause users to run into `NoMethodError` exceptions and
+    # get in the way of generic error handling.
+
+    # For card errors, the ID of the failed charge.
+    def charge
+      @values[:charge]
+    end
+
+    # For some errors that could be handled programmatically, a short string
+    # indicating the error code reported.
+    def code
+      @values[:code]
+    end
+
+    # For card errors resulting from a card issuer decline, a short string
+    # indicating the card issuer's reason for the decline if they provide one.
+    def decline_code
+      @values[:decline_code]
+    end
+
+    # A URL to more information about the error code reported.
+    def doc_url
+      @values[:doc_url]
+    end
+
+    # A human-readable message providing more details about the error. For card
+    # errors, these messages can be shown to your users.
+    def message
+      @values[:message]
+    end
+
+    # If the error is parameter-specific, the parameter related to the error.
+    # For example, you can use this to display a message near the correct form
+    # field.
+    def param
+      @values[:param]
+    end
+
+    # The PaymentIntent object for errors returned on a request involving a
+    # PaymentIntent.
+    def payment_intent
+      @values[:payment_intent]
+    end
+
+    # The PaymentMethod object for errors returned on a request involving a
+    # PaymentMethod.
+    def payment_method
+      @values[:payment_method]
+    end
+
+    # The SetupIntent object for errors returned on a request involving a
+    # SetupIntent.
+    def setup_intent
+      @values[:setup_intent]
+    end
+
+    # The source object for errors returned on a request involving a source.
+    def source
+      @values[:source]
+    end
+
+    # The type of error returned. One of `api_error`, `card_error`,
+    # `idempotency_error`, or `invalid_request_error`.
+    def type
+      @values[:type]
+    end
+  end
+
+  # Represents on OAuth error returned by the OAuth API.
+  #
+  # @see https://stripe.com/docs/connect/oauth-reference#post-token-errors
+  class OAuthErrorObject < StripeObject
+    # A unique error code per error type.
+    def error
+      @values[:error]
+    end
+
+    # A human readable description of the error.
+    def error_description
+      @values[:error_description]
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/errors.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Stripe
+  # StripeError is the base error from which all other more specific Stripe
+  # errors derive.
+  class StripeError < StandardError
+    attr_reader :message, :code, :error, :http_body, :http_headers, :http_status, :json_body, :request_id
+
+    # Response contains a StripeResponse object that has some basic information
+    # about the response that conveyed the error.
+    attr_accessor :response # equivalent to #data
+
+    # Initializes a StripeError.
+    def initialize(message = nil, http_status: nil, http_body: nil, # rubocop:todo Lint/MissingSuper
+                   json_body: nil, http_headers: nil, code: nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @http_headers = http_headers || {}
+      @idempotent_replayed = @http_headers["idempotent-replayed"] == "true"
+      @json_body = json_body
+      @code = code
+      @request_id = @http_headers["request-id"]
+      @error = construct_error_object
+    end
+
+    def construct_error_object
+      return nil if @json_body.nil? || !@json_body.key?(:error)
+
+      # ErrorObject is shared between v1 and v2, so use original object_classes to find
+      ErrorObject.construct_from(@json_body[:error], {}, nil, :v1)
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+      id_string = @request_id.nil? ? "" : "(Request #{@request_id}) "
+      "#{status_string}#{id_string}#{@message}"
+    end
+  end
+
+  # AuthenticationError is raised when invalid credentials are used to connect
+  # to Stripe's servers.
+  class AuthenticationError < StripeError
+  end
+
+  # APIConnectionError is raised in the event that the SDK can't connect to
+  # Stripe's servers. That can be for a variety of different reasons from a
+  # downed network to a bad TLS certificate.
+  class APIConnectionError < StripeError
+  end
+
+  # APIError is a generic error that may be raised in cases where none of the
+  # other named errors cover the problem. It could also be raised in the case
+  # that a new error has been introduced in the API, but this version of the
+  # Ruby SDK doesn't know how to handle it.
+  class APIError < StripeError
+  end
+
+  # CardError is raised when a user enters a card that can't be charged for
+  # some reason.
+  class CardError < StripeError
+    attr_reader :param
+
+    def initialize(message, param, code: nil, http_status: nil, http_body: nil,
+                   json_body: nil, http_headers: nil)
+      super(message, http_status: http_status, http_body: http_body,
+                     json_body: json_body, http_headers: http_headers,
+                     code: code)
+      @param = param
+    end
+  end
+
+  # IdempotencyError is raised in cases where an idempotency key was used
+  # improperly.
+  class IdempotencyError < StripeError
+  end
+
+  # InvalidRequestError is raised when a request is initiated with invalid
+  # parameters.
+  class InvalidRequestError < StripeError
+    attr_accessor :param
+
+    def initialize(message, param, http_status: nil, http_body: nil,
+                   json_body: nil, http_headers: nil, code: nil)
+      super(message, http_status: http_status, http_body: http_body,
+                     json_body: json_body, http_headers: http_headers,
+                     code: code)
+      @param = param
+    end
+  end
+
+  # PermissionError is raised in cases where access was attempted on a resource
+  # that wasn't allowed.
+  class PermissionError < StripeError
+  end
+
+  # RateLimitError is raised in cases where an account is putting too much load
+  # on Stripe's API servers (usually by performing too many requests). Please
+  # back off on request rate.
+  class RateLimitError < StripeError
+  end
+
+  # SignatureVerificationError is raised when the signature verification for a
+  # webhook fails
+  class SignatureVerificationError < StripeError
+    attr_accessor :sig_header
+
+    def initialize(message, sig_header, http_body: nil)
+      super(message, http_body: http_body)
+      @sig_header = sig_header
+    end
+  end
+
+  module OAuth
+    # OAuthError is raised when the OAuth API returns an error.
+    class OAuthError < StripeError
+      def initialize(code, description, http_status: nil, http_body: nil,
+                     json_body: nil, http_headers: nil)
+        super(description, http_status: http_status, http_body: http_body,
+                           json_body: json_body, http_headers: http_headers,
+                           code: code)
+      end
+
+      def construct_error_object
+        return nil if @json_body.nil?
+
+        OAuthErrorObject.construct_from(@json_body, {}, nil, :v1)
+      end
+    end
+
+    # InvalidClientError is raised when the client doesn't belong to you, or
+    # the API key mode (live or test) doesn't match the client mode. Or the
+    # stripe_user_id doesn't exist or isn't connected to your application.
+    class InvalidClientError < OAuthError
+    end
+
+    # InvalidGrantError is raised when a specified code doesn't exist, is
+    # expired, has been used, or doesn't belong to you; a refresh token doesn't
+    # exist, or doesn't belong to you; or if an API key's mode (live or test)
+    # doesn't match the mode of a code or refresh token.
+    class InvalidGrantError < OAuthError
+    end
+
+    # InvalidRequestError is raised when a code, refresh token, or grant type
+    # parameter is not provided, but was required.
+    class InvalidRequestError < OAuthError
+    end
+
+    # InvalidScopeError is raised when an invalid scope parameter is provided.
+    class InvalidScopeError < OAuthError
+    end
+
+    # UnsupportedGrantTypeError is raised when an unuspported grant type
+    # parameter is specified.
+    class UnsupportedGrantTypeError < OAuthError
+    end
+
+    # UnsupportedResponseTypeError is raised when an unsupported response type
+    # parameter is specified.
+    class UnsupportedResponseTypeError < OAuthError
+    end
+  end
+
+  # class definitions: The beginning of the section generated from our OpenAPI spec
+  class RateLimitError < StripeError
+  end
+
+  class TemporarySessionExpiredError < StripeError
+  end
+  # class definitions: The end of the section generated from our OpenAPI spec
+end