bongloy 4.21.3

data/lib/stripe/api_resource.rb

@@ -0,0 +1,107 @@
+# 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
+
+    def self.class_name
+      name.split("::")[-1]
+    end
+
+    def self.resource_url
+      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/#{self::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)
+      unless %i[get post delete].include?(http_verb)
+        raise ArgumentError,
+              "Invalid http_verb value: #{http_verb.inspect}. Should be one " \
+              "of :get, :post or :delete."
+      end
+      http_path ||= name.to_s
+      define_singleton_method(name) do |id, params = {}, opts = {}|
+        unless id.is_a?(String)
+          raise ArgumentError,
+                "id should be a string representing the ID of an API resource"
+        end
+
+        url = "#{resource_url}/#{CGI.escape(id)}/#{CGI.escape(http_path)}"
+        resp, opts = request(http_verb, url, params, opts)
+        Util.convert_to_stripe_object(resp.data, opts)
+      end
+    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
+      resp, opts = request(:get, resource_url, @retrieve_params)
+      initialize_from(resp.data, opts)
+    end
+
+    def self.retrieve(id, opts = {})
+      opts = Util.normalize_opts(opts)
+      instance = new(id, opts)
+      instance.refresh
+      instance
+    end
+  end
+end

data/lib/stripe/errors.rb

