wesabe-wesabe 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Wesabe
+
+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.markdown

@@ -0,0 +1,4 @@
+wesabe
+======
+
+Access the Wesabe API. See the examples directory for usage examples.

data/Rakefile

@@ -0,0 +1,12 @@
+task :default => :install
+
+desc "install the gem locally"
+task :install do
+  `which thor &>/dev/null`
+  if $?.exitstatus != 0
+    $stderr.puts "This project uses thor (http://github.com/wycats/thor)"
+    exit(1)
+  end
+  
+  sh %{thor :install}
+end

data/lib/cacert.pem

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDEzCCAnygAwIBAgIBATANBgkqhkiG9w0BAQQFADCBxDELMAkGA1UEBhMCWkEx
+FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD
+VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv
+biBTZXJ2aWNlcyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEm
+MCQGCSqGSIb3DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wHhcNOTYwODAx
+MDAwMDAwWhcNMjAxMjMxMjM1OTU5WjCBxDELMAkGA1UEBhMCWkExFTATBgNVBAgT
+DFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYDVQQKExRUaGF3
+dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNl
+cyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEmMCQGCSqGSIb3
+DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQAD
+gY0AMIGJAoGBANOkUG7I/1Zr5s9dtuoMaHVHoqrC2oQl/Kj0R1HahbUgdJSGHg91
+yekIYfUGbTBuFRkC6VLAYttNmZ7iagxEOM3+vuNkCXDF/rFrKbYvScg71CcEJRCX
+L+eQbcAoQpnXTEPew/UhbVSfXcNY4cDk2VuwuNy0e982OsK1ZiIS1ocNAgMBAAGj
+EzARMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEEBQADgYEAB/pMaVz7lcxG
+7oWDTSEwjsrZqG9JGubaUeNgcGyEYRGhGshIPllDfU+VPaGLtwtimHp1it2ITk6e
+QNuozDJ0uW8NxuOzRAvZim+aKZuZGCg70eNAKJpaPNW15yAbi8qkq43pUdniTCxZ
+qdq5snUb9kLy78fyGPmJvKP/iiMucEc=
+-----END CERTIFICATE-----

data/lib/wesabe/account.rb

@@ -0,0 +1,39 @@
+class Wesabe::Account
+  # The user-scoped account id, used to identify the account in URLs.
+  attr_accessor :id
+  # The user-provided account name ("Bank of America - Checking")
+  attr_accessor :name
+  # This account's balance or +nil+ if the account is a cash account.
+  attr_accessor :balance
+  # This account's currency.
+  attr_accessor :currency
+  # The financial institution this account is held at.
+  attr_accessor :financial_institution
+  
+  # Initializes a +Wesabe::Account+ and yields itself.
+  # 
+  # @yieldparam [Wesabe::Account] account
+  #   The newly-created account.
+  def initialize
+    yield self if block_given?
+  end
+  
+  # Returns a +Wesabe::Account+ generated from Wesabe's API XML.
+  # 
+  # @param [Hpricot::Element] xml
+  #   The <account> element from the API.
+  # 
+  # @return [Wesabe::Account]
+  #   The newly-created account populated by +xml+.
+  def self.from_xml(xml)
+    new do |account|
+      account.id = xml.at("id").inner_text.to_i
+      account.name = xml.at("name").inner_text
+      balance = xml.at("current-balance")
+      account.balance = balance.inner_text.to_f if balance
+      account.currency = Wesabe::Currency.from_xml(xml.at("currency"))
+      fi = xml.at("financial-institution")
+      account.financial_institution = Wesabe::FinancialInstitution.from_xml(fi) if fi
+    end
+  end
+end

data/lib/wesabe/credential.rb

