mirror of
https://github.com/stripe/stripe-ruby.git
synced 2025-06-03 00:01:47 -04:00
7bbc6ef2e5
Prior to my last major serialization refactor, there was a check in the
code that would remove any subobjects from serialization that were of
their own proper resource type (for example, if a charge contained a
customer, that customer would be removed).
What I didn't realize at the time is that the old serialization code had
a bug/quirk that would allow *certain types* of subobjects that were API
resources to make it through unscathed.
In short, the behavior requirement here is *directly* contradictory.
There was a test in place that would make sure that `customer` was
removed from this hash:
``` ruby
{
:id => 'ch_id',
:object => 'charge',
:customer => {
:object => 'customer',
:id => 'customer_id'
}
}
```
But, as reported in #406, we expect, and indeed need, for `source` (a
card) to make it through to the API in this hash:
``` ruby
{
:id => 'cus_id',
:object => 'customer',
:source => {
:object => 'card',
:id => 'card_id'
}
}
```
My proposal here is to just remove the check on serializing API
resources. The normal code that only sends up keys/hashes that have
changed is still in place, so in the first example, `customer` still
isn't sent unless the user has directly manipulated a field on that
subobject. I propose that in those cases we allow the API itself to
reject the request rather than try to cut it off at the client level.
Unfortunately, there is some possibility that removing those API
resources is important for some reason, but of course there's no
documentation on it beyond the after-the-fact post-justification that I
wrote during my last refactor. I can't think of any reason that it would
be too destructive, but there is some level of risk.
398 lines
12 KiB
Ruby
398 lines
12 KiB
Ruby
module Stripe
|
|
class StripeObject
|
|
include Enumerable
|
|
|
|
@@permanent_attributes = Set.new([:id])
|
|
|
|
# The default :id method is deprecated and isn't useful to us
|
|
if method_defined?(:id)
|
|
undef :id
|
|
end
|
|
|
|
def initialize(id=nil, opts={})
|
|
id, @retrieve_params = Util.normalize_id(id)
|
|
@opts = Util.normalize_opts(opts)
|
|
@original_values = {}
|
|
@values = {}
|
|
# This really belongs in APIResource, but not putting it there allows us
|
|
# to have a unified inspect method
|
|
@unsaved_values = Set.new
|
|
@transient_values = Set.new
|
|
@values[:id] = id if id
|
|
end
|
|
|
|
def self.construct_from(values, opts={})
|
|
values = Stripe::Util.symbolize_names(values)
|
|
|
|
# work around protected #initialize_from for now
|
|
self.new(values[:id]).send(:initialize_from, values, opts)
|
|
end
|
|
|
|
# Determines the equality of two Stripe objects. Stripe objects are
|
|
# considered to be equal if they have the same set of values and each one
|
|
# of those values is the same.
|
|
def ==(other)
|
|
@values == other.instance_variable_get(:@values)
|
|
end
|
|
|
|
# Indicates whether or not the resource has been deleted on the server.
|
|
# Note that some, but not all, resources can indicate whether they have
|
|
# been deleted.
|
|
def deleted?
|
|
@values.fetch(:deleted, false)
|
|
end
|
|
|
|
def to_s(*args)
|
|
JSON.pretty_generate(@values)
|
|
end
|
|
|
|
def inspect
|
|
id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
|
|
"#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@values)
|
|
end
|
|
|
|
# Re-initializes the object based on a hash of values (usually one that's
|
|
# come back from an API call). Adds or removes value accessors as necessary
|
|
# and updates the state of internal data.
|
|
#
|
|
# Please don't use this method. If you're trying to do mass assignment, try
|
|
# #initialize_from instead.
|
|
def refresh_from(values, opts, partial=false)
|
|
initialize_from(values, opts, partial)
|
|
end
|
|
extend Gem::Deprecate
|
|
deprecate :refresh_from, "#update_attributes", 2016, 01
|
|
|
|
# Mass assigns attributes on the model.
|
|
#
|
|
# This is a version of +update_attributes+ that takes some extra options
|
|
# for internal use.
|
|
#
|
|
# ==== Attributes
|
|
#
|
|
# * +values+ - Hash of values to use to update the current attributes of
|
|
# the object.
|
|
# * +:opts+ Options for StripeObject like an API key.
|
|
#
|
|
# ==== Options
|
|
#
|
|
# * +:dirty+ Whether values should be initiated as "dirty" (unsaved) and
|
|
# which applies only to new StripeObjects being ininiated under this
|
|
# StripeObject. Defaults to true.
|
|
def update_attributes(values, opts = {}, method_options = {})
|
|
# Default to true. TODO: Convert to optional arguments after we're off
|
|
# 1.9 which will make this quite a bit more clear.
|
|
dirty = method_options.fetch(:dirty, true)
|
|
|
|
values.each do |k, v|
|
|
@values[k] = Util.convert_to_stripe_object(v, opts)
|
|
dirty_value!(@values[k]) if dirty
|
|
@unsaved_values.add(k)
|
|
end
|
|
end
|
|
|
|
def [](k)
|
|
@values[k.to_sym]
|
|
end
|
|
|
|
def []=(k, v)
|
|
send(:"#{k}=", v)
|
|
end
|
|
|
|
def keys
|
|
@values.keys
|
|
end
|
|
|
|
def values
|
|
@values.values
|
|
end
|
|
|
|
def to_json(*a)
|
|
JSON.generate(@values)
|
|
end
|
|
|
|
def as_json(*a)
|
|
@values.as_json(*a)
|
|
end
|
|
|
|
def to_hash
|
|
maybe_to_hash = lambda do |value|
|
|
value.respond_to?(:to_hash) ? value.to_hash : value
|
|
end
|
|
|
|
@values.inject({}) do |acc, (key, value)|
|
|
acc[key] = case value
|
|
when Array
|
|
value.map(&maybe_to_hash)
|
|
else
|
|
maybe_to_hash.call(value)
|
|
end
|
|
acc
|
|
end
|
|
end
|
|
|
|
def each(&blk)
|
|
@values.each(&blk)
|
|
end
|
|
|
|
def _dump(level)
|
|
Marshal.dump([@values, @opts])
|
|
end
|
|
|
|
def self._load(args)
|
|
values, opts = Marshal.load(args)
|
|
construct_from(values, opts)
|
|
end
|
|
|
|
if RUBY_VERSION < '1.9.2'
|
|
def respond_to?(symbol)
|
|
@values.has_key?(symbol) || super
|
|
end
|
|
end
|
|
|
|
# Sets all keys within the StripeObject as unsaved so that they will be
|
|
# included with an update when #serialize_params is called. This method is
|
|
# also recursive, so any StripeObjects contained as values or which are
|
|
# values in a tenant array are also marked as dirty.
|
|
def dirty!
|
|
@unsaved_values = Set.new(@values.keys)
|
|
@values.each do |k, v|
|
|
dirty_value!(v)
|
|
end
|
|
end
|
|
|
|
def serialize_params(options = {})
|
|
update_hash = {}
|
|
|
|
@values.each do |k, v|
|
|
# There are a few reasons that we may want to add in a parameter for
|
|
# update:
|
|
#
|
|
# 1. The `force` option has been set.
|
|
# 2. We know that it was modified.
|
|
# 3. Its value is a StripeObject. A StripeObject may contain modified
|
|
# values within in that its parent StripeObject doesn't know about.
|
|
#
|
|
unsaved = @unsaved_values.include?(k)
|
|
if options[:force] || unsaved || v.is_a?(StripeObject)
|
|
update_hash[k.to_sym] =
|
|
serialize_params_value(@values[k], @original_values[k], unsaved, options[:force])
|
|
end
|
|
end
|
|
|
|
# a `nil` that makes it out of `#serialize_params_value` signals an empty
|
|
# value that we shouldn't appear in the serialized form of the object
|
|
update_hash.reject! { |_, v| v == nil }
|
|
|
|
update_hash
|
|
end
|
|
|
|
class << self
|
|
# This class method has been deprecated in favor of the instance method
|
|
# of the same name.
|
|
def serialize_params(obj, options = {})
|
|
obj.serialize_params(options)
|
|
end
|
|
extend Gem::Deprecate
|
|
deprecate :serialize_params, "#serialize_params", 2016, 9
|
|
end
|
|
|
|
protected
|
|
|
|
def metaclass
|
|
class << self; self; end
|
|
end
|
|
|
|
def protected_fields
|
|
[]
|
|
end
|
|
|
|
def remove_accessors(keys)
|
|
f = protected_fields
|
|
metaclass.instance_eval do
|
|
keys.each do |k|
|
|
next if f.include?(k)
|
|
next if @@permanent_attributes.include?(k)
|
|
k_eq = :"#{k}="
|
|
remove_method(k) if method_defined?(k)
|
|
remove_method(k_eq) if method_defined?(k_eq)
|
|
end
|
|
end
|
|
end
|
|
|
|
def add_accessors(keys, values)
|
|
f = protected_fields
|
|
metaclass.instance_eval do
|
|
keys.each do |k|
|
|
next if f.include?(k)
|
|
next if @@permanent_attributes.include?(k)
|
|
k_eq = :"#{k}="
|
|
define_method(k) { @values[k] }
|
|
define_method(k_eq) do |v|
|
|
if v == ""
|
|
raise ArgumentError.new(
|
|
"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.")
|
|
end
|
|
@values[k] = Util.convert_to_stripe_object(v, @opts)
|
|
dirty_value!(@values[k])
|
|
@unsaved_values.add(k)
|
|
end
|
|
|
|
if [FalseClass, TrueClass].include?(values[k].class)
|
|
k_bool = :"#{k}?"
|
|
define_method(k_bool) { @values[k] }
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def method_missing(name, *args)
|
|
# TODO: only allow setting in updateable classes.
|
|
if name.to_s.end_with?('=')
|
|
attr = name.to_s[0...-1].to_sym
|
|
|
|
# the second argument is only required when adding boolean accessors
|
|
add_accessors([attr], {})
|
|
|
|
begin
|
|
mth = method(name)
|
|
rescue NameError
|
|
raise NoMethodError.new("Cannot set #{attr} on this object. HINT: you can't set: #{@@permanent_attributes.to_a.join(', ')}")
|
|
end
|
|
return mth.call(args[0])
|
|
else
|
|
return @values[name] if @values.has_key?(name)
|
|
end
|
|
|
|
begin
|
|
super
|
|
rescue NoMethodError => e
|
|
if @transient_values.include?(name)
|
|
raise NoMethodError.new(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(', ')}")
|
|
else
|
|
raise
|
|
end
|
|
end
|
|
end
|
|
|
|
def respond_to_missing?(symbol, include_private = false)
|
|
@values && @values.has_key?(symbol) || super
|
|
end
|
|
|
|
# Re-initializes the object based on a hash of values (usually one that's
|
|
# come back from an API call). Adds or removes value accessors as necessary
|
|
# and updates the state of internal data.
|
|
#
|
|
# Protected on purpose! Please do not expose.
|
|
#
|
|
# ==== Options
|
|
#
|
|
# * +:values:+ Hash used to update accessors and values.
|
|
# * +:opts:+ Options for StripeObject like an API key.
|
|
# * +:partial:+ Indicates that the re-initialization should not attempt to
|
|
# remove accessors.
|
|
def initialize_from(values, opts, partial=false)
|
|
@opts = Util.normalize_opts(opts)
|
|
@original_values = Marshal.load(Marshal.dump(values)) # deep copy
|
|
|
|
removed = partial ? Set.new : 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
|
|
# customer, where there is no persistent card parameter. Mark those values
|
|
# which don't persist as transient
|
|
|
|
instance_eval do
|
|
remove_accessors(removed)
|
|
add_accessors(added, values)
|
|
end
|
|
|
|
removed.each do |k|
|
|
@values.delete(k)
|
|
@transient_values.add(k)
|
|
@unsaved_values.delete(k)
|
|
end
|
|
|
|
update_attributes(values, opts, :dirty => false)
|
|
values.each do |k, _|
|
|
@transient_values.delete(k)
|
|
@unsaved_values.delete(k)
|
|
end
|
|
|
|
self
|
|
end
|
|
|
|
def serialize_params_value(value, original, unsaved, force)
|
|
case value
|
|
when nil
|
|
''
|
|
|
|
when Array
|
|
update = value.map { |v| serialize_params_value(v, nil, true, force) }
|
|
|
|
# This prevents an array that's unchanged from being resent.
|
|
if update != serialize_params_value(original, nil, true, force)
|
|
update
|
|
else
|
|
nil
|
|
end
|
|
|
|
# Handle a Hash for now, but in the long run we should be able to
|
|
# eliminate all places where hashes are stored as values internally by
|
|
# making sure any time one is set, we convert it to a StripeObject. This
|
|
# will simplify our model by making data within an object more
|
|
# consistent.
|
|
#
|
|
# For now, you can still run into a hash if someone appends one to an
|
|
# existing array being held by a StripeObject. This could happen for
|
|
# example by appending a new hash onto `additional_owners` for an
|
|
# account.
|
|
when Hash
|
|
Util.convert_to_stripe_object(value, @opts).serialize_params
|
|
|
|
when StripeObject
|
|
update = value.serialize_params(:force => force)
|
|
|
|
# If the entire object was replaced, then we need blank each field of
|
|
# the old object that held a value. The new serialized values will
|
|
# override any of these empty values.
|
|
update = empty_values(original).merge(update) if original && unsaved
|
|
|
|
update
|
|
|
|
else
|
|
value
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def dirty_value!(value)
|
|
case value
|
|
when Array
|
|
value.map { |v| dirty_value!(v) }
|
|
when StripeObject
|
|
value.dirty!
|
|
end
|
|
end
|
|
|
|
# Returns a hash of empty values for all the values that are in the given
|
|
# StripeObject.
|
|
def empty_values(obj)
|
|
values = case obj
|
|
when Hash then obj
|
|
when StripeObject then obj.instance_variable_get(:@values)
|
|
else
|
|
raise ArgumentError, "#empty_values got unexpected object type: #{obj.class.name}"
|
|
end
|
|
|
|
values.inject({}) do |update, (k, _)|
|
|
update[k] = ''
|
|
update
|
|
end
|
|
end
|
|
end
|
|
end
|