plaid 0.1.6 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e809fa56df8552695b93076d9d4e657301214dce
-  data.tar.gz: 599f6ceeb4e92f61fe31a93e28babac8726a067d
+  metadata.gz: 177a3e175a0defda0b9303805fe7f1f841d161d6
+  data.tar.gz: addfdce9ab4abe67eb4fa0478a83e56e5e09172e
 SHA512:
-  metadata.gz: 491571f86e7ff9f2bd61e0cc58e4088a79dcc92a118c69686863296882dfe5c5f0d3a3d57e477d4c48cc1e76d049e5a0571aafac08ab8f2129cfebda35373468
-  data.tar.gz: 50d6b0fabe1074af7a13590b038192d29bcef0846e4717f305fbaa6077a7382811c7fdf76e101aa0f6b717c7a43efd56cded725cac97604d4e2e4d6de1f21bdc
+  metadata.gz: 578a30e11a1c222c77a8c8cc6d5877400cd77d25cca5d898ade5e2f2fc5092d2fb248c874676999ab134911804724c7a23e3ef96af53b755056427c71cabe92c
+  data.tar.gz: e0e2213f052cb3641f715603ee0991cb24ee1edae76c5d913ecc3aabcddaf6bd7be5b10cd4841c4aeceff5209b6477a48080529ab12faaa25b35a2b9f525d674

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Justin Crites
+
+MIT License
+
+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

@@ -0,0 +1,31 @@
+# Plaid
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'plaid'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install plaid
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/plaid/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default  => :spec

data/lib/plaid.rb

@@ -1,20 +1,43 @@
+require 'plaid/version'
 require 'plaid/config'
-require 'plaid/call'
-require 'plaid/customer'
-require 'rest_client'
+require 'plaid/util'
+
+require 'plaid/auth'
+require 'plaid/user/user'
+require 'plaid/institution/institution'
+require 'plaid/category/category'
+
 module Plaid
+  # Define an instance of the gem thus responding with one customer at a time
   class << self
+    # Include the SDK methods
+
+    # Configures the gem with the public, private, and environment vars
     include Plaid::Configure
 
-    # Defined when a user exists with a unique access_token. Ex: Plaid.customer.get_transactions
-    def customer
-      @customer = Plaid::Customer.new
+    # Include the utility classes used throughout the gem
+    include Plaid::Util
+
+    # Includes the method to authenticate the user. Defined in auth.rb
+    include Plaid::Auth
+
+    # Builds the user object and returns on successful authentication
+    def user(res)
+      @user = Plaid::User.new
+      @user.new(res)
+    end
+
+    # Builds an institution object and returns when the institution details exist
+    def institution(res)
+      @institution = Plaid::Institution.new
+      @institution.new(res)
     end
 
-    # Defined for generic calls without access_tokens required. Ex: Plaid.call.add_accounts(username,password,type)
-    def call
-      @call = Plaid::Call.new
+    # Builds an institution object and returns when the category details exist
+    def category(res)
+      @category = Plaid::Category.new
+      @category.new(res)
     end
 
   end
-end
+end

data/lib/plaid/auth.rb

@@ -0,0 +1,12 @@
+module Plaid
+  module Auth
+      def auth(api_level,username,password,type)
+        begin
+          res = self.post(api_level,username,password,type)
+          self.user(res)
+        rescue => e
+          error_handler(e)
+        end
+      end
+  end
+end

data/lib/plaid/category/category.rb

@@ -0,0 +1,36 @@
+require 'plaid/util'
+module Plaid
+  class Category
+    include Plaid::Util
+
+    attr_accessor(:type, :hierarchy, :id)
+
+    # Returns an instantiated category object, or an array of all categories
+    def new(id=nil)
+      res = get('categories',id)
+      id.nil? ? cat = instantiate_all_categories(res) : cat = instantiate_one_category(res)
+      cat
+    end
+
+    def instantiate_all_categories(res)
+      cat_array = []
+      res['category'].each do |cat|
+        @category = Category.new
+        cat_array << @category.build_category(cat)
+      end
+      cat_array
+    end
+
+    def instantiate_one_category(res)
+      @category = Category.new
+      @category.build_category(res)
+    end
+
+    protected
+
+    def build_category(cat)
+      self.type = cat['type'], self.hierarchy = cat['hierarchy'], self.id = cat['id']
+    end
+
+  end
+end

