stripe 5.55.0 → 13.5.1

data/lib/stripe/stripe_configuration.rb

@@ -25,26 +25,11 @@ module Stripe
   # If `.logger` is set, the value of `.log_level` is ignored. The decision on
   # what levels to print is entirely deferred to the logger.
   class StripeConfiguration
-    attr_accessor :api_key
-    attr_accessor :api_version
-    attr_accessor :client_id
-    attr_accessor :enable_telemetry
-    attr_accessor :logger
-    attr_accessor :stripe_account
-
-    attr_reader :api_base
-    attr_reader :uploads_base
-    attr_reader :connect_base
-    attr_reader :ca_bundle_path
-    attr_reader :log_level
-    attr_reader :initial_network_retry_delay
-    attr_reader :max_network_retries
-    attr_reader :max_network_retry_delay
-    attr_reader :open_timeout
-    attr_reader :read_timeout
-    attr_reader :write_timeout
-    attr_reader :proxy
-    attr_reader :verify_ssl_certs
+    attr_accessor :api_key, :api_version, :client_id, :enable_telemetry, :logger, :stripe_account, :stripe_context
+
+    attr_reader :api_base, :uploads_base, :connect_base, :meter_events_base, :base_addresses, :ca_bundle_path,
+                :log_level, :initial_network_retry_delay, :max_network_retries, :max_network_retry_delay,
+                :open_timeout, :read_timeout, :write_timeout, :proxy, :verify_ssl_certs
 
     def self.setup
       new.tap do |instance|
@@ -52,6 +37,25 @@ module Stripe
       end
     end
 
+    # Set options to the StripeClient configured options, if valid as a client option and provided
+    # Otherwise, for user configurable global options, set them to the global configuration
+    # For all other options, set them to the StripeConfiguration default value
+    def self.client_init(config_opts)
+      global_config = Stripe.config
+      imported_options = USER_CONFIGURABLE_GLOBAL_OPTIONS - StripeClient::CLIENT_OPTIONS
+      client_config = StripeConfiguration.setup do |instance|
+        imported_options.each do |key|
+          begin
+            instance.public_send("#{key}=", global_config.public_send(key)) if global_config.respond_to?(key)
+          rescue NotImplementedError => e
+            # In Ruby <= 2.5, we can't set write_timeout on Net::HTTP, log an error and continue
+            Util.log_error("Failed to set #{key} on client configuration: #{e}")
+          end
+        end
+      end
+      client_config.reverse_duplicate_merge(config_opts)
+    end
+
     # Create a new config based off an existing one. This is useful when the
     # caller wants to override the global configuration
     def reverse_duplicate_merge(hash)
@@ -59,25 +63,32 @@ module Stripe
         hash.each do |option, value|
           instance.public_send("#{option}=", value)
         end
+        instance.send("instance_variable_set", "@base_addresses",
+                      { api: instance.api_base, connect: instance.connect_base,
+                        files: instance.uploads_base, meter_events: instance.meter_events_base, })
       end
     end
 
     def initialize
+      @api_version = ApiVersion::CURRENT
       @ca_bundle_path = Stripe::DEFAULT_CA_BUNDLE_PATH
       @enable_telemetry = true
       @verify_ssl_certs = true
 
-      @max_network_retries = 0
+      @max_network_retries = 2
       @initial_network_retry_delay = 0.5
-      @max_network_retry_delay = 2
+      @max_network_retry_delay = 5
 
       @open_timeout = 30
       @read_timeout = 80
       @write_timeout = 30
 
-      @api_base = "https://api.stripe.com"
-      @connect_base = "https://connect.stripe.com"
-      @uploads_base = "https://files.stripe.com"
+      @api_base = DEFAULT_API_BASE
+      @connect_base = DEFAULT_CONNECT_BASE
+      @uploads_base = DEFAULT_UPLOAD_BASE
+      @meter_events_base = DEFAULT_METER_EVENTS_BASE
+      @base_addresses = { api: @api_base, connect: @connect_base, files: @uploads_base,
+                          meter_events: @meter_events_base, }
     end
 
     def log_level=(val)
@@ -86,13 +97,16 @@ module Stripe
         val = Stripe::LEVEL_DEBUG
       elsif val == "info"
         val = Stripe::LEVEL_INFO
+      elsif val == "error"
+        val = Stripe::LEVEL_ERROR
       end
 
       levels = [Stripe::LEVEL_INFO, Stripe::LEVEL_DEBUG, Stripe::LEVEL_ERROR]
 
       if !val.nil? && !levels.include?(val)
         raise ArgumentError,
-              "log_level should only be set to `nil`, `debug` or `info`"
+              "log_level should only be set to `nil`, `debug`, `info`, " \
+              "or `error`"
       end
       @log_level = val
     end
