stripe 2.0.3 → 5.55.0

data/README.md

@@ -1,38 +1,46 @@
-# Stripe Ruby Library [![Build Status](https://travis-ci.org/stripe/stripe-ruby.svg?branch=master)](https://travis-ci.org/stripe/stripe-ruby)
+# Stripe Ruby Library
+
+[![Gem Version](https://badge.fury.io/rb/stripe.svg)](https://badge.fury.io/rb/stripe)
+[![Build Status](https://travis-ci.org/stripe/stripe-ruby.svg?branch=master)](https://travis-ci.org/stripe/stripe-ruby)
 
 The Stripe Ruby library provides convenient access to the Stripe API from
 applications written in the Ruby language. It includes a pre-defined set of
 classes for API resources that initialize themselves dynamically from API
-responses. This allows it to operate on a number of different versions of the
+responses which makes it compatible with a wide range of versions of the Stripe
 API.
 
 The library also provides other features. For example:
 
-* Easy configuration path for fast setup and use.
-* Helpers for pagination.
-* Tracking of "fresh" values in API resources so that partial updates can be
-  executed.
-* Built-in mechanisms for the serialization of parameters according to the
+- Easy configuration path for fast setup and use.
+- Helpers for pagination.
+- Built-in mechanisms for the serialization of parameters according to the
   expectations of Stripe's API.
 
 ## Documentation
 
-See the [Ruby API docs](https://stripe.com/docs/api/ruby#intro).
+See the [Ruby API docs](https://stripe.com/docs/api?lang=ruby).
+
+See [video demonstrations][youtube-playlist] covering how to use the library.
+
 
 ## Installation
 
 You don't need this source code unless you want to modify the gem. If you just
 want to use the package, just run:
 
-    gem install stripe
+```sh
+gem install stripe
+```
 
 If you want to build the gem from source:
 
-    gem build stripe.gemspec
+```sh
+gem build stripe.gemspec
+```
 
 ### Requirements
 
-* Ruby 2.0+.
+- Ruby 2.3+.
 
 ### Bundler
 
@@ -40,7 +48,7 @@ If you are installing via bundler, you should be sure to use the https rubygems
 source in your Gemfile, as any gems fetched over http could potentially be
 compromised in transit and alter the code of gems fetched securely over https:
 
-``` ruby
+```ruby
 source 'https://rubygems.org'
 
 gem 'rails'
@@ -53,17 +61,15 @@ The library needs to be configured with your account's secret key which is
 available in your [Stripe Dashboard][api-keys]. Set `Stripe.api_key` to its
 value:
 
-``` ruby
-require "stripe"
-Stripe.api_key = "sk_test_..."
+```ruby
+require 'stripe'
+Stripe.api_key = 'sk_test_...'
 
-# list charges
-Stripe::Charge.list()
+# list customers
+Stripe::Customer.list()
 
-# retrieve single charge
-Stripe::Charge.retrieve(
-  "ch_18atAXCdGbJFKhCuBAa4532Z",
-)
+# retrieve single customer
+Stripe::Customer.retrieve('cus_123456789')
 ```
 
 ### Per-request Configuration
@@ -72,80 +78,273 @@ For apps that need to use multiple keys during the lifetime of a process, like
 one that uses [Stripe Connect][connect], it's also possible to set a
 per-request key and/or account:
 
-``` ruby
+```ruby
 require "stripe"
 
-Stripe::Charge.list(
+Stripe::Customer.list(
   {},
-  :api_key => "sk_test_...",
-  :stripe_account => "acct_..."
+  {
+    api_key: 'sk_test_...',
+    stripe_account: 'acct_...',
+    stripe_version: '2018-02-28',
+  }
 )
 
-Stripe::Charge.retrieve(
-  "ch_18atAXCdGbJFKhCuBAa4532Z",
-  :api_key => "sk_test_...",
-  :stripe_account => "acct_..."
+Stripe::Customer.retrieve(
+  'cus_123456789',
+  {
+    api_key: 'sk_test_...',
+    stripe_account: 'acct_...',
+    stripe_version: '2018-02-28',
+  }
+)
+
+Stripe::Customer.retrieve(
+  {
+    id: 'cus_123456789',
+    expand: %w(balance_transaction)
+  },
+  {
+    stripe_version: '2018-02-28',
+    api_key: 'sk_test_...',
+  }
+)
+
+Stripe::Customer.capture(
+  'cus_123456789',
+  {},
+  {
+    stripe_version: '2018-02-28',
+    api_key: 'sk_test_...',
+  }
 )
 ```
 
-### Configuring a Client
+Keep in mind that there are different method signatures depending on the action:
+
+- When operating on a collection (e.g. `.list`, `.create`) the method signature is
+  `method(params, opts)`.
+- When operating on resource (e.g. `.capture`, `.update`) the method signature is
+  `method(id, params, opts)`.
+- One exception is that `retrieve`, despite being an operation on a resource, has the signature
+  `retrieve(id, opts)`. In addition, it will accept a Hash for the `id` param but will extract the
+  `id` key out and use the others as options.
 
-While a default HTTP client is used by default, it's also possible to have the
-library use any client supported by [Faraday][faraday] by initializing a
-`Stripe::StripeClient` object and giving it a connection:
+### Accessing a response object
 
-``` ruby
-conn = Faraday.new
-client = Stripe::StripeClient.new(conn)
-client.request do
-  charge, resp = Stripe::Charge.retrieve(
-    "ch_18atAXCdGbJFKhCuBAa4532Z",
-  )
+Get access to response objects by initializing a client and using its `request`
+method:
+
+```ruby
+client = Stripe::StripeClient.new
+customer, resp = client.request do
+  Stripe::Customer.retrieve('cus_123456789',)
 end
 puts resp.request_id
 ```
 
+### Configuring a proxy
+
+A proxy can be configured with `Stripe.proxy`:
+
+```ruby
+Stripe.proxy = 'https://user:pass@example.com:1234'
+```
+
+### Configuring an API Version
+
+By default, the library will use the API version pinned to the account making
+a request. This can be overridden with this global option:
+
+```ruby
+Stripe.api_version = '2018-02-28'
+```
+
+See [versioning in the API reference][versioning] for more information.
+
 ### Configuring CA Bundles
 
 By default, the library will use its own internal bundle of known CA
 certificates, but it's possible to configure your own:
 
-    Stripe.ca_bundle_path = "path/to/ca/bundle"
+```ruby
+Stripe.ca_bundle_path = 'path/to/ca/bundle'
+```
 
 ### Configuring Automatic Retries
 
-The library can be configured to automatically retry requests that fail due to
-an intermittent network problem:
+You can enable automatic retries on requests that fail due to a transient
+problem by configuring the maximum number of retries:
 
-    Stripe.max_network_retries = 2
+```ruby
+Stripe.max_network_retries = 2
+```
+
+Various errors can trigger a retry, like a connection error or a timeout, and
+also certain API responses like HTTP status `409 Conflict`.
 
 [Idempotency keys][idempotency-keys] are added to requests to guarantee that
 retries are safe.
 
+### Configuring Timeouts
+
+Open, read and write timeouts are configurable:
+
+```ruby
+Stripe.open_timeout = 30 # in seconds
+Stripe.read_timeout = 80
+Stripe.write_timeout = 30 # only supported on Ruby 2.6+
+```
+
+Please take care to set conservative read timeouts. Some API requests can take
+some time, and a short timeout increases the likelihood of a problem within our
+servers.
+
+### Logging
+
+The library can be configured to emit logging that will give you better insight
+into what it's doing. The `info` logging level is usually most appropriate for
+production use, but `debug` is also available for more verbosity.
+
+There are a few options for enabling it:
+
+1. Set the environment variable `STRIPE_LOG` to the value `debug` or `info`:
+
+   ```sh
+   $ export STRIPE_LOG=info
+   ```
+
+2. Set `Stripe.log_level`:
+
+   ```ruby
+   Stripe.log_level = Stripe::LEVEL_INFO
+   ```
+
+### Instrumentation
+
+The library has various hooks that user code can tie into by passing a block to
+`Stripe::Instrumentation.subscribe` to be notified about specific events.
+
+#### `request_begin`
+
+Invoked when an HTTP request starts. Receives `RequestBeginEvent` with the
+following properties:
+
+- `method`: HTTP method. (`Symbol`)
+- `path`: Request path. (`String`)
+- `user_data`: A hash on which users can set arbitrary data, and which will be
+  passed through to `request_end` invocations. This could be used, for example,
+  to assign unique IDs to each request, and it'd work even if many requests are
+  running in parallel. All subscribers share the same object for any particular
+  request, so they must be careful to use unique keys that will not conflict
+  with other subscribers. (`Hash`)
+
+#### `request_end`
+
+Invoked when an HTTP request finishes, regardless of whether it terminated with
+a success or error. Receives `RequestEndEvent` with the following properties:
+
+- `duration`: Request duration in seconds. (`Float`)
+- `http_status`: HTTP response code (`Integer`) if available, or `nil` in case
+  of a lower level network error.
+- `method`: HTTP method. (`Symbol`)
+- `num_retries`: The number of retries. (`Integer`)
+- `path`: Request path. (`String`)
+- `user_data`: A hash on which users may have set arbitrary data in
+  `request_begin`. See above for more information. (`Hash`)
+- `request_id`. HTTP request identifier.
+
+#### Example
+
+For example:
+
+```ruby
+Stripe::Instrumentation.subscribe(:request_end) do |request_event|
+  tags = {
+    method: request_event.method,
+    resource: request_event.path.split('/')[2],
+    code: request_event.http_status,
+    retries: request_event.num_retries
+  }
+  StatsD.distribution('stripe_request', request_event.duration, tags: tags)
+end
+```
+
+### Writing a Plugin
+
+If you're writing a plugin that uses the library, we'd appreciate it if you
+identified using `#set_app_info`:
+
+```ruby
+Stripe.set_app_info('MyAwesomePlugin', version: '1.2.34', url: 'https://myawesomeplugin.info')
+```
+
+This information is passed along when the library makes calls to the Stripe
+API.
+
+### Request latency telemetry
+
+By default, the library sends request latency telemetry to Stripe. These
+numbers help Stripe improve the overall latency of its API for all users.
+
+You can disable this behavior if you prefer:
+
+```ruby
+Stripe.enable_telemetry = false
+```
+
 ## Development
 
+The test suite depends on [stripe-mock], so make sure to fetch and run it from a
+background terminal ([stripe-mock's README][stripe-mock] also contains
+instructions for installing via Homebrew and other methods):
+
+```sh
+go get -u github.com/stripe/stripe-mock
+stripe-mock
+```
+
 Run all tests:
 
-    bundle exec rake
+```sh
+bundle exec rake test
+```
 
 Run a single test suite:
 
-    bundle exec ruby -Ilib/ test/stripe/util_test.rb
+```sh
+bundle exec ruby -Ilib/ test/stripe/util_test.rb
+```
 
 Run a single test:
 
-    bundle exec ruby -Ilib/ test/stripe/util_test.rb -n /should.convert.names.to.symbols/
+```sh
+bundle exec ruby -Ilib/ test/stripe/util_test.rb -n /should.convert.names.to.symbols/
+```
 
-Update bundled CA certificates from the [Mozilla cURL release][curl]:
+Run the linter:
 
-    bundle exec rake update_certs
+```sh
+bundle exec rake rubocop
+```
+
+Update bundled CA certificates from the [Mozilla cURL release][curl]:
 
-Update bundled OpenAPI specification from the canonical repository:
+```sh
+bundle exec rake update_certs
+```
 
-    bundle exec rake update_openapi
+Update the bundled [stripe-mock] by editing the version number found in
+`.travis.yml`.
 
 [api-keys]: https://dashboard.stripe.com/account/apikeys
 [connect]: https://stripe.com/connect
 [curl]: http://curl.haxx.se/docs/caextract.html
-[faraday]: https://github.com/lostisland/faraday
-[idempotency-keys]: https://stripe.com/docs/api/ruby#idempotent_requests
+[idempotency-keys]: https://stripe.com/docs/api/idempotent_requests?lang=ruby
+[stripe-mock]: https://github.com/stripe/stripe-mock
+[versioning]: https://stripe.com/docs/api/versioning?lang=ruby
+[youtube-playlist]: https://www.youtube.com/playlist?list=PLy1nL-pvL2M50RmP6ie-gdcSnfOuQCRYk
+
+<!--
+# vim: set tw=79:
+-->

data/Rakefile

@@ -1,43 +1,37 @@
-require 'rake/testtask'
+# frozen_string_literal: true
 
-task :default => [:test]
+require "rake/testtask"
+require "rubocop/rake_task"
+
+task default: %i[test rubocop]
 
 Rake::TestTask.new do |t|
-  t.pattern = './test/**/*_test.rb'
+  t.pattern = "./test/**/*_test.rb"
 end
 
+RuboCop::RakeTask.new
+
 desc "Update bundled certs"
 task :update_certs do
-  require "faraday"
+  require "net/http"
+  require "uri"
 
   fetch_file "https://curl.haxx.se/ca/cacert.pem",
-    File.expand_path("../lib/data/ca-certificates.crt", __FILE__)
-end
-
-desc "Update OpenAPI specification"
-task :update_openapi do
-  require "faraday"
-
-  ["fixtures.json", "fixtures.yaml", "spec.json", "spec.yaml"].map { |file|
-    Thread.new do
-      fetch_file "https://raw.githubusercontent.com/stripe/openapi/master/spec/#{file}",
-        File.expand_path("../openapi/#{file}", __FILE__)
-    end
-  }.map { |t| t.join }
+             ::File.expand_path("../lib/data/ca-certificates.crt", __FILE__)
 end
 
 #
 # helpers
 #
 
-def fetch_file(url, dest)
-  File.open(dest, 'w') do |file|
-    resp = Faraday.get(url)
-    unless resp.status == 200
-      abort("bad response when fetching: #{url}\n" \
-        "Status #{resp.status}: #{resp.body}")
+def fetch_file(uri, dest)
+  ::File.open(dest, "w") do |file|
+    resp = Net::HTTP.get_response(URI.parse(uri))
+    unless resp.code.to_i == 200
+      abort("bad response when fetching: #{uri}\n" \
+        "Status #{resp.code}: #{resp.body}")
     end
     file.write(resp.body)
-    puts "Successfully fetched: #{url}"
+    puts "Successfully fetched: #{uri}"
   end
 end

data/VERSION

@@ -1 +1 @@
-2.0.3
+5.55.0

data/bin/stripe-console

@@ -1,9 +1,11 @@
 #!/usr/bin/env ruby
 
-require 'irb'
-require 'irb/completion'
+# frozen_string_literal: true
 
-require "#{File.dirname(__FILE__)}/../lib/stripe"
+require "irb"
+require "irb/completion"
+
+require "#{::File.dirname(__FILE__)}/../lib/stripe"
 
 # Config IRB to enable --simple-prompt and auto indent
 IRB.conf[:PROMPT_MODE] = :SIMPLE

data/lib/stripe/api_operations/create.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Stripe
   module APIOperations
     module Create
-      def create(params={}, opts={})
-        resp, opts = request(:post, resource_url, params, opts)
+      def create(params = {}, opts = {})
+        resp, opts = execute_resource_request(:post, resource_url, params, opts)
         Util.convert_to_stripe_object(resp.data, opts)
       end
     end

data/lib/stripe/api_operations/delete.rb

@@ -1,11 +1,39 @@
+# frozen_string_literal: true
+
 module Stripe
   module APIOperations
     module Delete
-      def delete(params={}, opts={})
-        opts = Util.normalize_opts(opts)
-        resp, opts = request(:delete, resource_url, params, opts)
+      module ClassMethods
+        # Deletes an API resource
+        #
+        # Deletes the identified resource with the passed in parameters.
+        #
+        # ==== Attributes
+        #
+        # * +id+ - ID of the resource to delete.
+        # * +params+ - A hash of parameters to pass to the API
+        # * +opts+ - A Hash of additional options (separate from the params /
+        #   object values) to be added to the request. E.g. to allow for an
+        #   idempotency_key to be passed in the request headers, or for the
+        #   api_key to be overwritten. See
+        #   {APIOperations::Request.execute_resource_request}.
+        def delete(id, params = {}, opts = {})
+          resp, opts = execute_resource_request(:delete,
+                                                "#{resource_url}/#{id}",
+                                                params, opts)
+          Util.convert_to_stripe_object(resp.data, opts)
+        end
+      end
+
+      def delete(params = {}, opts = {})
+        resp, opts = execute_resource_request(:delete, resource_url,
+                                              params, opts)
         initialize_from(resp.data, opts)
       end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
     end
   end
 end

data/lib/stripe/api_operations/list.rb

@@ -1,28 +1,19 @@
+# frozen_string_literal: true
+
 module Stripe
   module APIOperations
     module List
-      def list(filters={}, opts={})
+      def list(filters = {}, opts = {})
         opts = Util.normalize_opts(opts)
 
-        resp, opts = request(:get, resource_url, filters, opts)
+        resp, opts = execute_resource_request(:get, resource_url, filters, opts)
         obj = ListObject.construct_from(resp.data, opts)
 
         # set filters so that we can fetch the same limit, expansions, and
         # predicates when accessing the next and previous pages
-        #
-        # just for general cleanliness, remove any paging options
         obj.filters = filters.dup
-        obj.filters.delete(:ending_before)
-        obj.filters.delete(:starting_after)
-
         obj
       end
-
-      # The original version of #list was given the somewhat unfortunate name of
-      # #all, and this alias allows us to maintain backward compatibility (the
-      # choice was somewhat misleading in the way that it only returned a single
-      # page rather than all objects).
-      alias :all :list
     end
   end
 end

data/lib/stripe/api_operations/nested_resource.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Stripe
+  module APIOperations
+    # Adds methods to help manipulate a subresource from its parent resource so
+    # that it's possible to do so from a static context (i.e. without a
+    # pre-existing collection of subresources on the parent).
+    #
+    # For example, a transfer gains the static methods for reversals so that the
+    # methods `.create_reversal`, `.retrieve_reversal`, `.update_reversal`,
+    # etc. all become available.
+    module NestedResource
+      def nested_resource_class_methods(resource, path: nil, operations: nil,
+                                        resource_plural: nil)
+        resource_plural ||= "#{resource}s"
+        path ||= resource_plural
+
+        raise ArgumentError, "operations array required" if operations.nil?
+
+        resource_url_method = :"#{resource}s_url"
+
+        define_singleton_method(resource_url_method) do |id, nested_id = nil|
+          url = "#{resource_url}/#{CGI.escape(id)}/#{CGI.escape(path)}"
+          url += "/#{CGI.escape(nested_id)}" unless nested_id.nil?
+          url
+        end
+
+        operations.each do |operation|
+          case operation
+          when :create
+            define_singleton_method(:"create_#{resource}") \
+              do |id, params = {}, opts = {}|
+                url = send(resource_url_method, id)
+                resp, opts = execute_resource_request(:post, url, params, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
+          when :retrieve
+            define_singleton_method(:"retrieve_#{resource}") \
+              do |id, nested_id, opts = {}|
+                url = send(resource_url_method, id, nested_id)
+                resp, opts = execute_resource_request(:get, url, {}, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
+          when :update
+            define_singleton_method(:"update_#{resource}") \
+              do |id, nested_id, params = {}, opts = {}|
+                url = send(resource_url_method, id, nested_id)
+                resp, opts = execute_resource_request(:post, url, params, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
+          when :delete
+            define_singleton_method(:"delete_#{resource}") \
+              do |id, nested_id, params = {}, opts = {}|
+                url = send(resource_url_method, id, nested_id)
+                resp, opts = execute_resource_request(:delete, url, params,
+                                                      opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
+          when :list
+            define_singleton_method(:"list_#{resource_plural}") \
+              do |id, params = {}, opts = {}|
+                url = send(resource_url_method, id)
+                resp, opts = execute_resource_request(:get, url, params, opts)
+                Util.convert_to_stripe_object(resp.data, opts)
+              end
+          else
+            raise ArgumentError, "Unknown operation: #{operation.inspect}"
+          end
+        end
+      end
+    end
+  end
+end