data/lib/plaid/config.rb

@@ -1,8 +1,8 @@
 module Plaid
   module Configure
-    attr_writer :customer_id, :secret
+    attr_writer :customer_id, :secret, :environment_location
 
-    KEYS = [:customer_id, :secret]
+    KEYS = [:customer_id, :secret, :environment_location]
 
     def config
       yield self
@@ -10,4 +10,4 @@ module Plaid
     end
 
   end
-end
+end

data/lib/plaid/institution/institution.rb

@@ -0,0 +1,36 @@
+require 'plaid/util'
+module Plaid
+  class Institution
+    include Plaid::Util
+
+    attr_accessor(:id, :name, :type, :has_mfa, :mfa)
+
+    # Returns an instantiated category object, or an array of all categories
+    def new(id=nil)
+      res = get('institutions',id)
+      id.nil? ? cat = instantiate_all_institutions(res) : cat = instantiate_one_institution(res)
+      cat
+    end
+
+    def instantiate_all_institutions(res)
+      inst_array = []
+      res['institution'].each do |inst|
+        @institution = Institution.new
+        inst_array << @institution.build_institution(inst)
+      end
+      inst_array
+    end
+
+    def instantiate_one_institution(res)
+      @category = Institution.new
+      @category.build_institution(res)
+    end
+
+    protected
+
+    def build_institution(cat)
+      self.id = cat['id'], self.name = cat['name'], self.type = cat['type'], self.has_mfa = cat['has_mfa'], self.mfa = cat['mfa']
+    end
+
+  end
+end

data/lib/plaid/user/account/account.rb

@@ -0,0 +1,23 @@
+require 'plaid/util'
+module Plaid
+  class Account
+    include Plaid::Util
+    # Define vars for user accounts
+    attr_accessor(:available_balance, :current_balance, :institution_type, :meta, :transactions, :numbers, :name)
+
+    # Instantiate a new account with the results of the successful API call
+    # Build an array of nested transactions, and return self if successful
+    def new(res)
+      begin
+        self.name = res['name'], self.available_balance = res['balance']['available'], self.current_balance = res['balance']['current'], self.institution_type = res['institution_type']
+        self.meta = res['meta'] if res['meta']
+        res['numbers'] ? self.numbers = res['numbers'] : self.numbers = 'Upgrade user to access routing information for this account'
+      rescue => e
+        error_handler(e)
+      else
+        self
+      end
+    end
+
+  end
+end

data/lib/plaid/user/transaction/transaction.rb

@@ -0,0 +1,19 @@
+require 'plaid/util'
+module Plaid
+  class Transaction
+    include Plaid::Util
+    # Define vars for user accounts
+    attr_accessor(:id, :account, :amount, :name, :meta, :location, :pending, :score, :type, :category, :category_id)
+
+    # Instantiate a new account with the results of the successful API call
+    # Build an array of nested transactions, and return self if successful
+    def new(res)
+      begin
+        self.id = res['_id'], self.account = res['_account'], self.amount = res['amount'], self.name = res['name'], self.meta = res['meta'], self.location = res['location'], self.pending = res['pending'], self.score = res['score'], self.type = res['type'], self.category = res['category'], self.category_id = res['category_id']
+      rescue => e
+        error_handler(e)
+      end
+    end
+
+  end
+end

data/lib/plaid/user/user.rb

