plaid 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f8aeb4ddef4c58a7a03b9902450a8b87fc82296
-  data.tar.gz: d9b2daf9205549d39fa5a4f25700ddfae73cf6d7
+  metadata.gz: 1b5ab6d107eb42bdc74441ce2e47c068b43b66c0
+  data.tar.gz: fd69213bbb1001c8b283edb6742da94647ae9a53
 SHA512:
-  metadata.gz: 51e64249b4daad06dd8dd03d648b721204d3383ae493289b1dccf85e80ec2fe5892a83b388d4ec8ac2b417dd47732dafb1f3658a3cfb790947cb94b1866d2aaa
-  data.tar.gz: 2ab1e1bb607cb87ddaaa3a0adc52946b18dbac5e4112f8db945226985fafd2b93ef10d763eba101cd0ac2fea688c8cec455e660caacab9b8f0972a307d1135f2
+  metadata.gz: 8fe17b5426f28e1657f38541b2434c7462f60205d9073b778761a516587e8e809ef582720e5ccad3c08e5cb3f7f2f67a5aad08a0f402c99da0536d8d3129c2b8
+  data.tar.gz: 46bc2fe7a2f1da6895e15b4a9c265613f8da13c8966b75c9e069bbe55185a95dbfed3a15f8445a7929aab6d9e5867afe0aeef11ee42a3d1fd9ddd692499c3e09

data/CONTRIBUTING.md

@@ -1,4 +1,10 @@
-# Contributing
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
 
 1.  Make one or more atomic commits, and ensure that each commit has a
     descriptive commit message. Commit messages should be line wrapped

data/Gemfile

@@ -1,4 +1,3 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in plaid.gemspec
 gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -1,6 +1,8 @@
-# Plaid [![Build Status](https://travis-ci.org/plaid/plaid-ruby.svg)](https://travis-ci.org/plaid/plaid-ruby) [![Gem Version](https://badge.fury.io/rb/plaid.svg)](http://badge.fury.io/rb/plaid)
+# plaid-ruby [![Build Status](https://travis-ci.org/plaid/plaid-ruby.svg)](https://travis-ci.org/plaid/plaid-ruby) [![Gem Version](https://badge.fury.io/rb/plaid.svg)](http://badge.fury.io/rb/plaid)
 