@@ -0,0 +1,156 @@
+# 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
+
+    # Response contains a StripeResponse object that has some basic information
+    # about the response that conveyed the error.
+    attr_accessor :response
+
+    attr_reader :code
+    attr_reader :http_body
+    attr_reader :http_headers
+    attr_reader :http_status
+    attr_reader :json_body # equivalent to #data
+    attr_reader :request_id
+
+    # Initializes a StripeError.
+    def initialize(message = nil, http_status: nil, http_body: nil,
+                   json_body: nil, http_headers: nil, code: nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @http_headers = http_headers || {}
+      @json_body = json_body
+      @code = code
+      @request_id = @http_headers[:request_id]
+    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
+
+    # TODO: make code a keyword arg in next major release
+    def initialize(message, param, code, 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
+    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
+end

data/lib/stripe/list_object.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Stripe
+  class ListObject < StripeObject
+    include Enumerable
+    include Stripe::APIOperations::List
+    include Stripe::APIOperations::Request
+    include Stripe::APIOperations::Create
+
+    OBJECT_NAME = "list".freeze
+
+    # This accessor allows a `ListObject` to inherit various filters that were
+    # given to a predecessor. This allows for things like consistent limits,
+    # expansions, and predicates as a user pages through resources.
+    attr_accessor :filters
+
+    # An empty list object. This is returned from +next+ when we know that
+    # there isn't a next page in order to replicate the behavior of the API
+    # when it attempts to return a page beyond the last.
+    def self.empty_list(opts = {})
+      ListObject.construct_from({ data: [] }, opts)
+    end
+
+    def initialize(*args)
+      super
+      self.filters = {}
+    end
+
+    def [](key)
+      case key
+      when String, Symbol
+        super
+      else
+        raise ArgumentError,
+              "You tried to access the #{key.inspect} index, but ListObject " \
+              "types only support String keys. (HINT: List calls return an " \
+              "object with a 'data' (which is the data array). You likely " \
+              "want to call #data[#{key.inspect}])"
+      end
+    end
+
+    # Iterates through each resource in the page represented by the current
+    # `ListObject`.
+    #
+    # Note that this method makes no effort to fetch a new page when it gets to
+    # the end of the current page's resources. See also +auto_paging_each+.
+    def each(&blk)
+      data.each(&blk)
+    end
+
+    # Iterates through each resource in all pages, making additional fetches to
+    # the API as necessary.
+    #
+    # Note that this method will make as many API calls as necessary to fetch
+    # all resources. For more granular control, please see +each+ and
+    # +next_page+.
+    def auto_paging_each(&blk)
+      return enum_for(:auto_paging_each) unless block_given?
+
+      page = self
+      loop do
+        page.each(&blk)
+        page = page.next_page
+        break if page.empty?
+      end
+    end
+
+    # Returns true if the page object contains no elements.
+    def empty?
+      data.empty?
+    end
+
+    def retrieve(id, opts = {})
+      id, retrieve_params = Util.normalize_id(id)
+      resp, opts = request(:get, "#{resource_url}/#{CGI.escape(id)}",
+                           retrieve_params, opts)
+      Util.convert_to_stripe_object(resp.data, opts)
+    end
+
+    # Fetches the next page in the resource list (if there is one).
+    #
+    # This method will try to respect the limit of the current page. If none
+    # was given, the default limit will be fetched again.
+    def next_page(params = {}, opts = {})
+      return self.class.empty_list(opts) unless has_more
+      last_id = data.last.id
+
+      params = filters.merge(starting_after: last_id).merge(params)
+
+      list(params, opts)
+    end
+
+    # Fetches the previous page in the resource list (if there is one).
+    #
+    # This method will try to respect the limit of the current page. If none
+    # was given, the default limit will be fetched again.
+    def previous_page(params = {}, opts = {})
+      first_id = data.first.id
+
+      params = filters.merge(ending_before: first_id).merge(params)
+
+      list(params, opts)
+    end
+
+    def resource_url
+      url ||
+        raise(ArgumentError, "List object does not contain a 'url' field.")
+    end
+  end
+end

data/lib/stripe/oauth.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Stripe
+  module OAuth
+    module OAuthOperations
+      extend APIOperations::Request::ClassMethods
+
+      def self.request(method, url, params, opts)
+        opts = Util.normalize_opts(opts)
+        opts[:client] ||= StripeClient.active_client
+        opts[:api_base] ||= Stripe.connect_base
+
+        super(method, url, params, opts)
+      end
+    end
+
+    def self.get_client_id(params = {})
+      client_id = params[:client_id] || Stripe.client_id
+      unless client_id
+        raise AuthenticationError, "No client_id provided. " \
+          'Set your client_id using "Stripe.client_id = <CLIENT-ID>". ' \
+          "You can find your client_ids in your Stripe dashboard at " \
+          "https://dashboard.stripe.com/account/applications/settings, " \
+          "after registering your account as a platform. See " \
+          "https://stripe.com/docs/connect/standalone-accounts for details, " \
+          "or email support@stripe.com if you have any questions."
+      end
+      client_id
+    end
+
+    def self.authorize_url(params = {}, opts = {})
+      base = opts[:connect_base] || Stripe.connect_base
+
+      path = "/oauth/authorize"
+      path = "/express" + path if opts[:express]
+
+      params[:client_id] = get_client_id(params)
+      params[:response_type] ||= "code"
+      query = Util.encode_parameters(params)
+
+      "#{base}#{path}?#{query}"
+    end
+
+    def self.token(params = {}, opts = {})
+      opts = Util.normalize_opts(opts)
+      resp, opts = OAuthOperations.request(
+        :post, "/oauth/token", params, opts
+      )
+      # This is just going to return a generic StripeObject, but that's okay
+      Util.convert_to_stripe_object(resp.data, opts)
+    end
+
+    def self.deauthorize(params = {}, opts = {})
+      opts = Util.normalize_opts(opts)
+      params[:client_id] = get_client_id(params)
+      resp, opts = OAuthOperations.request(
+        :post, "/oauth/deauthorize", params, opts
+      )
+      # This is just going to return a generic StripeObject, but that's okay
+      Util.convert_to_stripe_object(resp.data, opts)
+    end
+  end
+end

data/lib/stripe/object_types.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/LineLength
+# rubocop:disable Metrics/MethodLength
+
+module Stripe
+  module ObjectTypes
+    def self.object_names_to_classes
+      {
+        # data structures
+        ListObject::OBJECT_NAME => ListObject,
+
+        # business objects
+        Account::OBJECT_NAME => Account,
+        AccountLink::OBJECT_NAME => AccountLink,
+        AlipayAccount::OBJECT_NAME => AlipayAccount,
+        ApplePayDomain::OBJECT_NAME => ApplePayDomain,
+        ApplicationFee::OBJECT_NAME => ApplicationFee,
+        ApplicationFeeRefund::OBJECT_NAME => ApplicationFeeRefund,
+        Balance::OBJECT_NAME => Balance,
+        BalanceTransaction::OBJECT_NAME => BalanceTransaction,
+        BankAccount::OBJECT_NAME => BankAccount,
+        BitcoinReceiver::OBJECT_NAME => BitcoinReceiver,
+        BitcoinTransaction::OBJECT_NAME => BitcoinTransaction,
+        Capability::OBJECT_NAME => Capability,
+        Card::OBJECT_NAME => Card,
+        Charge::OBJECT_NAME => Charge,
+        Checkout::Session::OBJECT_NAME => Checkout::Session,
+        CountrySpec::OBJECT_NAME => CountrySpec,
+        Coupon::OBJECT_NAME => Coupon,
+        CreditNote::OBJECT_NAME => CreditNote,
+        Customer::OBJECT_NAME => Customer,
+        CustomerBalanceTransaction::OBJECT_NAME => CustomerBalanceTransaction,
+        Discount::OBJECT_NAME => Discount,
+        Dispute::OBJECT_NAME => Dispute,
+        EphemeralKey::OBJECT_NAME => EphemeralKey,
+        Event::OBJECT_NAME => Event,
+        ExchangeRate::OBJECT_NAME => ExchangeRate,
+        File::OBJECT_NAME => File,
+        File::OBJECT_NAME_ALT => File,
+        FileLink::OBJECT_NAME => FileLink,
+        Invoice::OBJECT_NAME => Invoice,
+        InvoiceItem::OBJECT_NAME => InvoiceItem,
+        InvoiceLineItem::OBJECT_NAME => InvoiceLineItem,
+        IssuerFraudRecord::OBJECT_NAME => IssuerFraudRecord,
+        Issuing::Authorization::OBJECT_NAME => Issuing::Authorization,
+        Issuing::Card::OBJECT_NAME => Issuing::Card,
+        Issuing::CardDetails::OBJECT_NAME => Issuing::CardDetails,
+        Issuing::Cardholder::OBJECT_NAME => Issuing::Cardholder,
+        Issuing::Dispute::OBJECT_NAME => Issuing::Dispute,
+        Issuing::Transaction::OBJECT_NAME => Issuing::Transaction,
+        LoginLink::OBJECT_NAME => LoginLink,
+        Order::OBJECT_NAME => Order,
+        OrderReturn::OBJECT_NAME => OrderReturn,
+        PaymentIntent::OBJECT_NAME => PaymentIntent,
+        PaymentMethod::OBJECT_NAME => PaymentMethod,
+        Payout::OBJECT_NAME => Payout,
+        Person::OBJECT_NAME => Person,
+        Plan::OBJECT_NAME => Plan,
+        Product::OBJECT_NAME => Product,
+        Radar::EarlyFraudWarning::OBJECT_NAME => Radar::EarlyFraudWarning,
+        Radar::ValueList::OBJECT_NAME => Radar::ValueList,
+        Radar::ValueListItem::OBJECT_NAME => Radar::ValueListItem,
+        Recipient::OBJECT_NAME => Recipient,
+        RecipientTransfer::OBJECT_NAME => RecipientTransfer,
+        Refund::OBJECT_NAME => Refund,
+        Reporting::ReportRun::OBJECT_NAME => Reporting::ReportRun,
+        Reporting::ReportType::OBJECT_NAME => Reporting::ReportType,
+        Reversal::OBJECT_NAME => Reversal,
+        Review::OBJECT_NAME => Review,
+        SKU::OBJECT_NAME => SKU,
+        SetupIntent::OBJECT_NAME => SetupIntent,
+        Sigma::ScheduledQueryRun::OBJECT_NAME => Sigma::ScheduledQueryRun,
+        Source::OBJECT_NAME => Source,
+        SourceTransaction::OBJECT_NAME => SourceTransaction,
+        Subscription::OBJECT_NAME => Subscription,
+        SubscriptionItem::OBJECT_NAME => SubscriptionItem,
+        SubscriptionSchedule::OBJECT_NAME => SubscriptionSchedule,
+        SubscriptionScheduleRevision::OBJECT_NAME => SubscriptionScheduleRevision,
+        TaxId::OBJECT_NAME => TaxId,
+        TaxRate::OBJECT_NAME => TaxRate,
+        Terminal::ConnectionToken::OBJECT_NAME => Terminal::ConnectionToken,
+        Terminal::Location::OBJECT_NAME => Terminal::Location,
+        Terminal::Reader::OBJECT_NAME => Terminal::Reader,
+        ThreeDSecure::OBJECT_NAME => ThreeDSecure,
+        Token::OBJECT_NAME => Token,
+        Topup::OBJECT_NAME => Topup,
+        Transfer::OBJECT_NAME => Transfer,
+        UsageRecord::OBJECT_NAME => UsageRecord,
+        UsageRecordSummary::OBJECT_NAME => UsageRecordSummary,
+        WebhookEndpoint::OBJECT_NAME => WebhookEndpoint,
+      }
+    end
+  end
+end
+
+# rubocop:enable Metrics/LineLength
+# rubocop:enable Metrics/MethodLength