@@ -0,0 +1,54 @@
+require_relative 'account/account'
+require_relative 'transaction/transaction'
+require 'plaid/util'
+module Plaid
+  class User
+    include Plaid::Util
+
+    # Define user vars
+    attr_accessor(:accounts, :transactions, :access_token)
+
+    def initialize
+      self.accounts = []
+      self.transactions = []
+      self.access_token = ''
+    end
+
+    # Instantiate a new user with the results of the successful API call
+    # Build an array of nested accounts, and return self if successful
+    def new(res)
+      begin
+        self.access_token = res['access_token']
+        if res['msg'].nil?
+          res['accounts'].each do |account|
+            self.accounts << new_account(account)
+          end if res['accounts']
+          res['transactions'].each do |transaction|
+            self.transactions << new_transaction(transaction)
+          end if res['transactions']
+        else
+          self.accounts = res.msg, self.transactions = res.msg
+        end
+      rescue => e
+        error_handler(e)
+      else
+        self
+      end
+    end
+
+    protected
+
+    # Instantiate and build a new account object, return this to the accounts array
+    def new_account(account)
+      @account = Account.new
+      @account.new(account)
+    end
+
+    # Instantiate and build a new account object, return this to the accounts array
+    def new_transaction(transaction)
+      @transaction = Transaction.new
+      @transaction.new(transaction)
+    end
+
+  end
+end

data/lib/plaid/util.rb

@@ -0,0 +1,67 @@
+require 'net/http'
+require 'json'
+require 'uri'
+module Plaid
+  module Util
+
+    def post(path,username,password,type,options={})
+      uri = build_uri(path)
+      res = Net::HTTP.post_form(uri, {client_id: self.instance_variable_get(:'@customer_id') ,secret: self.instance_variable_get(:'@secret'), username: username, password: password, type: type})
+      parse_response(res)
+    end
+
+    def get(path,id=nil)
+      uri = build_uri(path,id)
+      res = Net::HTTP.get(uri)
+      parse_response(res)
+    end
+
+    def error_handler(err,res=nil)
+      case err
+        when 'Bad Request'
+          raise 'The request was malformed. Did you check the API docs?'
+        when 'Unauthorized'
+          raise 'Access denied: Try using the correct credentials.'
+        when 'Request Failed'
+          raise 'Request Failed'
+        when 'Not Found'
+          raise 'Not Found'
+        else
+          raise err
+      end
+    end
+
+    protected
+
+    def build_uri(path,id=nil)
+      id ? URI.parse(self.instance_variable_get(:'@environment_location') + path + id) :
+           URI.parse(self.instance_variable_get(:'@environment_location') + path)
+    end
+
+    private
+
+    def parse_response(res)
+      body = JSON.parse(res.body)
+      case res.code
+        when '200'
+          return body
+        when '201'
+          return { msg: 'Requires further authentication', body: body}
+        when '400'
+          error_handler('Bad Request',res)
+        when '401'
+          error_handler('Unauthorized',res)
+        when '402'
+          if body['code'] == 1205
+            return { msg: 'User account is locked', body: body }
+          else
+            error_handler('Request Failed',res)
+          end
+        when '404'
+          error_handler('Not Found',res)
+        else
+          error_handler('Server Error',res)
+      end
+    end
+  end
+end

data/lib/plaid/version.rb

@@ -0,0 +1,3 @@
+module Plaid
+  VERSION = '1.0.0'
+end

data/plaid.gemspec

@@ -0,0 +1,23 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'plaid/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'plaid'
+  spec.version       = Plaid::VERSION
+  spec.authors       = ['Justin Crites']
+  spec.email         = ['crites.justin@gmail.com']
+  spec.summary       = 'Ruby bindings for Plaid'
+  spec.description   = 'Ruby gem wrapper for the Plaid API. Read more at the homepage, the wiki, or the plaid documentation.'
+  spec.homepage      = 'https://github.com/plaid/plaid-ruby'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~>3.1'
+end

data/spec/plaid_spec.rb

