stripe 1.18.0 → 1.30.0

data/lib/stripe/stripe_object.rb

@@ -2,25 +2,16 @@ module Stripe
   class StripeObject
     include Enumerable
 
-    attr_accessor :api_key
-    @@permanent_attributes = Set.new([:api_key, :id])
+    @@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, api_key=nil)
-      # parameter overloading!
-      if id.kind_of?(Hash)
-        @retrieve_options = id.dup
-        @retrieve_options.delete(:id)
-        id = id[:id]
-      else
-        @retrieve_options = {}
-      end
-
-      @api_key = api_key
+    def initialize(id=nil, opts={})
+      id, @retrieve_params = Util.normalize_id(id)
+      @opts = Util.normalize_opts(opts)
       @values = {}
       # This really belongs in APIResource, but not putting it there allows us
       # to have a unified inspect method
@@ -29,8 +20,25 @@ module Stripe
       @values[:id] = id if id
     end
 
-    def self.construct_from(values, api_key=nil)
-      self.new(values[:id], api_key).refresh_from(values, api_key)
+    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)
@@ -42,32 +50,36 @@ module Stripe
       "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@values)
     end
 
-    def refresh_from(values, api_key, partial=false)
-      @api_key = api_key
-
-      @previous_metadata = values[:metadata]
-      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
+    # 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
 
-      instance_eval do
-        remove_accessors(removed)
-        add_accessors(added)
-      end
-      removed.each do |k|
-        @values.delete(k)
-        @transient_values.add(k)
-        @unsaved_values.delete(k)
-      end
+    # 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.
+    #
+    # ==== Options
+    #
+    # * +:opts+ Options for StripeObject like an API key.
+    def update_attributes(values, opts = {})
       values.each do |k, v|
-        @values[k] = Util.convert_to_stripe_object(v, api_key)
-        @transient_values.delete(k)
-        @unsaved_values.delete(k)
+        @values[k] = Util.convert_to_stripe_object(v, opts)
+        @unsaved_values.add(k)
       end
-
-      return self
     end
 
     def [](k)
@@ -95,8 +107,17 @@ module Stripe
     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] = value.respond_to?(:to_hash) ? value.to_hash : value
+        acc[key] = case value
+                   when Array
+                     value.map(&maybe_to_hash)
+                   else
+                     maybe_to_hash.call(value)
+                   end
         acc
       end
     end
@@ -106,12 +127,12 @@ module Stripe
     end
 
     def _dump(level)
-      Marshal.dump([@values, @api_key])
+      Marshal.dump([@values, @opts])
     end
 
     def self._load(args)
-      values, api_key = Marshal.load(args)
-      construct_from(values, api_key)
+      values, opts = Marshal.load(args)
+      construct_from(values, opts)
     end
 
     if RUBY_VERSION < '1.9.2'
@@ -120,15 +141,96 @@ module Stripe
       end
     end
 
+    def serialize_nested_object(key)
+      new_value = @values[key]
+      if new_value.is_a?(APIResource)
+        return {}
+      end
+
+      if @unsaved_values.include?(key)
+        # the object has been reassigned
+        # e.g. as object.key = {foo => bar}
+        update = new_value
+        new_keys = update.keys.map(&:to_sym)
+
+        # remove keys at the server, but not known locally
+        if @original_values[key]
+          keys_to_unset = @original_values[key].keys - new_keys
+          keys_to_unset.each {|key| update[key] = ''}
+        end
+
+        update
+      else
+        # can be serialized normally
+        self.class.serialize_params(new_value)
+      end
+    end
+
+    def self.serialize_params(obj, original_value=nil)
+      case obj
+      when nil
+        ''
+      when StripeObject
+        unsaved_keys = obj.instance_variable_get(:@unsaved_values)
+        obj_values = obj.instance_variable_get(:@values)
+        update_hash = {}
+
+        unsaved_keys.each do |k|
+          update_hash[k] = serialize_params(obj_values[k])
+        end
+
+        obj_values.each do |k, v|
+          if v.is_a?(StripeObject) || v.is_a?(Hash)
+            update_hash[k] = obj.serialize_nested_object(k)
+          elsif v.is_a?(Array)
+            original_value = obj.instance_variable_get(:@original_values)[k]
+            if original_value && original_value.length > v.length
+              # url params provide no mechanism for deleting an item in an array,
+              # just overwriting the whole array or adding new items. So let's not
+              # allow deleting without a full overwrite until we have a solution.
+              raise ArgumentError.new(
+                "You cannot delete an item from an array, you must instead set a new array"
+              )
+            end
+            update_hash[k] = serialize_params(v, original_value)
+          end
+        end
+
+        update_hash
+      when Array
+        update_hash = {}
+        obj.each_with_index do |value, index|
+          update = serialize_params(value)
+          if update != {} && (!original_value || update != original_value[index])
+            update_hash[index] = update
+          end
+        end
+
+        if update_hash == {}
+          nil
+        else
+          update_hash
+        end
+      else
+        obj
+      end
+    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)
@@ -137,22 +239,29 @@ module Stripe
       end
     end
 