@@ -0,0 +1,34 @@
+class Wesabe::Credential
+  # The id of the credential, used to identify the account in URLs.
+  attr_accessor :id
+  # The financial institution this credential is for.
+  attr_accessor :financial_institution
+  # The accounts linked to this credential.
+  attr_accessor :accounts
+  
+  # Initializes a +Wesabe::Credential+ and yields itself.
+  # 
+  # @yieldparam [Wesabe::Credential] credential
+  #   The newly-created credential.
+  def initialize
+    yield self if block_given?
+  end
+  
+  # Returns a +Wesabe::Credential+ generated from Wesabe's API XML.
+  # 
+  # @param [Hpricot::Element] xml
+  #   The <credential> element from the API.
+  # 
+  # @return [Wesabe::Credential]
+  #   The newly-created credential populated by +xml+.
+  def self.from_xml(xml)
+    new do |cred|
+      cred.id = xml.at('id').inner_text.to_i
+      cred.financial_institution = Wesabe::FinancialInstitution.from_xml(
+                                    xml.children_of_type('financial-institution')[0])
+      cred.accounts = xml.search('accounts account').map do |account|
+        Wesabe::Account.from_xml(account)
+      end
+    end
+  end
+end

data/lib/wesabe/currency.rb

@@ -0,0 +1,30 @@
+class Wesabe::Currency
+  attr_accessor :decimal_places, :symbol, :separator, :delimiter
+  
+  # Initializes a +Wesabe::Currency+ and yields itself.
+  # 
+  # @yieldparam [Wesabe::Currency] currency
+  #   The newly-created currency.
+  def initialize
+    yield self if block_given?
+  end
+  
+  alias_method :precision, :decimal_places
+  alias_method :precision=, :decimal_places=
+  
+  # Returns a +Wesabe::Currency+ generated from Wesabe's API XML.
+  # 
+  # @param [Hpricot::Element] xml
+  #   The <currency> element from the API.
+  # 
+  # @return [Wesabe::Currency]
+  #   The newly-created currency populated by +xml+.
+  def self.from_xml(xml)
+    new do |currency|
+      currency.decimal_places = xml[:decimal_places].to_s.to_i
+      currency.symbol         = xml[:symbol].to_s
+      currency.separator      = xml[:separator].to_s
+      currency.delimiter      = xml[:delimiter].to_s
+    end
+  end
+end

data/lib/wesabe/financial_institution.rb

@@ -0,0 +1,34 @@
+class Wesabe::FinancialInstitution
+  # The id of this +FinancialInstitution+, as used in URLs.
+  attr_accessor :id
+  # The name of this +FinancialInstitution+ ("Bank of America").
+  attr_accessor :name
+  # The url users of this +FinancialInstitution+ log in to for online banking.
+  attr_accessor :login_url
+  # The home url of this +FinancialInstitution+.
+  attr_accessor :homepage_url
+  
+  # Initializes a +Wesabe::FinancialInstitution+ and yields itself.
+  # 
+  # @yieldparam [Wesabe::FinancialInstitution] financial_institution
+  #   The newly-created financial institution.
+  def initialize
+    yield self if block_given?
+  end
+  
+  # Returns a +Wesabe::FinancialInstitution+ generated from Wesabe's API XML.
+  # 
+  # @param [Hpricot::Element] xml
+  #   The <financial-institution> element from the API.
+  # 
+  # @return [Wesabe::FinancialInstitution]
+  #   The newly-created financial institution populated by +xml+.
+  def self.from_xml(xml)
+    new do |fi|
+      fi.id = (xml.children_of_type("id") + xml.children_of_type("wesabe-id")).first.inner_text
+      fi.name = xml.at("name").inner_text
+      fi.login_url = xml.at("login-url") && xml.at("login-url").inner_text
+      fi.homepage_url = xml.at("homepage-url") && xml.at("homepage-url").inner_text
+    end
+  end
+end

data/lib/wesabe/request.rb