@@ -0,0 +1,252 @@
+require 'spec_helper.rb'
+########## Plaid specs ##########
+describe Plaid do
+  # Configuration specs - used in gem configuration
+  describe '.config' do
+    context 'has valid dev keys' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      res = Plaid.auth('connect','plaid_test','plaid_good','wells')
+      it { expect(res).to be instance_of Plaid::User }
+    end
+
+    context 'has valid production keys' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://api.plaid.com/'
+      end
+      #TODO: Test production level credentials
+      res = Plaid.auth('connect','plaid_test','plaid_good','wells')
+      it { expect(res).to raise_error }
+    end
+
+    context 'has invalid dev keys' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_bad'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      it { expect(Plaid.auth('connect','plaid_test','plaid_good','wells')).to raise_error }
+    end
+
+    context 'has invalid production keys' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_bad'
+        p.environment_location = 'https://api.plaid.com/'
+      end
+      it { expect(Plaid.auth('connect','plaid_test','plaid_good','wells')).to raise_error }
+    end
+  end
+
+  # Authentication flow specs - returns Plaid::User
+  # TODO: Abstract the config from each section with the result in passing tests
+  describe '.auth' do
+
+    context 'has correct credentials for single factor auth, authenticates to the connect path' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      user = Plaid.auth('connect','plaid_test','plaid_good','wells')
+      it { expect(user.accounts.blank?).to be_false }
+    end
+
+    context 'has correct credentials for single factor auth, authenticates to the auth path' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      user = Plaid.auth('auth','plaid_test','plaid_good','wells')
+      it { expect(user.accounts[0].numbers.nil?).to be_false }
+    end
+
+    context 'has correct username, but incorrect password for single factor auth under auth path' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      it { expect(Plaid.auth('auth','plaid_test','plaid_bad','wells')).to raise_error }
+    end
+
+    context 'has incorrect username under auth path' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      it { expect(Plaid.auth('auth','plaid_bad','plaid_bad','wells')).to raise_error }
+    end
+
+    context 'has correct username, but incorrect password for single factor auth under connect path' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      it { expect(Plaid.auth('connect','plaid_test','plaid_bad','wells')).to raise_error }
+    end
+
+    context 'has incorrect username under connect path' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      it { expect(Plaid.auth('connect','plaid_bad','plaid_bad','wells')).to raise_error }
+    end
+
+    context 'has to enter MFA credentials' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      user = Plaid.auth('connect','plaid_selections', 'plaid_good','wells')
+      it { expect(user.accounts).to eq 'Requires further authentication' }
+    end
+
+    context 'enters correct information with locked account' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      user = Plaid.auth('connect','plaid_selections', 'plaid_locked','wells')
+      it { expect(user.accounts).to eq 'User account is locked' }
+    end
+  end
+
+=begin
+  TODO: Finish up these tests
+  # Institution specs
+  describe Plaid::Institution do
+
+    context 'when institution is found' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      institution = Plaid.institution('amex')
+      it { expect(institution).to be instance_of Plaid::Institution }
+    end
+
+    context 'when institution is not found' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      it { expect(Plaid.institution('dumb_bank')).to raise_error }
+    end
+  end
+
+  # Category specs
+  describe Plaid::Category do
+
+    context 'when category is found' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      category = Plaid.category('17001013')
+      it { expect(category).to be instance_of Plaid::Category }
+    end
+
+    context 'when category is not found' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      it { expect(Plaid.category('dumb_cat')).to raise_error }
+    end
+
+  end
+end
+
+########## Plaid instantiated user specs ##########
+
+describe Plaid::User do
+  subject(:success_user) { Plaid.auth('connect','plaid_test','plaid_good','wells') }
+  subject(:mfa_user) { Plaid.auth('connect','plaid_selections', 'plaid_good','wells') }
+
+  # MFA specs - after user is instantiated,
+  describe '#mfa_authentication' do
+    context 'has to enter another round of MFA credentials' do
+      res = user.mfa_authenticaiton('again')
+      expect(res).to eq 'Another round requested'
+    end
+
+    context 'enters correct credentials for MFA auth and authenticates' do
+      user.mfa_authentication('tomato')
+      expect(user.accounts).to be_truthy
+    end
+
+    context 'enters incorrect credentials for MFA auth' do
+      res = user.mfa_authentication('bad')
+      expect(res).to eq 'Incorrect answer to MFA'
+    end
+  end
+
+  # Upgrade specs - either pass or fails
+  describe '#upgrade' do
+    context 'auth upgrade is successful' do
+      user.upgrade('auth')
+      expect(user.auth).to be true
+    end
+
+    context 'auth upgrade failed' do
+      user.upgrade('auth')
+      expect(user.auth).to be false
+    end
+
+    context 'connect upgrade is successful' do
+      user.upgrade('connect')
+      expect(user.auth).to be true
+    end
+
+    context 'connect upgrade failed' do
+      user.upgrade('connect')
+      expect(user.auth).to be false
+    end
+  end
+
+  # Auth specs
+  describe '#auth' do
+    context 'has access and returns accounts' do
+      auth = user.auth
+      expect(auth).to be true
+      expect(user.accounts).to be_truthy
+    end
+
+    context 'does not have access to auth' do
+      auth = user.auth
+      expect(auth).to be false
+    end
+  end
+
+  # Connect specs
+  describe '#connect' do
+    context 'has access and returns accounts' do
+      expect(user.connect).to be true
+      expect(user.transactions).to be_truthy
+    end
+
+    context 'does not have access to auth' do
+      expect(user.connect).to be false
+    end
+  end
+
+=end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'plaid'