-Ruby bindings for the Plaid API.
+The official Ruby bindings for the [Plaid API](https://plaid.com/docs).
+
+This module was recently released as version `4.0.x` for Plaid's updated API. Use the gem `plaid-legacy` for version `3.0.x`.
 
 ## Installation
 
@@ -18,306 +20,331 @@ Or install it yourself as:
 
     $ gem install plaid
 
-The gem supports Ruby 2.x only.
+The gem supports Ruby 2.1+ only.
 
 ## Usage
 
-This gem wraps the Plaid API, which is fully described in the [documentation](http://plaid.com/docs).
+This gem wraps the Plaid API, which is fully described in the [documentation](https://plaid.com/docs/api).
 
-The RubyDoc for the gem is available [here](http://plaid.github.io/plaid-ruby).
+The RubyDoc for the gem is available [here](LINKPLACEHOLDER).
 
-### Configuring access to Plaid
+### Creating a Plaid client
 
-Configure the gem with your client id, secret, and the environment you would like to use.
+Create an instance of the client using the `client_id`, `secret`, and `public_key` from your Plaid dashboard along with your environment of choice:
 
 ```ruby
-Plaid.config do |p|
-  p.client_id = '<<< Plaid provided client ID >>>'
-  p.secret = '<<< Plaid provided secret key >>>'
-  p.env = :tartan  # or :production
-end
-```
+require 'plaid'
 
-### Creating a new User
+$client = Plaid::Client.new(env: :sandbox,
+                            client_id: '***',
+                            secret: '***',
+                            public_key: '***')
 
-```ruby
-user = Plaid::User.create(:connect, 'wells', 'plaid_test', 'plaid_good')
 ```
 
-This call will do a `POST /connect`. The response will contain account information and transactions
-for last 30 days, which you can find in `user.accounts` and `user.initial_transactions`, accordingly.
+The `env` field is the environment which the client will be running in. Your choices for the `env` field include:
+- `:sandbox` allows you to do your initial integrations tests against preloaded data without being billed or making expensive API calls. More information about using the API sandbox can be found on the [API Sandbox documentation](https://plaid.com/docs/api/blob/master/SANDBOX.md).
+- `:development` allows you to test against both real and test accounts without being billed. More information about Plaid test accounts can be found in our [API documentation](https://plaid.com/docs/api/#sandbox).
+- `:production` is the production environment where you can launch your production ready application and be charged for your Plaid usage.
 
-If the authentication requires a pin, you can pass it as a named parameter:
+### Creating a new item
+
+A new item can be created by providing a set of credentials, an institution code, and a list of products to create the item with.
 
 ```ruby
-user = Plaid::User.create(:income, 'usaa', 'plaid_test', 'plaid_good', pin: '1234')
+item = client.item.create(credentials: { username: 'user_good',
+                                         password: 'pass_good',
+                                         pin: '1234' },
+                          institution_id: 'ins_109509',
+                          initial_products: %i(auth identity transactions))
 ```
-
-To add options such as `login_only` or `webhook`, use `options` argument:
-
+The first argument for `client.item.create` is always the credentials in the form of a hash. 
 ```ruby
-user = Plaid::User.create(:connect, 'wells', 'plaid_test', 'plaid_good',
-                          options: { login_only: true, webhook: 'https://example.org/callbacks/plaid')
+credentials = { username: 'user_good',
+                password: 'pass_good',
+                pin: '1234' }
 ```
+The `pin` field in the credentials hash is not required and does not need to be entered if your institution does not require it.
 
-The first argument for `Plaid::User.create` is always a product you want to add the user to (like,
-`:connect`, `:auth`, `:info`, `:income`, or `:risk`). The user object is bound to the product, and subsequent
-calls like `user.update` or `user.delete` are done for this product (i.e., `PATCH /info` and `DELETE /info`
-for `:info`).
-
-### Instantiating a User with an existing access token
-
-If you've already added the user and saved the access token, you should use `User.load`:
-
+A successful, non-MFA (multi-factor authentication) response (HTTP 200) to an item creation will come in the form of a hash where each of these attributes can be accessed by the corresponding string key:
 ```ruby
-user = Plaid::User.load(:risk, 'access_token')
+{ "access_token" => String,
+  "item" => { "available_products" => [String],
+              "billed_products"    => [String],
+              "error"              => Object,
+              "institution_id"     => String,
+              "item_id"            => String,
+              "webhook"            => nullable String },
+  "request_id" => String }
 ```
+The response provides three primary pieces of information:
+- `access_token` is your token to access this item and the item's products in the future such as `auth` or `transactions`
+- `item` provides information about the item such as the `item_id` and `available_products`
+- `request_id` is the identifier for your actual request, this is often used to file tickets if necessary
 
-This won't make any API requests by itself, just set the product and the token in the `User` instance.
+There are other responses you can receive from an item creation such as an MFA response and an error response (they're all in hash form).
 
-### Exchanging a Link public token for a Plaid access token
+An MFA response (HTTP 210) looks like this:
+```ruby
+{ "access_token" => String,
+  "device"       => nullable String,
+  "device_list"  => nullable [Object],
+  "mfa_type"     => String Enum (device, device_list, questions, selections),
+  "questions"    => nullable [String],
+  "request_id"   => String,
+  "selections"   => nullable [Object] }
+```
 
-If you have a Link public token, use `User.exchange_token`:
+An example of how an MFA onboarding flow looks like can be seen below in the Examples section.
 
+If an error occurs during the creation, an error will be thrown. The class for the error has values that you can access by using the following keys.
 ```ruby
-user = Plaid::User.exchange_token('public_token')   # bound to :connect product
+{ "error_type"      => String,
+  "error_code"      => String,
+  "error_message"   => String,
+  "display_message" => (nullable) String,
+  "request_id"      => String }
 ```
+Additional information on the meaning or usage of each field can be found in our [API Error documentation](https://plaid.com/docs/api#errors).
 
-With more options:
+You can also add options such as `transactions.await_results` or `webhook` to your item creation, use keyed arguments:
 
 ```ruby
-user2 = Plaid::User.exchange_token('public_token', 'account_id', product: :auth)
+item = client.item.create(credentials: { username: 'user_good',
+                                         password: 'pass_good' },
+                          institution_id: 'ins_109509',
+                          initial_products: %i(auth identity transactions),
+                          transactions_await_results: true,
+                          webhook: 'https://plaid.com/webhook-test')
 ```
 
-If you want to [move money via Stripe's ACH
-API](https://plaid.com/docs/link/stripe/#step-4-write-server-side-handler), you
-ought to specify the `account_id` param. In this case the returned user
-instance will have the `stripe_bank_account_token` attribute set.
+More information about item creation options can be found in our [API documentation](https://plaid.com/docs/api#post-itemcreate).
 
-### Upgrading and changing the current product
 
-Plaid supports upgrading a user, i.e. adding it to another product:
+## Examples
 
-```ruby
-# Create a user in Connect
-user = Plaid::User.create(:connect, 'wells', 'plaid_test', 'plaid_good')
+### Exchanging a Link public token for a Plaid access_token
 
-# Upgrade this user, attaching it to Auth as well (makes a request to /upgrade).
-auth_user = user.upgrade(:auth)
-```
+If you have a [Link](https://github.com/plaid/link) `public token`, use this function to get an `access_token`: `client.item.public_token.exchange(public_token)`
 
-The `auth_user` will be a different instance of `User`, attached to Auth, but the access token will be the same.
-
-Sometimes you know that the user has already been added to another product. To get a `User` instance with
-same access token, but different current product, use `User.for_product`:
+An example of the function's usage if you have a `public_token` in hand:
 
 ```ruby
-# Get a user attached to Connect
-user = Plaid::User.load(:connect, 'access_token')
-
-# Makes no requests
-info_user = user.for_product(:info)
+response = client.item.public_token.exchange(public_token)
+access_token = response['access_token']
 ```
 
-Basically it's the same as:
+### Handle MFA during item creation
 
+If MFA is requested by the financial institution, there will be additional steps required to finish the item creation flow:
 ```ruby
-info_user = Plaid::User.load(:info, 'access_token')
-```
+require 'plaid'
+
+def answer_mfa(client, access_token, data)
+  case data['mfa_type']
+  when 'questions'
+    answer_questions(client, access_token, data['questions'])
+  when 'device_list'
+    answer_device_list(client, access_token, data['device_list'])
+  when 'selections'
+    answer_selections(client, access_token, data['selections'])
+  when 'device'
+    answer_device(client, access_token, data['device'])
+  else
+    raise 'Unknown MFA type from Plaid'
+  end
+end
 
-### MFA (Multi-Factor Authorization)
+def answer_questions(client, access_token, _questions)
+  # We have magically inferred the answer here, so we respond immediately.
+  # In the real world, we would present the questions to our user and
+  # submit their responses.
+  answers = ['answer_0_0']
+  client.item.mfa(access_token, 'questions', answers)
+end
 
-If MFA is requested by the financial institution, the `User.create` call would behave
-a bit differently:
+def answer_device_list(client, access_token, device_list)
+  # We have picked the first device here.
+  # In the real world, we would ask our user which device the passcode
+  # should be sent to.
+  device = device_list[0]['device_id']
+  client.item.mfa(access_token, 'device_list', [device])
+end
 
-```ruby
-user = Plaid::User.create(:auth, 'wells', 'plaid_test', 'plaid_good')
+def answer_device(client, access_token, _device)
+  # Another magically inferred answer.
+  # In the real world, we would ask our user for the passcode they received.
+  client.item.mfa(access_token, 'device', ['1234'])
+end
+
+def answer_selections(client, access_token, _selections)
+  # We have magically inferred the answer here, so we respond immediately.
+  # In the real world, we would present the selection question and choices
+  # to our user and submit their responses.
+  answers = %w(tomato ketchup)
+  client.item.mfa(access_token, 'selections', answers)
+end
 
-user.accounts   #=> nil
-user.mfa?       #=> true
-user.mfa_type   #=> :questions
-user.mfa        #=> [{question: "What's the nickname of the person who created Ruby?"}]
+begin
+  client = Plaid::Client.new(env: :sandbox,
+                             client_id: '***',
+                             secret: '***',
+                             public_key: '***')
+
+  response = client.item.create(credentials: { username: 'user_good',
+                                               password: 'mfa_device' },
+                                institution_id: 'ins_109508',
+                                initial_products: %i(transactions auth))
+
+  access_token = response['access_token']
+  response = answer_mfa(client, access_token, response) while response.key?('mfa_type')
+rescue Plaid::PlaidError
+  raise 'Error in main flow.'
+end
 ```
 
-In this case you'll have to submit the answer to the question:
+### Deleting an item
 
 ```ruby
-user.mfa_step('matz')        # This is the correct answer!
-
-user.mfa?       #=> false
-user.mfa_type   #=> nil
-user.mfa        #=> nil
-user.accounts   #=> [<Plaid::Account ...>, ...]
-```
+require 'plaid'
 
-The code-based MFA workflow is similar. Basically you need to call `user.mfa_step(...)`
-until `user.mfa?` becomes false.
+client = Plaid::Client.new(env: :sandbox,
+                           client_id: '***',
+                           secret: '***',
+                           public_key: '***')
 
-### Obtaining user-related data
-
-If you have a live `User` instance, you can use following methods
-(independent of instance's current product):
+response = client.item.create(credentials: { username: 'user_good',
+                                             password: 'pass_good' },
+                              institution_id: 'ins_109509',
+                              initial_products: %i(auth identity transactions))
 
-* `user.transactions(...)`. Makes a `/connect/get` request.
-* `user.auth(sync: false)`. Makes an `/auth/get` request.
-* `user.info(sync: false)`. Makes an `/info/get` request.
-* `user.income(sync: false)`. Makes an `/income/get` request.
-* `user.risk(sync: false)`. Makes an `/risk/get` request.
-* `user.balance`. Makes an `/balance` request.
+access_token = response['access_token']
 
-All of these methods return appropriate data, but they also update the cached `user.accounts`. That is,
-if you user has access to Auth and Risk  products, the following code:
+# Provide the access_token for the Item you want to delete
+client.item.delete(access_token)
+```
 
+### Get paginated transactions
 ```ruby
-user = User.load(:auth, 'access_token')
-user.auth
-user.risk
+require 'plaid'
+
+client = Plaid::Client.new(env: :sandbox,
+                           client_id: '***',
+                           secret: '***',
+                           public_key: '***')
+
+item_response = client.item.create(credentials: { username: 'user_good',
+                                                  password: 'pass_good' },
+                                   institution_id: 'ins_109509',
+                                   initial_products: %i(auth identity transactions))
+
+access_token = item_response['access_token']
+
+transaction_response = client.transactions.get(access_token, '2016-07-12', '2017-01-09')
+transactions = transaction_response['transactions']
+
+# the transactions in the response are paginated, so make multiple calls while
+# increasing the offset to retrieve all transactions
+while transactions.length < response['total_transactions']
+  transaction_response = client.transactions.get(access_token,
+                                                 '2016-07-12',
+                                                 '2017-01-09',
+                                                 offset: transactions.length)
+  transactions += transaction_response['transactions']
+end
+
 ```
-will result in `user.accounts` having both routing number and risk information for all the accounts. The
-subsequent `user.balance` call will just update the current balance, not touching the routing and risk information.
 
-The `sync` flag, if set to true, will result in updating the information from the server even if it has already been
-loaded. Otherwise cached information will be returned:
+### Obtaining user-related data
 
+If you have an `access_token`, you can use following code to retreive data:
 ```ruby
-user = User.load(:auth, 'access_token')   # Just set the token
-user.auth                                 # POST /auth/get
-user.auth                                 # No POST, return cached info
-user.auth(sync: true)                     # POST /auth/get again
-```
+require 'plaid'
 
-Same goes for other methods, except `User#transactions` and `User#balance` which always make requests to the API.
+client = Plaid::Client.new(env: :sandbox,
+                           client_id: '***',
+                           secret: '***',
+                           public_key: '***')
 
-### Categories
+item_response = client.item.create(credentials: { username: 'user_good',
+                                                  password: 'pass_good' },
+                                   institution_id: 'ins_109509',
+                                   initial_products: %i(auth identity transactions))
 
-You can request category information:
+access_token = item_response['access_token']
 
-```ruby
-cats = Plaid::Category.all             # Array of all known categories
-cat  = Plaid::Category.get('17001013') # A single category by its ID
-```
+auth_response = client.auth.get(access_token)
+auth = auth_response['auth']
 
-### Institutions
+```
 
-Financial institution information is available via `Plaid::Institution`.
+### Create a Stripe bank_account_token
 
+Exchange a Plaid Link `public_token` for an API `access_token` and a Stripe `bank_account_token`:
 ```ruby
-insts = Plaid::Institution.all(count: 20, offset: 20)        # A page
-inst  = Plaid::Institution.get('5301a93ac140de84910000e0')   # A single institution by its ID
+require 'plaid'
 
-res  = Plaid::Institution.search(query: 'c')         # Lookup by name
-```
+client = Plaid::Client.new(env: :sandbox,
+                           client_id: '***',
+                           secret: '***',
+                           public_key: '***')
 
-### Webhooks
+exchange_token_response = client.item.public_token.exchange('[Plaid Link public_token]')
+access_token = exchange_token_response['access_token']
 
-You can register to receive [Webhooks](https://plaid.com/docs/api/#webhook) from Plaid when your users have new events. If you do, you'll receive `POST` requests with JSON.
+stripe_response = client.processor.stripe.bank_account_token.create(access_token, '[Account ID]')
+bank_account_token = stripe_response['stripe_bank_account_token']
 
-E.g. Initial Transaction Webhook:
-```json
-{
- "message": "Initial transaction pull finished",
- "access_token": "xxxxx",
- "total_transactions": 123,
- "code": 0
-}
 ```
 
-You should parse that JSON into a Ruby Hash with String keys (eg. `webhook_hash = JSON.parse(json_string)`). Then, you can convert that Hash into a Ruby object using `Plaid::Webhook`:
+There are also a number of other methods you can use to retrieve data:
 
-```ruby
-webhook = Plaid::Webhook.new(webhook_hash)
-
-# Was that the Initial Transaction Webhook?
-webhook.initial_transaction?
-access_token = webhook.access_token
-total_transactions = webhook.total_transactions
-
-# Or did Historical Transactions become available?
-webhook.historical_transaction?
-access_token = webhook.access_token
-total_transactions = webhook.total_transactions
-
-# Or did Normal Transactions become available?
-webhook.normal_transaction?
-access_token = webhook.access_token
-total_transactions = webhook.total_transactions
-
-# Or maybe a transaction was removed?
-webhook.removed_transaction?
-access_token = webhook.access_token
-removed_transactions_ids = webhook.removed_transactions_ids
-
-# Or was the User's Webhook Updated?
-webhook.user_webhook_updated?
-access_token = webhook.access_token
-
-# Otherwise, was it an error?
-webhook.error_response?
-# Which error?
-error = webhook.error
-```
+* `client.accounts.get(access_code, ...)`: accounts
+* `client.accounts.balance.get(access_code, ...)`: real-time balances
+* `client.auth.get(access_code, ...)`: auth
+* `client.identity.get(access_code, ...)`: identity
+* `client.transactions.get(access_code, ...)`: transactions
+* `client.credit_details.get(access_code, ...)`: credit details
 
-### Custom clients
+All of these methods return appropriate data. More information and especially information about fields available in all the returned hashes can be found on the [API documentation](https://plaid.com/docs/api).
 
-It's possible to use several Plaid environments and/or credentials in one app by
-explicit instantiation of `Plaid::Client`:
+### Categories
 
-```ruby
-# Configuring the global client (Plaid.client) which is used by default
-Plaid.config do |p|
-  p.client_id = 'client_id_1'
-  p.secret = 'secret_1'
-  p.env = :tartan
-end
+You can request category information:
 
-# Creating a custom client
-api = Plaid::Client.new(client_id: 'client_id_2', secret: 'secret_2', env: :production)
+```ruby
+categories = client.categories.get             # Array of all known categories
+```
 
-# Tartan user (using default client)
-user1 = Plaid::User.create(:connect, 'wells', 'plaid_test', 'plaid_good')
+### Institutions
 
-# Api user (using api client)
-user2 = Plaid::User.create(:connect, 'wells', 'plaid_test', 'plaid_good', client: api)
+Financial institution information is available as shown below where the function arguments represent count and offset:
 
-# Lookup an institution in production
-res = Plaid::Institution.search(query: 'c', client: api)
+```ruby
+institutions = client.institutions.get(count: 3, offset: 1)
 ```
 
-The `client` option can be passed to the following methods:
-
-* `User.create`
-* `User.load`
-* `User.exchange_token`
-* `Category.all`
-* `Category.get`
-* `Institution.all`
-* `Institution.get`
-* `Institution.search`
-* `Institution.search_by_id`
-
-### Errors
+## Errors
 
 Any methods making API calls will result in an exception raised unless the response code is "200: Success" or
-"201: MFA Required".
+"210: MFA Required".
 
-`Plaid::BadRequestError` is raised when status code is "400: Bad Request".
+`Plaid::InvalidRequestError` is returned when the request is malformed and cannot be processed.
 
-`Plaid::UnauthorizedError` is raised when status code is "401: Unauthorized".
+`Plaid::InvalidInputError` is returned when all fields are provided and are in the correct format, but the values provided are incorrect in some way.
 
-`Plaid::RequestFailedError` is raised when status code is "402: Request Failed".
+`Plaid::RateLimitExceededError` returned when the request is valid but has exceeded established rate limits.
 
-`Plaid::NotFoundError` is raised when status code is "404: Cannot be Found".
+`Plaid::APIError` is returned during planned maintenance windows and in response to API internal server errors.
 
-`Plaid::ServerError` is raised when status code is "50X: Server Error".
+`Plaid::ItemError` indicates that information provided for the Item (such as credentials or MFA) may be invalid or that the Item is not supported on Plaid's platform.
 
 Read more about response codes and their meaning in the
-[Plaid documentation](https://plaid.com/docs/api/#response-codes).
-
-## Development
+[Plaid documentation](https://plaid.com/docs/api).
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+## Network Timeout
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+A network timeout value is set in the `lib/plaid/connect.rb` file. It is currently defaulted at 600 (in seconds) which equates to about 10 minutes. Some requests from the Plaid API may take longer than others and we want to make sure that all valid requests have a chance to complete. Adjust this value if necessary.
 
 ## Contributing