@@ -111,46 +125,53 @@ module Stripe
 
     def open_timeout=(open_timeout)
       @open_timeout = open_timeout
-      StripeClient.clear_all_connection_managers(config: self)
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def read_timeout=(read_timeout)
       @read_timeout = read_timeout
-      StripeClient.clear_all_connection_managers(config: self)
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def write_timeout=(write_timeout)
-      unless Net::HTTP.instance_methods.include?(:write_timeout=)
-        raise NotImplementedError
-      end
+      raise NotImplementedError unless Net::HTTP.instance_methods.include?(:write_timeout=)
 
       @write_timeout = write_timeout
-      StripeClient.clear_all_connection_managers(config: self)
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def proxy=(proxy)
       @proxy = proxy
-      StripeClient.clear_all_connection_managers(config: self)
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def verify_ssl_certs=(verify_ssl_certs)
       @verify_ssl_certs = verify_ssl_certs
-      StripeClient.clear_all_connection_managers(config: self)
+      APIRequestor.clear_all_connection_managers(config: self)
+    end
+
+    def meter_events_base=(meter_events_base)
+      @meter_events_base = meter_events_base
+      @base_addresses[:meter_events] = meter_events_base
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def uploads_base=(uploads_base)
       @uploads_base = uploads_base
-      StripeClient.clear_all_connection_managers(config: self)
+      @base_addresses[:files] = uploads_base
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def connect_base=(connect_base)
       @connect_base = connect_base
-      StripeClient.clear_all_connection_managers(config: self)
+      @base_addresses[:connect] = connect_base
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def api_base=(api_base)
       @api_base = api_base
-      StripeClient.clear_all_connection_managers(config: self)
+      @base_addresses[:api] = api_base
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def ca_bundle_path=(path)
@@ -159,7 +180,7 @@ module Stripe
       # empty this field so a new store is initialized
       @ca_store = nil
 
-      StripeClient.clear_all_connection_managers(config: self)
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     # A certificate store initialized from the the bundle in #ca_bundle_path and
@@ -173,10 +194,10 @@ module Stripe
     # and is itself not thread safe.
     def ca_store
       @ca_store ||= begin
-                      store = OpenSSL::X509::Store.new
-                      store.add_file(ca_bundle_path)
-                      store
-                    end
+        store = OpenSSL::X509::Store.new
+        store.add_file(ca_bundle_path)
+        store
+      end
     end
 
     def enable_telemetry?

data/lib/stripe/stripe_object.rb

@@ -4,6 +4,8 @@ module Stripe
   class StripeObject
     include Enumerable
 
+    attr_reader :last_response
+
     @@permanent_attributes = Set.new([:id]) # rubocop:disable Style/ClassVars
 
     # The default :id method is deprecated and isn't useful to us
@@ -70,7 +72,8 @@ module Stripe
       @additive_params.include?(name)
     end
 
-    def initialize(id = nil, opts = {})
+    def initialize(id = nil, opts = {}, api_mode = :v1, requestor = nil)
+      @api_mode = api_mode
       id, @retrieve_params = Util.normalize_id(id)
       @opts = Util.normalize_opts(opts)
       @original_values = {}
@@ -80,13 +83,15 @@ module Stripe
       @unsaved_values = Set.new
       @transient_values = Set.new
       @values[:id] = id if id
+      @last_response = nil
+      @requestor = requestor || APIRequestor.active_requestor
     end
 
-    def self.construct_from(values, opts = {})
+    def self.construct_from(values, opts = {}, last_response = nil, api_mode = :v1, requestor = nil)
       values = Stripe::Util.symbolize_names(values)
 
       # work around protected #initialize_from for now
-      new(values[:id]).send(:initialize_from, values, opts)
+      new(values[:id]).send(:initialize_from, values, opts, last_response, api_mode: api_mode, requestor: requestor)
     end
 
     # Determines the equality of two Stripe objects. Stripe objects are
@@ -148,7 +153,7 @@ module Stripe
     def update_attributes(values, opts = {}, dirty: true)
       values.each do |k, v|
         add_accessors([k], values) unless metaclass.method_defined?(k.to_sym)
-        @values[k] = Util.convert_to_stripe_object(v, opts)
+        @values[k] = Util.convert_to_stripe_object(v, opts, api_mode: @api_mode, requestor: @requestor)
         dirty_value!(@values[k]) if dirty
         @unsaved_values.add(k)
       end
@@ -217,20 +222,22 @@ module Stripe
     # This allows us to remove certain features that cannot or should not be
     # serialized.
     def marshal_dump
-      # The StripeClient instance in @opts is not serializable and is not
+      # The APIRequestor instance in @opts is not serializable and is not
       # really a property of the StripeObject, so we exclude it when
       # dumping
       opts = @opts.clone