metadata

@@ -1,83 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: plaid
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 1.0.0
 platform: ruby
 authors:
 - Justin Crites
-- Gamble McAdam
-- Rahul Ramakrishnan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-11 00:00:00.000000000 Z
+date: 2015-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rest-client
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
+        version: '1.7'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: Ruby Gem wrapper for Plaid API.
-email: justin@guavatext.com
+        version: '3.1'
+description: Ruby gem wrapper for the Plaid API. Read more at the homepage, the wiki,
+  or the plaid documentation.
+email:
+- crites.justin@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
 - lib/plaid.rb
-- lib/plaid/call.rb
+- lib/plaid/auth.rb
+- lib/plaid/category/category.rb
 - lib/plaid/config.rb
-- lib/plaid/customer.rb
+- lib/plaid/institution/institution.rb
+- lib/plaid/user/account/account.rb
+- lib/plaid/user/transaction/transaction.rb
+- lib/plaid/user/user.rb
+- lib/plaid/util.rb
+- lib/plaid/version.rb
+- plaid.gemspec
+- spec/plaid_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/plaid/plaid-ruby
 licenses:
 - MIT
@@ -101,5 +101,7 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Plaid Ruby Gem
-test_files: []
+summary: Ruby bindings for Plaid
+test_files:
+- spec/plaid_spec.rb
+- spec/spec_helper.rb

data/lib/plaid/call.rb