@@ -0,0 +1,144 @@
+class Wesabe::Request
+  attr_reader :url, :username, :password, :method, :proxy, :payload
+  
+  private
+  
+  def initialize(options=Hash.new)
+    @url = options[:url] or raise ArgumentError, "Missing option 'url'"
+    @username = options[:username] or raise ArgumentError, "Missing option 'username'"
+    @password = options[:password] or raise ArgumentError, "Missing option 'password'" 
+    @proxy = options[:proxy]
+    @method = options[:method] || :get
+    @payload = options[:payload]
+  end
+  
+  # Returns a new Net::HTTP instance to connect to the Wesabe API.
+  # 
+  # @return [Net::HTTP]
+  #   A connection object all ready to be used to communicate securely.
+  def net
+    if proxy
+      proxy_uri = URI.parse(proxy)
+      http_klass = Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
+    else
+      http_klass = Net::HTTP
+    end
+    
+    http = http_klass.new(uri.host, uri.port)
+    if uri.scheme == 'https'
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      http.ca_file = self.class.ca_file
+    end
+    http
+  end
+  
+  def uri
+    URI.join(self.class.base_url, url)
+  end
+  
+  def process_response(res)
+    if %w[200 201 202].include?(res.code)
+      res.body
+    elsif %w[301 302 303].include?(res.code)
+      url = res.header['Location']
+      
+      if url !~ /^http/
+        uri = URI.parse(@url)
+        uri.path = "/#{url}".squeeze('/')
+        url = uri.to_s
+      end
+      
+      raise Redirect, url
+    elsif res.code == "401"
+      raise Unauthorized
+    elsif res.code == "404"
+      raise ResourceNotFound
+    else
+      raise RequestFailed, url
+    end
+  end
+  
+  public
+  
+  # Executes the request and returns the response.
+  # 
+  # @return [String]
+  #   The response object for the request just made.
+  # 
+  # @raise [Wesabe::ServerConnectionBroken]
+  #   If the connection with the server breaks.
+  # 
+  # @raise [Timeout::Error]
+  #   If the request takes too long.
+  def execute
+    # set up the uri
+    @username = uri.user if uri.user
+    @password = uri.password if uri.password
+    
+    # set up the request
+    req = Net::HTTP.const_get(method.to_s.capitalize).new(uri.request_uri)
+    req.basic_auth(username, password)
+    
+    net.start do |http|
+      process_response http.request(req, payload || "")
+    end
+  end
+  
+  # Executes a request and returns the response.
+  # 
+  # @param [String] options[:url]
+  #   The url relative to +Wesabe::Request.base_url+ to request (required).
+  # 
+  # @param [String] options[:username]
+  #   The Wesabe username (required).
+  # 
+  # @param [String] options[:password]
+  #   The Wesabe password (required).
+  # 
+  # @param [String] options[:proxy]
+  #   The proxy url to use (optional).
+  # 
+  # @param [String, Symbol] options[:method]
+  #   The HTTP method to use (defaults to +:get+).
+  # 
+  # @param [String] options[:payload]
+  #   The post-body to use (defaults to an empty string).
+  # 
+  # @return [Net::HTTPResponse]
+  #   The response object for the request just made.
+  # 
+  # @raise [EOFError]
+  #   If the connection with the server breaks.
+  # 
+  # @raise [Timeout::Error]
+  #   If the request takes too long.
+  def self.execute(options=Hash.new)
+    new(options).execute
+  end
+  
+  def self.ca_file
+    [File.expand_path("~/.wesabe"), File.join(File.dirname(__FILE__), '..')].each do |dir|
+      file = File.join(dir, "cacert.pem")
+      return file if File.exist?(file)
+    end
+    raise "Unable to find a CA pem file to use for www.wesabe.com"
+  end
+  
+  # Gets the base url for the Wesabe API.
+  def self.base_url
+    @base_url ||= "https://www.wesabe.com"
+  end
+  
+  # Sets the base url for the Wesabe API.
+  def self.base_url=(base_url)
+    @base_url = base_url
+  end
+end
+
+class Wesabe::Request::Exception < RuntimeError; end
+class Wesabe::Request::ServerBrokeConnection < Exception; end
+class Wesabe::Request::Redirect < Exception; end
+class Wesabe::Request::Unauthorized < Exception; end
+class Wesabe::Request::ResourceNotFound < Exception; end
+class Wesabe::Request::RequestFailed < Exception; end

data/lib/wesabe.rb

