plaid-kilt 0.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b97a9853fe6fc505a415b82c258f6d2962c1fb2
+  data.tar.gz: f804262388591a3f8f37af71e3133de10bde95d6
+SHA512:
+  metadata.gz: 3a6e46925739f73d5a6710f0619c49b4fc20a6d207d46bb450096f9e2817a3b1ae6bcfa6110a49c398cc52279b5ae6e1e7696b9e4cefbe6c8c0664208225f981
+  data.tar.gz: 827cb24aacd8442693ea1d1e469b132b67cacd0410e3ee98011fff6c6b0e1a15718de1cc5031c2eab3f054dc4e750309b9cfa3d284350e3d31d756704a758cfc

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 1.8.7"
+end
+
+gem 'httparty'
+gem 'yard'

data/Gemfile.lock

@@ -0,0 +1,78 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (4.0.3)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    addressable (2.3.5)
+    atomic (1.1.14)
+    builder (3.2.2)
+    faraday (0.8.8)
+      multipart-post (~> 1.2.0)
+    git (1.2.6)
+    github_api (0.10.1)
+      addressable
+      faraday (~> 0.8.1)
+      hashie (>= 1.2)
+      multi_json (~> 1.4)
+      nokogiri (~> 1.5.2)
+      oauth2
+    hashie (2.0.5)
+    highline (1.6.20)
+    httparty (0.12.0)
+      json (~> 1.8)
+      multi_xml (>= 0.5.2)
+    httpauth (0.2.0)
+    i18n (0.6.9)
+    jeweler (1.8.8)
+      builder
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      github_api (= 0.10.1)
+      highline (>= 1.6.15)
+      nokogiri (= 1.5.10)
+      rake
+      rdoc
+    json (1.8.1)
+    jwt (0.1.8)
+      multi_json (>= 1.5)
+    minitest (4.7.5)
+    multi_json (1.8.4)
+    multi_xml (0.5.5)
+    multipart-post (1.2.0)
+    nokogiri (1.5.10)
+    oauth2 (0.9.2)
+      faraday (~> 0.8)
+      httpauth (~> 0.2)
+      jwt (~> 0.1.4)
+      multi_json (~> 1.0)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.1.1)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.1.6)
+    shoulda-matchers (2.4.0)
+      activesupport (>= 3.0.0)
+    thread_safe (0.1.3)
+      atomic
+    tzinfo (0.3.38)
+    yard (0.8.7.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  httparty
+  jeweler (~> 1.8.7)
+  rdoc (~> 3.12)
+  shoulda
+  yard

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 John Koisch
+
+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.rdoc

@@ -0,0 +1,157 @@
+= plaid
+
+Accessing the Plaid API using Ruby.
+
+=== Version
+
+Head is 0.5.1
+
+== API
+
+=== Grab a client
+
+    client = Plaid.client 'user@name.com','pass_word', 'amex'
+
+Where the last value is the institution.
+
+=== Connect
+
+Plaid uses the "connect" Plaid API call to initiate the user flow and to access information.
+
+    info = client.connect               <= gets information from Plaid
+
+=== Responses
+
+This gem returns values in response objects or error objects. This is not very ruby-esque,
+but it helps to make sense of the Plaid environment as well as making HTTPParty consumable for a business.
+
+Response objects are initialized when the client gets a valid response from plaid. In the case of non-MFA banks
+
+    r = client.connect
+
+* r.raw_response    <= the raw HTTPParty response from Plaid
+* r.accounts        <= Array of accounts associated with this institution for this user
+* r.transactions    <= Array of transactions associated with the accounts
+* r.is_mfa?         <= false for this request
+* r.message         <= "Successful retrieved information from bank"
+* r.http_code       <= 200 in this case
+
+Accounts and Transactions are objects that follow the JSON from Plaid. Thus you can expect to see
+
+    r.transactions[66].category_id              <= "52544965f71e87d007000119"
+    r.transactions[66].name                     <= "Online Payment Processed"
+    r.accounts[2].institution_type              <= "fake_institution"
+    r.accounts[2].balance["current"]            <= 8.98 (which ruby infers as a double)
+
+More explicitly
+
+    r.accounts[2].inspect
+
+    "#<PlaidObject:0x007f92853ca770 @type=\"credit\", @_id=\"52db1be4be13cbc36e000006\", @_item=\"52af631671c3bd1b25000064\", @_user=\"52af630f71c3bd1b25000063\", @balance={\"available\"=>3721, \"current\"=>8.98}, @meta={\"limit\"=>3500, \"name\"=>\"Plaid Credit Card\", \"number\"=>\"93004\"}, @institution_type=\"fake_institution\">"
+
+=== Errors
+
+Errors use the gem's PlaidError object
+
+    client = Plaid.client 'user@name.com','pass_word_xyz', 'amex'
+    r = client.connect
+
+* r.http_code       <= 402
+* r.plaid_code      <= Plaid's internal error code (https://plaid.com/expand#Response_Code_Detail)
+* r.error_message   <= "Error"
+* r.resolution      <= "The username or password provided were not correct."
+* r.raw_response    <= the raw HTTPParty response
+
+More explicitly
+
+    r = client.connect
+
+    "#<PlaidError:0x007f928513d638 @code=\"1200\", @message=\"Error\", @resolve=\"The username or password provided were not correct.\", @response=#<HTTParty::Response:0x7f928513d318 parsed_response={\"code\"=>1200, \"message\"=>\"invalid credentials\", \"resolve\"=>\"The username or password provided were not correct.\"}, @response=#<Net::HTTPPaymentRequired 402 Payment Required readbody=true>, @headers={\"content-type\"=>[\"application/json; charset=utf-8\"], \"date\"=>[\"Sat, 15 Mar 2014 17:31:46 GMT\"], \"x-powered-by\"=>[\"Express\"], \"content-length\"=>[\"109\"], \"connection\"=>[\"Close\"]}>>"
+
+=== MFA
+
+MFA requires some management of user flow, which is why this gem tries to make the returns / errors from API calls
+explicit. If it seems heavyweight to you, it is because the MFA process is a heavyweight process. Plaid does a
+better job managing it than some others, but if you are going to use Plaid extensively,
+then you are going to have to cope with MFA. See the wiki for more information.
+
+https://github.com/jkoisch/plaid/wiki/MFA
+
+These two diagrams go through user set up and user flow with MFA, respectively.
+
+https://github.com/jkoisch/plaid/blob/master/design/plaid_user_set_up.png
+https://github.com/jkoisch/plaid/blob/master/design/plaid_flows_connect.png
+
+=== Raw response
+
+You can, if you would rather, ignore the PlaidResponse objects.
+
+     #config/initializers/plaid.rb
+     config.save_full_response = true
+
+     #when you get your responses
+     x = client.connect
+     x.raw_response                 <= the raw http response to the request. Have fun.
+
+=== Thin Client
+
+The Plaid gem also has a thin_client for some secure followup operations:
+
+    thin_client = Plaid.thin_client "me@example.com", "chase", "access_token"
+
+This client can be used where user credentials are NOT needed, but you still want to access scecure information on
+the Plaid side of things:
+
+    thin_client.followup                                <= GET operation to get account and transaction information
+    thin_client.get_balance                             <= GET operation to receive account balances
+    thin_client.get_entity("unique_plaid_entity")       <= Entity context information
+
+== Configuration
+
+You need to configure access through your own initializers using the values you receive from Plaid.
+
+    #config/initializers/plaid.rb
+    Plaid.configure do |config|
+      config.client_id            = 'JUNK'
+      config.secret               = 'JUNK'
+      config.endpoint             = 'https://tartan.plaid.com/'
+      config.certpath             = 'ca-bundle.crt'
+      config.headers              = {'Content-Type'=>'application/x-www-form-urlencoded'}
+      config.webhook_address      = 'http://If.You.Need.To.You.Can.Use/plaid_webhook/antennas'
+      config.save_full_response   = false
+    end
+
+== Additional Client Methods
+
+The Plaid Client is not-quite-skinny so that it can handle various parts of the returns from the Plaid API. This is to
+support alternate user flows or user handling in implementation.
+
+The Plaid Client supports the following attr_readers, with the attribute settings handled through normal client
+management.
+
+    client.settings
+    client.username
+    client.password
+    client.institution
+    client.endpoint
+    client.secret
+    client.access_token
+    client.mfa_type
+    client.mfa_message
+    client.mfa_return               <= an array of the MFA returns from Plaid
+
+== Contributing to the plaid gem
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2014 John Koisch. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "plaid-kilt"
+  gem.homepage = "http://github.com/jkoisch/plaid"
+  gem.license = "MIT"
+  gem.summary = %Q{Access the Plaid API using Ruby}
+  gem.description = %Q{Access the Plaid API using Rubyre}
+  gem.email = "jk@cloudsway.com"
+  gem.authors = ["John Koisch"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "plaid #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.1

data/lib/plaid.rb

@@ -0,0 +1,35 @@
+module Plaid
+  class << self
+    def configure(&block)
+      Plaid::Client::Base.configure(&block)
+    end
+
+    # client for initializing access through Plaid
+    def client(user, email, password, institution)
+      Plaid::Client::Base.new(user, email, password, institution)
+    end
+
+    # a special thin client for accessing Plaid without credentials securely
+    def thin_client(e_mail, institution, access_token)
+      Plaid::Client::ThinClient.new(e_mail, institution, access_token)
+    end
+
+    #scaffolding are general purpose tools for dealing with Plaid
+    def scaffold
+      Plaid::Scaffold::Base
+    end
+  end
+end
+
+require 'plaid/client/client'
+require 'plaid/client/thin_client'
+require 'plaid/client/configuration'
+require 'plaid/client/connect'
+require 'plaid/client/entity'
+require 'plaid/client/balance'
+require 'plaid/client/followup'
+require 'plaid/scaffold/scaffold'
+require 'plaid/scaffold/institution'
+require 'plaid/plaid_object'
+require 'plaid/plaid_error'
+require 'plaid/plaid_response'

data/lib/plaid/client/balance.rb

@@ -0,0 +1,15 @@
+module Plaid
+  module Client
+    module Balances
+      include Plaid::Client::Configurations
+
+      def get_balance
+        body = body_retrieve
+
+        response = self.class.get('/balance', :query => body)
+        handle(response) { PlaidResponse.new(response, "Retrieved Balance") }
+      end
+
+    end
+  end
+end

data/lib/plaid/client/body.rb

@@ -0,0 +1,101 @@
+module Plaid
+  module Client
+    module Bodies
+      include Plaid::Client::Configurations
+
+      # Used before the organization is obtained and chosen by the user
+      def body
+        {
+            :client_id => self.client_id,
+            :secret => self.secret
+        }
+      end
+
+      # For accessing balances associated with an access_token via a GET
+      # * client_id
+      # * secret
+      # * access_token
+      # * institution type
+      # * email of the user
+      def body_retrieve
+        ret = Hash.new
+        ret[:access_token] = self.access_token
+        ret[:type] = self.institution
+        ret[:email] = self.email
+        ret.merge(body)
+      end
+
+      # the fundamental body object used in most calls to Plaid.
+      # * client_id
+      # * secret
+      # * institution_type
+      # * credentials
+      # * email
+      # * options {"list":true}
+      def body_original
+        ret = Hash.new
+        ret[:type] = self.institution
+        ret[:credentials] = {
+            "username" => self.username,
+            "password" => self.password
+        }
+        ret[:email] = 'me@example.com'
+        ret[:options] = options(nil,"list",true)
+        ret.merge(body)
+      end
+
+      def body_test
+        ret = hash.new
+        ret[:options] = options(nil,"pretty","true")
+        ret.merge(body_original)
+      end
+
+      #simple hash providing the entity_id to plaid.
+      def body_entity(entity_id)
+        {
+          :entity_id => entity_id,
+          :options => {"pretty"=>"true"}
+        }
+      end
+
+      #adds an mfa answer to the body.
+      #based on {#body}
+      def body_mfa(answer)
+        ret = Hash.new
+        ret[:mfa] = answer.to_s
+        ret[:access_token] = self.access_token
+        ret[:type] = self.institution
+        ret.merge(body)
+      end
+
+      #adds a webhook address to {#body_mfa}
+      def body_mfa_webhook(answer)
+        ret = Hash.new
+        ret[:options] = options(nil,"webhook", webhook_address )
+        ret.merge(body_mfa(answer))
+      end
+
+      def body_mfa_mode(mode)
+        ret = Hash.new
+        ret[:options] = options(nil, "send_method", mode)
+        ret[:access_token] = self.access_token
+        ret[:type] = self.institution
+        ret.merge(body)
+      end
+
+      def body_init_user
+        ret = Hash.new
+        ret[:options] = options(options(nil,"login",true),"webhook",webhook_address )
+        ret.merge(body_original)
+      end
+
+      #helper method to add options to an option hash
+      def options(original_hash=nil, key, value)
+        j = Hash.new
+        j[key] = value
+        j.merge(original_hash) unless original_hash.nil?
+        j
+      end
+    end
+  end
+end

data/lib/plaid/client/client.rb

@@ -0,0 +1,89 @@
+module Plaid
+  module Client
+
+    class Base
+      attr_accessor :mfa_response, :mfa_type, :mfa_message, :username, :password, :institution, :endpoint, :secret, :access_token, :is_mfa_initialized, :email
+
+      require 'plaid/client/configuration'
+      require 'plaid/client/connect'
+      require 'plaid/client/body'
+      require 'plaid/plaid_object'
+      require 'plaid/plaid_error'
+      require 'plaid/plaid_response'
+      require 'httparty'
+      include Plaid::Client::Configurations
+      include Plaid::Client::Logins
+      include Plaid::Client::Bodies
+      include HTTParty
+
+      base_uri endpoint
+      format :json
+      ssl_ca_file certpath
+      ssl_version :SSLv3
+      debug_output $stdout
+
+      def initialize(user, e_mail, pass_word, institution)
+        self.username = user
+        self.email = e_mail
+        self.password = pass_word
+        self.institution = institution
+        self.mfa_response ||= []
+      end
+
+      def settings
+        puts "Base URI: " + endpoint.to_s
+        puts "Cert: " + certpath.to_s
+        puts "User: " + self.username.to_s
+        puts "Email: " + self.email.to_s
+        puts "Plaid Client_id: " + self.client_id.to_s
+        puts "Webhook address: " + webhook_address
+        puts "Save full response: " + save_full_response.to_s
+      end
+
+      #generic method for handling the structure of the response. Only creates an error object if there is an error (business error) from Plaid.com. Yields to the block with calling function
+      def handle(response)
+        if response.code.eql? 200
+          self.mfa_type = nil
+          self.mfa_message = nil
+          self.is_mfa_initialized = false
+          yield(response)
+        elsif response.code.eql? 201        #mfa
+          mfa_201 = PlaidResponse.new(response, "MFA")
+          self.access_token = mfa_201.access_token
+          self.mfa_type = mfa_201.raw_response.type
+          self.mfa_response << mfa_201
+          self.mfa_message = mfa_201.message
+          self.is_mfa_initialized = mfa_201.is_mfa?
+          mfa_201
+        else
+          PlaidError.new(response, "Error")
+        end
+      end
+
+      #for testing through IRB
+      def secrets(client_id, secret)
+        self.client_id = client_id
+        self.secret = secret
+        "Set"
+      end
+
+      def is_mfa?
+        @is_mfa_initialized
+      end
+
+      def plaid_response_codes
+        {
+          200 => "Success",
+          201 => "MFA Required",
+          400 => "Bad Request",
+          401 => "Unauthorized",
+          402 => "Request Failed",
+          404 => "Cannot be Found",
+          500 => "Server Error"
+        }
+      end
+    end
+
+  end
+
+end

data/lib/plaid/client/configuration.rb

@@ -0,0 +1,79 @@
+module Plaid
+  module Client
+    module Configurations
+      require 'active_support/concern'
+      extend ActiveSupport::Concern
+
+      included do
+        #Plaid.com
+        add_config :endpoint
+        add_config :headers
+
+        #app
+        add_config :certpath
+        add_config :client_id
+        add_config :secret
+        add_config :webhook_address
+        add_config :save_full_response
+
+        # set default values
+        reset_config
+      end
+
+      module ClassMethods
+
+        def add_config(name)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+
+              def self.#{name}(value=nil)
+                @#{name} = value if value
+                return @#{name} if self.object_id == #{self.object_id} || defined?(@#{name})
+                name = superclass.#{name}
+                return nil if name.nil? && !instance_variable_defined?("@#{name}")
+                @#{name} = name && !name.is_a?(Module) && !name.is_a?(Symbol) && !name.is_a?(Numeric) && !name.is_a?(TrueClass) && !name.is_a?(FalseClass) ? name.dup : name
+              end
+
+              def self.#{name}=(value)
+                @#{name} = value
+              end
+
+              def #{name}=(value)
+                @#{name} = value
+              end
+
+              def #{name}
+                value = @#{name} if instance_variable_defined?(:@#{name})
+                value = self.class.#{name} unless instance_variable_defined?(:@#{name})
+                if value.instance_of?(Proc)
+                  value.arity >= 1 ? value.call(self) : value.call
+                else
+                  value
+                end
+              end
+          RUBY
+        end
+
+        def configure
+          yield self
+        end
+
+        ##
+        # sets configuration to default
+        #
+        def reset_config
+          configure do |config|
+
+            config.client_id            = 'JUNK'
+            config.secret               = 'JUNK'
+            config.endpoint             = 'https://tartan.plaid.com/'
+            config.certpath             = 'ca-bundle.crt'
+            config.headers              = {'Content-Type'=>'application/x-www-form-urlencoded'}
+            config.webhook_address      = 'http://domain.com/plaid_webhook/antennas'
+            config.save_full_response   = true
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plaid/client/connect.rb

@@ -0,0 +1,67 @@
+module Plaid
+  module Client
+    module Logins
+      include Plaid::Client::Configurations
+
+      #connects to the plaid api.
+      #this can be used to retrieve information, get the access token, and initialize a user.
+      #sets the access token on the {Plaid::Client::Base}
+      #@return {PlaidResponse}
+      def connect
+        body = body_original
+
+        response = self.class.post('/connect', :query => body)
+
+        handle(response) do |r|
+          plaid = PlaidResponse.new(r, "Successful retrieved information from bank")
+          self.access_token = plaid.access_token
+          plaid
+        end
+      end
+
+      #The basic way to submit MFA information to Plaid.
+      #Simply appends the answer into the parameters for submission.
+      #@return {PlaidResponse} or {PlaidError}
+      def connect_step(mfa_response)
+        body = body_mfa(mfa_response)
+        response = self.class.post('/connect/step', :query => body)
+
+        handle(response) { PlaidResponse.new(response, "Successful MFA submission - retrieved information from bank") }
+      end
+
+      #Submits an MFA answer to Plaid.
+      #Adds a webhook return address as a parameter.
+      #@return {PlaidResponse} or {PlaidError}
+      def connect_step_webhook(mfa_response)
+        body = body_mfa_webhook(mfa_response)
+        response = self.class.post('/connect/step', :query => body)
+
+        handle(response) { PlaidResponse.new(response, "Successful MFA submission - Webhook will notify when retrieved information from bank") }
+      end
+
+      # Plaid's preferred way to initialize a user to their bank via the Plaid Proxy.
+      #
+      def connect_init_user
+        body = body_init_user
+        response = self.class.post('/connect', :query => body)
+
+        handle(response) { PlaidResponse.new(response, "Successfully added user; Wait on Webhook Response") }
+      end
+
+      def connect_filter_response
+
+      end
+
+      def connect_step_specify_mode(mode)
+        body = body_mfa_mode(mode)
+        response = self.class.post('/connect/step', :query => body)
+        handle(response) { PlaidResponse.new(response, "Successful MFA mode submission - You will now be asked to
+input your code.") }
+      end
+
+    end
+
+  end
+
+end
+

data/lib/plaid/client/entity.rb

@@ -0,0 +1,16 @@
+module Plaid
+  module Client
+    module Entities
+      include Plaid::Client::Configurations
+
+      def get_entity(entity_id)
+        body = body_entity(entity_id)
+
+        response = self.class.get('/entity', :query => body)
+
+        handle(response) { PlaidResponse.new(response, "Retrieved Entity")}
+      end
+
+    end
+  end
+end

data/lib/plaid/client/followup.rb

@@ -0,0 +1,15 @@
+module Plaid
+  module Client
+    module Followups
+      include Plaid::Client::Configurations
+
+      #explicitly for following up after an init to retrieve updated information from Plaid
+      def followup
+        body = body_retrieve
+        response = self.class.get('/connect', :query => body)
+
+        handle(response) { PlaidResponse.new(response, "Successfully retrieved Transactions") }
+      end
+    end
+  end
+end

data/lib/plaid/client/thin_client.rb

@@ -0,0 +1,60 @@
+module Plaid
+  module Client
+    class ThinClient
+      attr_accessor :institution, :endpoint, :secret, :access_token, :email, :client_id
+
+      require 'plaid/client/configuration'
+      require 'plaid/client/followup'
+      require 'plaid/client/entity'
+      require 'plaid/client/balance'
+      require 'plaid/client/body'
+      require 'plaid/plaid_object'
+      require 'plaid/plaid_error'
+      require 'plaid/plaid_response'
+      require 'httparty'
+      include Plaid::Client::Configurations
+      include Plaid::Client::Bodies
+      include Plaid::Client::Entities
+      include Plaid::Client::Balances
+      include Plaid::Client::Followups
+      include HTTParty
+
+      base_uri endpoint
+      format :json
+      ssl_ca_file certpath
+      ssl_version :SSLv3
+      debug_output $stdout
+
+      def initialize(e_mail, institution, access_token)
+        self.email = e_mail
+        self.institution = institution
+        self.access_token = access_token
+      end
+
+      #for testing through IRB
+      def secrets(client_id, secret)
+        self.client_id = client_id
+        self.secret = secret
+        "Set"
+      end
+
+      def settings
+        puts "Base URI: " + endpoint.to_s
+        puts "Cert: " + certpath.to_s
+        puts "Email: " + self.email.to_s
+        puts "Plaid Client_id: " + self.client_id.to_s
+        puts "Webhook address: " + webhook_address
+        puts "Save full response: " + save_full_response.to_s
+      end
+
+      #generic method for handling the structure of the response. Only creates an error object if there is an error (business error) from Plaid.com. Yields to the block with calling function
+      def handle(response)
+        if response.code.eql? 200
+          yield(response)
+        else
+          PlaidError.new(response, "Error")
+        end
+      end
+    end
+  end
+end

data/lib/plaid/plaid_error.rb

@@ -0,0 +1,38 @@
+class PlaidError < PlaidObject
+
+  require 'plaid/plaid_object'
+
+  @error = nil
+  @message = nil
+  @response = nil
+
+  def initialize(response, message)
+    if response.parsed_response
+      super(response.parsed_response)
+    else
+      super(response)
+    end
+    @response = response
+    @message = message
+  end
+
+  def error_message
+    self.message
+  end
+
+  def http_code
+    @response.code if @response
+  end
+
+  def plaid_code
+    response.code
+  end
+
+  def resolution
+    self.resolve
+  end
+
+  def raw_response
+    @response if @response
+  end
+end

data/lib/plaid/plaid_object.rb

@@ -0,0 +1,33 @@
+class PlaidObject
+
+  def initialize(hash)
+    hash.keys.each do |key|
+      self.class.send(:define_method, "#{key}") do
+        instance_variable_get("@#{key}")
+      end
+
+      if hash[key].is_a? Array
+        arr = []
+        hash[key].each do |chunk|
+          if chunk.is_a? Hash
+            arr <<  PlaidObject.new(chunk)
+          else
+            arr << chunk
+          end
+        end
+        instance_variable_set("@#{key}", arr)
+      elsif hash[key].is_a? Hash
+        h = hash[key]
+        instance_variable_set("@#{key}", h)
+      else
+        eval("@#{key} = '#{encode(hash[key].to_s)}'")
+      end
+    end
+
+  end
+
+  def encode(str)
+    str.gsub("'", "")
+  end
+
+end

data/lib/plaid/plaid_response.rb

@@ -0,0 +1,80 @@
+class PlaidResponse
+  include Plaid::Client::Configurations
+
+  require 'plaid/plaid_object'
+  require 'plaid/client/configuration'
+
+  attr_reader :http_code, :mfa_message, :accounts, :transactions, :access_token
+
+  @response = nil
+  @message = "N/A"
+  @mfa_type
+  @mfa_message
+  @questions = nil
+  @mfa_modes = nil
+  @is_mfa_initialized = false
+
+  def initialize(response, message=nil)
+    @http_code = response.code
+    zed = PlaidObject.new(response)
+
+    if save_full_response.eql?(save_full_response)
+      @response = zed
+    end
+
+    unless message.eql?("MFA")
+      @accounts = zed.accounts
+      @transactions = zed.transactions
+      @is_mfa_initialized = false
+    else
+      manage_mfa_type(zed)
+      @is_mfa_initialized = true
+    end
+
+    @access_token = zed.access_token
+    @message = message if message
+    zed = nil
+  end
+
+  def raw_response
+    @response
+  end
+
+  def message
+    @message.eql?("MFA") ? @message + ": " + @mfa_message : @message
+  end
+
+  def mfa_type
+    @message.eql?("MFA") ? @mfa_type : "Not a response from an MFA request to a bank"
+  end
+
+  def is_mfa?
+    @is_mfa_initialized
+  end
+
+  def mfa_modes
+    @mfa_modes
+  end
+
+  def manage_mfa_type(zed)
+    @mfa_type = zed.type
+
+    if @mfa_type.eql?("device")
+      @mfa_message = zed.mfa["message"]
+    elsif @mfa_type.eql?("questions")
+      @questions ||= []
+      zed.mfa.each do |q|
+        @questions << q.question
+      end
+      @mfa_message = @questions.reverse.pop
+    elsif @mfa_type.eql?("list")
+      @mfa_modes ||= []
+      @mfa_message = "There are several ways to authenticate, or it will default to your email"
+      zed.mfa.each do |q|
+        @mfa_modes << q
+      end
+    end
+
+  end
+
+end

data/lib/plaid/scaffold/institution.rb

@@ -0,0 +1,26 @@
+module Plaid
+  module Scaffold
+    module Institutions
+
+      module ClassMethods
+        def index_institutions
+          ret = []
+          response = self.get('/institutions')
+          response.each do |piece|
+            ret << PlaidObject.new(piece)
+          end
+          self.institutions = ret
+        end
+
+        def get_institution(id)
+          response = self.get('/institutions/' + id.to_s)
+          PlaidObject.new(response)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/plaid/scaffold/scaffold.rb

@@ -0,0 +1,39 @@
+module Plaid
+  module Scaffold
+    class Base
+
+      require 'plaid/scaffold/institution'
+      require 'plaid/client/configuration'
+      require 'plaid/plaid_object'
+      require 'plaid/plaid_error'
+      require 'plaid/plaid_response'
+      require 'httparty'
+      require 'singleton'
+      include Plaid::Scaffold::Institutions
+      include Plaid::Client::Configurations
+      include HTTParty
+      include Singleton
+
+      base_uri endpoint
+      format :json
+      ssl_ca_file certpath
+      ssl_version :SSLv3
+      debug_output $stdout
+
+      @@institutions ||= []
+
+      def self.institutions=(i)
+        @@institutions = i
+      end
+
+      def self.institutions
+        if @@institutions.empty?
+          self.index_institutions rescue "There is something wrong with Plaid!"
+        end
+
+        @@institutions
+      end
+
+    end
+  end
+end

data/lib/plaid/text/exposition.rb

@@ -0,0 +1,33 @@
+module Plaid
+  module Text
+    class Narrative
+       class << self
+
+         def introduction
+
+         end
+
+
+         def submit_credentials
+
+         end
+
+
+         def get_transaction
+
+         end
+
+         def updating_institution_info
+
+         end
+
+         def mfa
+
+         end
+
+
+
+       end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'plaid'
+
+class Test::Unit::TestCase
+end

data/test/test_plaid.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestPlaid < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: plaid-kilt
+version: !ruby/object:Gem::Version
+  version: 0.5.1
+platform: ruby
+authors:
+- John Koisch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  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: yard
+  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: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+description: Access the Plaid API using Rubyre
+email: jk@cloudsway.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .DS_Store
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- design/plaid_flows_connect.png
+- design/plaid_user_set_up.png
+- lib/plaid.rb
+- lib/plaid/client/balance.rb
+- lib/plaid/client/body.rb
+- lib/plaid/client/client.rb
+- lib/plaid/client/configuration.rb
+- lib/plaid/client/connect.rb
+- lib/plaid/client/entity.rb
+- lib/plaid/client/followup.rb
+- lib/plaid/client/thin_client.rb
+- lib/plaid/plaid_error.rb
+- lib/plaid/plaid_object.rb
+- lib/plaid/plaid_response.rb
+- lib/plaid/scaffold/institution.rb
+- lib/plaid/scaffold/scaffold.rb
+- lib/plaid/text/exposition.rb
+- test/helper.rb
+- test/test_plaid.rb
+homepage: http://github.com/jkoisch/plaid
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Access the Plaid API using Ruby
+test_files: []