+
+      # TODO: (major) Remove the :client option. This is not explicitly supported as a user-specified option.
       opts.delete(:client)
       [@values, opts]
     end
 
     # Implements custom decoding for Ruby's Marshal. Consumes data that's
     # produced by #marshal_dump.
-    def marshal_load(data)
+    def marshal_load(data, api_mode: :v1)
       values, opts = data
-      initialize(values[:id])
-      initialize_from(values, opts)
+      initialize(values[:id], api_mode: api_mode)
+      initialize_from(values, opts, api_mode: api_mode, requestor: @requestor)
     end
 
     def serialize_params(options = {})
@@ -320,8 +327,8 @@ module Stripe
               # Here we swallow that error and issue a warning so at least
               # the program doesn't crash.
               warn("WARNING: Unable to remove method `#{method_name}`; " \
-                "if custom, please consider renaming to a name that doesn't " \
-                "collide with an API property name.")
+                   "if custom, please consider renaming to a name that doesn't " \
+                   "collide with an API property name.")
             end
           end
         end
@@ -351,17 +358,15 @@ module Stripe
           define_method(:"#{k}=") do |v|
             if v == ""
               raise ArgumentError, "You cannot set #{k} to an empty string. " \
-                "We interpret empty strings as nil in requests. " \
-                "You may set (object).#{k} = nil to delete the property."
+                                   "We interpret empty strings as nil in requests. " \
+                                   "You may set (object).#{k} = nil to delete the property."
             end
-            @values[k] = Util.convert_to_stripe_object(v, @opts)
+            @values[k] = Util.convert_to_stripe_object(v, @opts, api_mode: @api_mode, requestor: @requestor)
             dirty_value!(@values[k])
             @unsaved_values.add(k)
           end
 
-          if [FalseClass, TrueClass].include?(values[k].class)
-            define_method(:"#{k}?") { @values[k] }
-          end
+          define_method(:"#{k}?") { @values[k] } if [FalseClass, TrueClass].include?(values[k].class)
         end
       end
     end
@@ -369,7 +374,6 @@ module Stripe
     # Disabling the cop because it's confused by the fact that the methods are
     # protected, but we do define `#respond_to_missing?` just below. Hopefully
     # this is fixed in more recent Rubocop versions.
-    # rubocop:disable Style/MissingRespondToMissing
     protected def method_missing(name, *args)
       # TODO: only allow setting in updateable classes.
       if name.to_s.end_with?("=")
@@ -405,16 +409,14 @@ module Stripe
 
         raise NoMethodError,
               e.message + ".  HINT: The '#{name}' attribute was set in the " \
-              "past, however.  It was then wiped when refreshing the object " \
-              "with the result returned by Stripe's API, probably as a " \
-              "result of a save().  The attributes currently available on " \
-              "this object are: #{@values.keys.join(', ')}"
+                          "past, however.  It was then wiped when refreshing the object " \
+                          "with the result returned by Stripe's API, probably as a " \
+                          "result of a save().  The attributes currently available on " \
+                          "this object are: #{@values.keys.join(', ')}"
       end
     end
-    # rubocop:enable Style/MissingRespondToMissing
-
     protected def respond_to_missing?(symbol, include_private = false)
-      @values && @values.key?(symbol) || super
+      (@values && @values.key?(symbol)) || super
     end
 
     # Re-initializes the object based on a hash of values (usually one that's
@@ -429,13 +431,17 @@ module Stripe
     # * +:opts:+ Options for StripeObject like an API key.
     # * +:partial:+ Indicates that the re-initialization should not attempt to
     #   remove accessors.
-    protected def initialize_from(values, opts, partial = false)
+    protected def initialize_from(values, opts, last_response = nil, api_mode:, requestor: nil)
+      @api_mode = api_mode
+      @last_response = last_response
+      @requestor = requestor
+
       @opts = Util.normalize_opts(opts)
 
       # the `#send` is here so that we can keep this method private
-      @original_values = self.class.send(:deep_copy, values)
+      @original_values = self.class.send(:deep_copy, values, api_mode: api_mode)
 
-      removed = partial ? Set.new : Set.new(@values.keys - values.keys)
+      removed = Set.new(@values.keys - values.keys)
       added = Set.new(values.keys - @values.keys)
 
       # Wipe old state before setting new.  This is useful for e.g. updating a
@@ -460,7 +466,21 @@ module Stripe
       self
     end
 