@@ -1,83 +0,0 @@
-module Plaid
-  class Call
-
-    BASE_URL = 'https://tartan.plaid.com/'
-
-    # This initializes our instance variables, and sets up a new Customer class.
-    def initialize
-      Plaid::Configure::KEYS.each do |key|
-        instance_variable_set(:"@#{key}", Plaid.instance_variable_get(:"@#{key}"))
-      end
-    end
-
-    # This is a specific route for auth,
-    # it returns specific acct info
-    def add_account_auth(type, username, password, email)
-      parse_auth_response(post('/auth', type, username, password, email))
-    end
-
-    # This is a specific route for connect,
-    # it returns transaction information
-    def add_account_connect(type,username,password,email,options={})
-      parse_connect_response(post('/connect',type,username,password,email,options))
-    end
-
-    def get_place(id)
-      parse_place(get('entities/',id))
-    end
-
-    def get_institutions
-      JSON.parse(get('/institutions'))
-    end
-
-    protected
-
-    # Specific parser for auth response
-    def parse_auth_response(response)
-      parsed = JSON.parse(response)
-      case response.code
-      when 200
-        {code: response.code, access_token: parsed['access_token'], accounts: parsed['accounts']}
-      when 201
-        {code: response.code, type: parsed['type'], access_token: parsed['access_token'], mfa: parsed['mfa']}
-      else
-        {code: response.code, message: parsed}
-      end
-    end
-
-    def parse_connect_response(response)
-      parsed = JSON.parse(response)
-      case response.code
-      when 200
-        {code: response.code, access_token: parsed['access_token'], accounts: parsed['accounts'], transactions: parsed['transactions']}
-      when 201
-        {code: response.code, type: parsed['type'], access_token: parsed['access_token'], mfa: parsed['mfa']}
-      else
-        {code: response.code, message: parsed}
-      end
-    end
-
-    def parse_place(response)
-      parsed = JSON.parse(response)
-      {code: response.code, category: parsed['category'], name: parsed['name'], id: parsed['_id'], phone: parsed['meta']['contact']['telephone'], location: parsed['meta']['location']}
-    end
-
-    def parse_institutions(response)
-      parsed = JSON.parse(response)
-      {code: response.code, institutions: parsed}
-    end
-
-    private
-
-    def post(path,type,username,password,email,options={})
-      url = BASE_URL + path
-      RestClient.post url, client_id: self.instance_variable_get(:'@customer_id') ,secret: self.instance_variable_get(:'@secret'), type: type ,credentials: {username: username, password: password} ,email: email, options: options
-    end
-
-    def get(path,id = nil)
-      url = BASE_URL + path + id.to_s
-      RestClient.get(url)
-    end
-
-  end
-end

data/lib/plaid/customer.rb

@@ -1,68 +0,0 @@
-module Plaid
-  # This is used when a customer needs to be defined by the plaid access token.
-  # Abstracting as a class makes it easier since we wont have to redefine the access_token over and over.
-  class Customer
-
-    BASE_URL = 'https://tartan.plaid.com'
-
-    # This initializes our instance variables, and sets up a new Customer class.
-    def initialize
-      Plaid::Configure::KEYS.each do |key|
-        instance_variable_set(:"@#{key}", Plaid.instance_variable_get(:"@#{key}"))
-      end
-    end
-
-    def mfa_auth_step(access_token, code, type)
-      parse_response(post('/auth/step', access_token, mfa: code, type: type), 0)
-    end
-
-    def mfa_connect_step(access_token,code)
-      parse_response(post('/connect/step', access_token, mfa: code),1)
-    end
-
-    def get_transactions(access_token)
-      parse_response(get('/connect', access_token),2)
-    end
-
-    def delete_account(access_token)
-      parse_response(delete('/connect', access_token),3)
-    end
-
-    protected
-
-    def parse_response(response,method)
-      parsed = JSON.parse(response)
-      if response.code == '200'
-        case method
-        when 0
-          {code: response.code, access_token: parsed['access_token'], accounts: parsed['accounts']}
-        when 1
-          {code: response.code, access_token: parsed['access_token'], accounts: parsed['accounts'], transactions: parsed['transactions']}
-        when 2
-          {code: response.code, transactions: parsed['transactions']}
-        else
-          {code: response.code, message: parsed}
-        end
-      else
-        {code: response.code, message: parsed}
-      end
-    end
-
-    private
-
-    def get(path,access_token)
-      url = BASE_URL + path
-      RestClient.get(url, params: {client_id: self.instance_variable_get(:'@customer_id'), secret: self.instance_variable_get(:'@secret'), access_token: access_token})
-    end
-
-    def post(path,access_token,options={})
-      url = BASE_URL + path
-      RestClient.post url, client_id: self.instance_variable_get(:'@customer_id'), secret: self.instance_variable_get(:'@secret'), access_token: access_token, mfa: options[:mfa], type: options[:type]
-    end
-
-    def delete(path,access_token)
-      url = BASE_URL + path
-      RestClient.delete(url, params: {client_id: self.instance_variable_get(:'@customer_id'), secret: self.instance_variable_get(:'@secret'), access_token: access_token})
-    end
-  end
-end