-    def add_accessors(keys)
+    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 cannot set #{k} to an empty string." \
+                "We interpret empty strings as nil in requests." \
                 "You may set #{self}.#{k} = nil to delete the property.")
             end
             @values[k] = v
             @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
@@ -161,7 +270,10 @@ module Stripe
       # TODO: only allow setting in updateable classes.
       if name.to_s.end_with?('=')
         attr = name.to_s[0...-1].to_sym
-        add_accessors([attr])
+
+        # the second argument is only required when adding boolean accessors
+        add_accessors([attr], {})
+
         begin
           mth = method(name)
         rescue NameError
@@ -186,5 +298,79 @@ module Stripe
     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 => opts)
+      values.each do |k, _|
+        @transient_values.delete(k)
+        @unsaved_values.delete(k)
+      end
+
+      self
+    end
+
+    # Mass assigns attributes on the model.
+    #
+    # This is a version of +update_attributes+ that takes some extra options
+    # for internal use.
+    #
+    # ==== Options
+    #
+    # * +:opts:+ Options for StripeObject like an API key.
+    # * +:raise_error:+ Set to false to suppress ArgumentErrors on keys that
+    #   don't exist.
+    def update_attributes_with_options(values, options={})
+      # `opts` are StripeObject options
+      opts        = options.fetch(:opts, {})
+      raise_error = options.fetch(:raise_error, true)
+
+      values.each do |k, v|
+        if !@@permanent_attributes.include?(k) && !self.respond_to?(:"#{k}=")
+          if raise_error
+            raise ArgumentError,
+              "#{k} is not an attribute that can be assigned on this object"
+          else
+            next
+          end
+        end
+
+        @values[k] = Util.convert_to_stripe_object(v, opts)
+        @unsaved_values.add(k)
+      end
+      self
+    end
   end
 end

data/lib/stripe/subscription.rb

@@ -7,13 +7,13 @@ module Stripe
       "#{Customer.url}/#{CGI.escape(customer)}/subscriptions/#{CGI.escape(id)}"
     end
 
-    def self.retrieve(id, api_key=nil)
+    def self.retrieve(id, opts=nil)
       raise NotImplementedError.new("Subscriptions cannot be retrieved without a customer ID. Retrieve a subscription using customer.subscriptions.retrieve('subscription_id')")
     end
 
     def delete_discount
-      Stripe.request(:delete, discount_url, @api_key)
-      refresh_from({ :discount => nil }, api_key, true)
+      response, opts = request(:delete, discount_url)
+      initialize_from({ :discount => nil }, opts, true)
     end
 
     private

data/lib/stripe/token.rb

@@ -1,5 +1,5 @@
 module Stripe
   class Token < APIResource
-    include Stripe::APIOperations::Create
+    extend Stripe::APIOperations::Create
   end
 end

data/lib/stripe/transfer.rb

@@ -1,12 +1,12 @@
 module Stripe
   class Transfer < APIResource
-    include Stripe::APIOperations::List
-    include Stripe::APIOperations::Create
+    extend Stripe::APIOperations::List
+    extend Stripe::APIOperations::Create
     include Stripe::APIOperations::Update
 
     def cancel
       response, api_key = Stripe.request(:post, cancel_url, @api_key)
-      refresh_from(response, api_key)
+      initialize_from(response, api_key)
     end
 
     def cancel_url

data/lib/stripe/util.rb

@@ -1,3 +1,5 @@
+require "cgi"
+
 module Stripe
   module Util
     def self.objects_to_ids(h)
@@ -21,9 +23,11 @@ module Stripe
         'list' => ListObject,
 
         # business objects
+        'account' => Account,
         'application_fee' => ApplicationFee,
         'balance' => Balance,
         'balance_transaction' => BalanceTransaction,
+        'bank_account' => BankAccount,
         'card' => Card,
         'charge' => Charge,
         'coupon' => Coupon,
@@ -37,19 +41,25 @@ module Stripe
         'refund' => Refund,
         'subscription' => Subscription,
         'file_upload' => FileUpload,
+        'token' => Token,
         'transfer' => Transfer,