-    protected def serialize_params_value(value, original, unsaved, force,
+    # Should only be for v2 events and lists, for now.
+    protected def _request(method:, path:, base_address:, params: {}, opts: {})
+      req_opts = RequestOptions.extract_opts_from_hash(opts)
+      req_opts = RequestOptions.combine_opts(@opts, req_opts)
+      @requestor.execute_request(
+        method,
+        path,
+        base_address,
+        params: params,
+        opts: req_opts
+      )
+    end
+
+    # rubocop:todo Metrics/PerceivedComplexity
+    protected def serialize_params_value(value, original, unsaved, force, # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
                                          key: nil)
       if value.nil?
         ""
@@ -494,8 +514,8 @@ module Stripe
           value
         else
           raise ArgumentError, "Cannot save property `#{key}` containing " \
-            "an API resource. It doesn't appear to be persisted and is " \
-            "not marked as `save_with_parent`."
+                               "an API resource. It doesn't appear to be persisted and is " \
+                               "not marked as `save_with_parent`."
         end
 
       elsif value.is_a?(Array)
@@ -515,7 +535,7 @@ module Stripe
       # example by appending a new hash onto `additional_owners` for an
       # account.
       elsif value.is_a?(Hash)
-        Util.convert_to_stripe_object(value, @opts).serialize_params
+        Util.convert_to_stripe_object(value, @opts, api_mode: @api_mode, requestor: @requestor).serialize_params
 
       elsif value.is_a?(StripeObject)
         update = value.serialize_params(force: force)
@@ -535,24 +555,26 @@ module Stripe
         value
       end
     end
+    # rubocop:enable Metrics/PerceivedComplexity
 
     # Produces a deep copy of the given object including support for arrays,
     # hashes, and StripeObjects.
-    private_class_method def self.deep_copy(obj)
+    private_class_method def self.deep_copy(obj, api_mode:)
       case obj
       when Array
-        obj.map { |e| deep_copy(e) }
+        obj.map { |e| deep_copy(e, api_mode: api_mode) }
       when Hash
         obj.each_with_object({}) do |(k, v), copy|
-          copy[k] = deep_copy(v)
+          copy[k] = deep_copy(v, api_mode: api_mode)
           copy
         end
       when StripeObject
         obj.class.construct_from(
-          deep_copy(obj.instance_variable_get(:@values)),
-          obj.instance_variable_get(:@opts).select do |k, _v|
-            Util::OPTS_COPYABLE.include?(k)
-          end
+          deep_copy(obj.instance_variable_get(:@values), api_mode: api_mode),
+          RequestOptions.copyable(obj.instance_variable_get(:@opts)),
+          nil,
+          api_mode,
+          obj.instance_variable_get(:@requestor)
         )
       else
         obj

data/lib/stripe/stripe_response.rb

@@ -41,9 +41,7 @@ module Stripe
 
     def [](name)
       values = @hash[name.downcase]
-      if values && values.count > 1
-        warn("Duplicate header values for `#{name}`; returning only first")
-      end
+      warn("Duplicate header values for `#{name}`; returning only first") if values && values.count > 1
       values ? values.first : nil
     end
   end

data/lib/stripe/stripe_service.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+# typed: true
+
+module Stripe
+  class StripeService
+    # Initializes a new StripeService
+    def initialize(requestor)
+      @requestor = requestor
+    end
+
+    def request(method:, path:, base_address:, params: {}, opts: {})
+      @requestor.execute_request(
+        method,
+        path,
+        base_address,
+        params: params,
+        opts: RequestOptions.extract_opts_from_hash(opts)
+      )
+    end
+
+    def request_stream(method:, path:, base_address:, params: {}, opts: {}, &read_body_chunk_block)
+      @requestor.execute_request_stream(
+        method,
+        path,
+        base_address,
+        params: params,
+        opts: RequestOptions.extract_opts_from_hash(opts),
+        &read_body_chunk_block
+      )
+    end
+  end
+end

data/lib/stripe/thin_event.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Stripe
+  class EventReasonRequest
+    attr_reader :id, :idempotency_key
+
+    def initialize(event_reason_request_payload = {})
+      @id = event_reason_request_payload[:id]
+      @idempotency_key = event_reason_request_payload[:idempotency_key]
+    end
+  end
+
+  class EventReason
+    attr_reader :type, :request
+
+    def initialize(event_reason_payload = {})
+      @type = event_reason_payload[:type]
+      @request = EventReasonRequest.new(event_reason_payload[:request])
+    end
+  end
+
+  class ThinEvent
+    attr_reader :id, :type, :created, :context, :related_object, :livemode, :reason
+
+    def initialize(event_payload = {})
+      @id = event_payload[:id]
+      @type = event_payload[:type]
+      @created = event_payload[:created]
+      @context = event_payload[:context]
+      @livemode = event_payload[:livemode]
+      @related_object = event_payload[:related_object]
+      return if event_payload[:reason].nil?
+
+      @reason = EventReason.new(event_payload[:reason])
+    end
+  end
+end