@@ -0,0 +1,122 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'net/https'
+require 'hpricot'
+require 'yaml'
+
+# Provides an object-oriented interface to the Wesabe API.
+class Wesabe
+  attr_accessor :username, :password
+  
+  # Initializes access to the Wesabe API with a certain user. All requests 
+  # will be made in the context of this user.
+  # 
+  # @param [String] username
+  #   The username of an active Wesabe user.
+  # 
+  # @param [String] password
+  #   The password of an active Wesabe user.
+  def initialize(username, password)
+    self.username = username
+    self.password = password
+  end
+  
+  # Fetches the user's accounts list from Wesabe or, if the list was already
+  # fetched, returns the cached result.
+  # 
+  #   pp wesabe.accounts
+  #   [#<Wesabe::Account:0x106105c
+  #     @balance=-393.42,
+  #     @currency=
+  #      #<Wesabe::Currency:0x104fdc0
+  #       @decimal_places=2,
+  #       @delimiter=",",
+  #       @separator=".",
+  #       @symbol="$">,
+  #     @financial_institution=
+  #      #<Wesabe::FinancialInstitution:0x104b054
+  #       @homepage_url=nil,
+  #       @id="us-003383",
+  #       @login_url=nil,
+  #       @name="American Express Card">,
+  #     @id=4,
+  #     @name="Amex Blue">]
+  #
+  # @return [Array<Wesabe::Account>]
+  #   A list of the user's active accounts.
+  def accounts
+    @accounts ||= load_accounts
+  end
+  
+  # Returns an account with the given id or +nil+ if the account is not found.
+  # 
+  #   wesabe.account(4).name # => "Amex Blue"
+  # 
+  # @param [#to_s] id
+  #   Something whose +to_s+ result matches the +to_s+ result of the account id.
+  # 
+  # @return [Wesabe::Account, nil]
+  #   The account whose user-scoped id is +id+ or +nil+ if there is no account
+  #   with that +id+.
+  def account(id)
+    accounts.find {|a| a.id.to_s == id.to_s}
+  end
+  
+  # Fetches the user's accounts list from Wesabe or, if the list was already
+  # fetched, returns the cached result.
+  # 
+  #   pp wesabe.credentials
+  #   [#<Wesabe::Credential:0x10ae870
+  #     @accounts=[],
+  #     @financial_institution=
+  #      #<Wesabe::FinancialInstitution:0x1091928
+  #       @homepage_url=nil,
+  #       @id="us-003383",
+  #       @login_url=nil,
+  #       @name="American Express Card">,
+  #     @id=3>]
+  # 
+  # @return [Array<Wesabe::Account>]
+  #   A list of the user's active accounts.
+  def credentials
+    @credentials ||= load_credentials
+  end
+  
+  private
+  
+  def load_accounts
+    process_accounts(
+      Hpricot::XML(
+        Request.execute(
+          :url => '/accounts.xml', 
+          :username => username, 
+          :password => password)))
+  end
+  
+  def process_accounts(xml)
+    (xml / :accounts / :account).map do |element|
+      Account.from_xml(element)
+    end
+  end
+  
+  def load_credentials
+    process_credentials(
+      Hpricot::XML(
+        Request.execute(
+          :url => '/credentials.xml', 
+          :username => username, 
+          :password => password)))
+  end
+  
+  def process_credentials(xml)
+    (xml / :credentials / :credential).map do |element|
+      Credential.from_xml(element)
+    end
+  end
+end
+
+require 'wesabe/request'
+require 'wesabe/account'
+require 'wesabe/currency'
+require 'wesabe/credential'
+require 'wesabe/financial_institution'

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: wesabe-wesabe
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Brian Donovan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-04 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: "0.6"
+    version: 
+description: Wraps communication with the Wesabe API
+email: brian@wesabe.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+- LICENSE
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/cacert.pem
+- lib/wesabe
+- lib/wesabe/account.rb
+- lib/wesabe/credential.rb
+- lib/wesabe/currency.rb
+- lib/wesabe/financial_institution.rb
+- lib/wesabe/request.rb
+- lib/wesabe.rb
+has_rdoc: true
+homepage: https://www.wesabe.com/page/api
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: wesabe
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Wraps communication with the Wesabe API
+test_files: []
+