+        'transfer_reversal' => Reversal,
         'bitcoin_receiver' => BitcoinReceiver,
-        'bitcoin_transaction' => BitcoinTransaction
+        'bitcoin_transaction' => BitcoinTransaction,
+        'dispute' => Dispute,
+        'product' => Product,
+        'sku' => SKU,
+        'order' => Order,
       }
     end
 
-    def self.convert_to_stripe_object(resp, api_key)
+    def self.convert_to_stripe_object(resp, opts)
       case resp
       when Array
-        resp.map { |i| convert_to_stripe_object(i, api_key) }
+        resp.map { |i| convert_to_stripe_object(i, opts) }
       when Hash
         # Try converting to a known object class.  If none available, fall back to generic StripeObject
-        object_classes.fetch(resp[:object], StripeObject).construct_from(resp, api_key)
+        object_classes.fetch(resp[:object], StripeObject).construct_from(resp, opts)
       else
         resp
       end
@@ -84,14 +94,30 @@ module Stripe
       end
     end
 
+    # Encodes a hash of parameters in a way that's suitable for use as query
+    # parameters in a URI or as form parameters in a request body. This mainly
+    # involves escaping special characters from parameter keys and values (e.g.
+    # `&`).
+    def self.encode_parameters(params)
+      Util.flatten_params(params).
+        map { |k,v| "#{url_encode(k)}=#{url_encode(v)}" }.join('&')
+    end
+
+    # Encodes a string in a way that makes it suitable for use in a set of
+    # query parameters in a URI or in a set of form parameters in a request
+    # body.
     def self.url_encode(key)
-      URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+      CGI.escape(key.to_s).
+        # Don't use strict form encoding by changing the square bracket control
+        # characters back to their literals. This is fine by the server, and
+        # makes these parameter strings easier to read.
+        gsub('%5B', '[').gsub('%5D', ']')
     end
 
     def self.flatten_params(params, parent_key=nil)
       result = []
       params.each do |key, value|
-        calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
+        calculated_key = parent_key ? "#{parent_key}[#{key}]" : "#{key}"
         if value.is_a?(Hash)
           result += flatten_params(value, calculated_key)
         elsif value.is_a?(Array)
@@ -100,14 +126,19 @@ module Stripe
           result << [calculated_key, value]
         end
       end
-      result
+
+      # The #sort_by call here is mostly so that we can get some stability in
+      # our 1.8.7 test suite where Hash key order is not preserved.
+      #
+      # https://www.igvita.com/2009/02/04/ruby-19-internals-ordered-hash/
+      result.sort_by { |(k, _)| k }
     end
 
     def self.flatten_params_array(value, calculated_key)
       result = []
       value.each do |elem|
         if elem.is_a?(Hash)
-          result += flatten_params(elem, calculated_key)
+          result += flatten_params(elem, "#{calculated_key}[]")
         elsif elem.is_a?(Array)
           result += flatten_params_array(elem, calculated_key)
         else
@@ -117,26 +148,38 @@ module Stripe
       result
     end
 
+    def self.normalize_id(id)
+      if id.kind_of?(Hash) # overloaded id
+        params_hash = id.dup
+        id = params_hash.delete(:id)
+      else
+        params_hash = {}
+      end
+      [id, params_hash]
+    end
+
     # The secondary opts argument can either be a string or hash
     # Turn this value into an api_key and a set of headers
-    def self.parse_opts(opts)
+    def self.normalize_opts(opts)
       case opts
-      when NilClass
-        return nil, {}
       when String
-        return opts, {}
+        {:api_key => opts}
       when Hash
-        headers = {}
-        if opts[:idempotency_key]
-          headers[:idempotency_key] = opts[:idempotency_key]
-        end
-        if opts[:stripe_account]
-          headers[:stripe_account] = opts[:stripe_account]
-        end
-        return opts[:api_key], headers
+        check_api_key!(opts.fetch(:api_key)) if opts.has_key?(:api_key)
+        opts.clone
       else
-        raise TypeError.new("parse_opts expects a string or a hash")
+        raise TypeError.new('normalize_opts expects a string or a hash')
       end
     end
+
+    def self.check_string_argument!(key)
+      raise TypeError.new("argument must be a string") unless key.is_a?(String)
+      key
+    end
+
+    def self.check_api_key!(key)
+      raise TypeError.new("api_key must be a string") unless key.is_a?(String)
+      key
+    end
   end
 end

data/lib/stripe/version.rb

@@ -1,3 +1,3 @@
 module Stripe
-  VERSION = '1.18.0'
+  VERSION = '1.30.0'
 end