wesabe 0.0.3

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,16 @@
+wesabe
+======
+
+Access the Wesabe API. See the examples directory for usage examples.
+
+Installation
+------------
+
+Make sure you have bundler installed, then run this:
+
+    $ gem bundle --cached
+    $ rake spec gem
+
+Assuming the specs pass and the gem is generated, run this (with `sudo` if required):
+
+    $ gem install pkg/wesabe*.gem

data/Rakefile

@@ -0,0 +1,75 @@
+require 'rubygems'
+require 'rubygems/specification'
+require 'rake/gempackagetask'
+require 'bundler'
+require File.dirname(__FILE__)+'/lib/wesabe'
+
+GEM = "wesabe"
+GEM_VERSION = Wesabe::VERSION
+AUTHOR = "Brian Donovan"
+EMAIL = "brian@wesabe.com"
+HOMEPAGE = "https://www.wesabe.com/page/api"
+SUMMARY = "Wraps communication with the Wesabe API"
+PROJECT = "wesabe"
+
+SPEC = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.markdown", "LICENSE"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.rubyforge_project = PROJECT
+
+  env = Bundler::Bundle.load.environment
+  env.dependencies.each do |dep|
+    s.add_dependency(dep.name, dep.version.to_s)
+  end
+
+  s.require_path = 'lib'
+  # s.bindir = "bin"
+  # s.executables = %w( wesabe )
+  s.files = %w(LICENSE README.markdown Rakefile) + Dir.glob("{bin,lib,specs}/**/*")
+end
+
+Rake::GemPackageTask.new(SPEC) do |pkg|
+  pkg.gem_spec = SPEC
+end
+
+require 'spec/rake/spectask'
+desc "Run specs"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << %w(-fs --color) << %w(-O spec/spec.opts)
+  t.spec_opts << '--loadby' << 'random'
+  t.spec_files = Dir["spec/**/*_spec.rb"]
+end
+
+desc "Generates the documentation for this project"
+task :doc do
+  `yardoc 'lib/**/*.rb' 2>/dev/null`
+  `open doc/index.html 2>/dev/null`
+end
+
+namespace :wesabe do
+  desc "Downloads and installs an updated PEM file (requires openssl)"
+  task :update_pem do
+    # get the certificate
+    certs = `echo QUIT | openssl s_client -showcerts -connect www.wesabe.com:443 2>/dev/null`
+    pem = certs[/-----BEGIN CERTIFICATE-----(?:.|\n)+?-----END CERTIFICATE-----/, 0]
+
+    # write it to our pem file
+    dir  = File.expand_path("~/.wesabe")
+    path = File.join(dir, "cacert.pem")
+    FileUtils.mkdir_p(dir)
+    File.open(path, 'w') do |file|
+      file.puts pem
+    end
+    puts "Wrote PEM file to #{path}"
+  end
+end
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'rubygems'
+require 'wesabe'
+
+require 'yaml'
+
+def usage(why = nil)
+  $stderr.puts "failed for reason: #{why}" if why
+  $stderr.puts "usage: console [url|name] [username] [password]"
+  exit(1)
+end
+
+@url = ARGV.shift if ARGV.size != 2
+@username, @password = ARGV.shift, ARGV.shift
+
+@url ||= "https://www.wesabe.com/"
+
+config = YAML.load(File.read(ENV['HOME'] + "/.wesabe.console")) rescue {}
+
+if c = config[@url]
+  @url = c["url"]
+  @username = c["username"] || @username
+  @password = c["password"] || @password
+end
+
+usage("invalid url #{@url.inspect}") unless @url =~ /^https?/
+usage("missing username") unless @username
+usage("missing password") unless @password
+
+def w
+  @w ||= begin
+    Wesabe::Request.base_url = @url
+    Wesabe.new(@username, @password)
+  end
+end
+
+w # force it to load
+
+def method_missing(s, *args, &b)
+  super unless w.respond_to?(s)
+  begin
+    w.send(s, *args, &b)
+  rescue Wesabe::Request::RequestFailed => e
+    puts e.response.body
+    raise e
+  end
+end
+
+require 'irb'
+require 'irb/completion'
+
+if File.exists? ".irbrc"
+  ENV['IRBRC'] = ".irbrc"
+end
+
+ARGV.clear
+
+puts "Starting the Wesabe API console for #{@username} at #{@url}"
+puts "(try 'accounts', 'credentials', or 'targets')"
+
+IRB.start
+exit!

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.rb

@@ -0,0 +1,164 @@
+$:.unshift(File.dirname(__FILE__))
+
+begin
+  require 'rubygems'
+rescue LoadError
+  # no rubygems, just keep going
+end
+
+require 'hpricot'
+require 'net/https'
+require 'yaml'
+require 'time'
+
+# Provides an object-oriented interface to the Wesabe API.
+class Wesabe
+  attr_accessor :username, :password
+
+  VERSION = '0.0.3'
+
+  # 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
+
+  # Fetches the user's targets list from Wesabe or, if the list was already
+  # fetched, returns the cached result.
+  def targets
+    @targets ||= load_targets
+  end
+
+  # Executes a request via POST with the initial username and password.
+  #
+  # @see Wesabe::Request::execute
+  def post(options)
+    Request.execute({:method => :post, :username => username, :password => password}.merge(options))
+  end
+
+  # Executes a request via GET with the initial username and password.
+  #
+  # @see Wesabe::Request::execute
+  def get(options)
+    Request.execute({:method => :get, :username => username, :password => password}.merge(options))
+  end
+
+  def inspect
+    "#<#{self.class.name} username=#{username.inspect} password=#{password.gsub(/./, '*').inspect} url=#{Wesabe::Request.base_url.inspect}>"
+  end
+
+  private
+
+  def load_accounts
+    process_accounts( Hpricot::XML( get(:url => '/accounts.xml') ) )
+  end
+
+  def process_accounts(xml)
+    associate((xml / :accounts / :account).map do |element|
+      Account.from_xml(element)
+    end)
+  end
+
+  def load_credentials
+    process_credentials( Hpricot::XML( get(:url => '/credentials.xml') ) )
+  end
+
+  def process_credentials(xml)
+    associate((xml / :credentials / :credential).map do |element|
+      Credential.from_xml(element)
+    end)
+  end
+
+  def load_targets
+    process_targets( Hpricot::XML( get(:url => '/targets.xml') ) )
+  end
+
+  def process_targets(xml)
+    associate((xml / :targets / :target).map do |element|
+      Target.from_xml(element)
+    end)
+  end
+
+  def associate(what)
+    Wesabe::Util.all_or_one(what) {|obj| obj.wesabe = self}
+  end
+end
+
+require 'wesabe/util'
+require 'wesabe/request'
+require 'wesabe/base_model'
+require 'wesabe/account'
+require 'wesabe/upload'
+require 'wesabe/financial_institution'
+require 'wesabe/currency'
+require 'wesabe/credential'
+require 'wesabe/job'
+require 'wesabe/target'

data/lib/wesabe/account.rb

@@ -0,0 +1,62 @@
+# Encapsulates an account from Wesabe's API.
+class Wesabe::Account < Wesabe::BaseModel
+  # The user-scoped account id, used to identify the account in URLs.
+  attr_accessor :id
+  # The application-scoped account id, used in upload
+  attr_accessor :number
+  # The user-provided account name ("Bank of America - Checking")
+  attr_accessor :name
+  # The account type ("Credit Card", "Savings" ...)
+  attr_accessor :type
+  # 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
+
+  # Creates a +Wesabe::Upload+ that can be used to upload to this account.
+  #
+  # @return [Wesabe::Upload]
+  #   The newly-created upload, ready to be used to upload a statement.
+  def new_upload
+    Wesabe::Upload.new do |upload|
+      upload.accounts = [self]
+      upload.financial_institution = financial_institution
+      associate upload
+    end
+  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
+      account.type = xml.at("account-type").inner_text
+      account.number = xml.at("account-number").inner_text if xml.at("account-number")
+      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
+
+  def inspect
+    inspect_these :id, :number, :type, :name, :balance, :financial_institution, :currency
+  end
+end

data/lib/wesabe/base_model.rb

@@ -0,0 +1,31 @@
+class Wesabe::BaseModel
+  include Wesabe::Util
+  # The +Wesabe+ instance this model uses.
+  #
+  # @return [Wesabe] The object containing the username/password to use.
+  attr_accessor :wesabe
+
+  # Requests via POST using the given options.
+  #
+  # @see Wesabe#post
+  def post(options)
+    wesabe.post(options)
+  end
+
+  # Requests via GET using the given options.
+  #
+  # @see Wesabe#get
+  def get(options)
+    wesabe.get(options)
+  end
+
+  private
+
+  def associate(what)
+    all_or_one(what) {|obj| obj.wesabe = wesabe}
+  end
+
+  def inspect_these(*attributes)
+    "#<#{self.class.name}#{attributes.map{|a| " #{a}=#{send(a).inspect}"}.join}>"
+  end
+end

data/lib/wesabe/credential.rb

@@ -0,0 +1,52 @@
+class Wesabe::Credential < Wesabe::BaseModel
+  # 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
+
+  # Starts a new sync job for this +Wesabe::Credential+.
+  #
+  # @return [Wesabe::Job]
+  #   The job that was just started.
+  def start_job
+    associate(Wesabe::Job.from_xml(Hpricot::XML(post(:url => "/credentials/#{id}/jobs.xml")) / :job))
+  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
+
+  def inspect
+    inspect_these :id, :financial_institution, :accounts
+  end
+
+  private
+
+  def associate(what)
+    all_or_one(super(what)) {|obj| obj.credential = self}
+  end
+end

data/lib/wesabe/currency.rb

@@ -0,0 +1,34 @@
+class Wesabe::Currency < Wesabe::BaseModel
+  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
+
+  def inspect
+    inspect_these :symbol, :decimal_places, :separator, :delimiter
+  end
+end

data/lib/wesabe/financial_institution.rb

@@ -0,0 +1,38 @@
+class Wesabe::FinancialInstitution < Wesabe::BaseModel
+  # 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
+
+  def inspect
+    inspect_these :id, :name
+  end
+end

data/lib/wesabe/job.rb

@@ -0,0 +1,97 @@
+class Wesabe::Job < Wesabe::BaseModel
+  # The globally unique identifier for this job.
+  attr_accessor :id
+  # The status of this job (pending|successful|failed).
+  attr_accessor :status
+  # The result of this job, which gives more specific
+  # information for "pending" and "failed" statuses.
+  attr_accessor :result
+  # When this job was created.
+  attr_accessor :created_at
+  # The credential that this job belongs to.
+  attr_accessor :credential
+
+  # Initializes a +Wesabe::Job+ and yields itself.
+  #
+  # @yieldparam [Wesabe::Job] job
+  #   The newly-created job.
+  def initialize
+    yield self if block_given?
+  end
+
+  # Reloads this job from the server, useful when polling for updates.
+  #
+  #   job = credential.start_job
+  #   until job.complete?
+  #     print '.'
+  #     job.reload
+  #     sleep 1
+  #   end
+  #   puts
+  #   puts "Job finished with status=#{job.status}, result=#{job.result}"
+  #
+  # @return [Wesabe::Job] Returns self.
+  def reload
+    replace(
+      Wesabe::Job.from_xml(
+        Hpricot.XML(
+          get(:url => "/credentials/#{credential.id}/jobs/#{id}.xml"))))
+    return self
+  end
+
+  # Determines whether this job is still running.
+  #
+  # @return [Boolean] Whether the job is still running.
+  def pending?
+    status == 'pending'
+  end
+
+  # Determines whether this job is finished.
+  #
+  # @return [Boolean] Whether the job is finished running.
+  def complete?
+    !pending?
+  end
+
+  # Determines whether this job is successful.
+  #
+  # @return [Boolean]
+  #   Whether this job has completed and, if so, whether it was successful.
+  def successful?
+    status == 'successful'
+  end
+
+  # Determines whether this job failed.
+  #
+  # @return [Boolean]
+  #   Whether this job has completed and, if so, whether it failed.
+  def failed?
+    status == 'failed'
+  end
+
+  # Returns a +Wesabe::Job+ generated from Wesabe's API XML.
+  #
+  # @param [Hpricot::Element] xml
+  #   The <job> element from the API.
+  #
+  # @return [Wesabe::Job]
+  #   The newly-created job populated by +xml+.
+  def self.from_xml(xml)
+    new do |job|
+      job.id = xml.at('id').inner_text
+      job.status = xml.at('status').inner_text
+      job.result = xml.at('result').inner_text
+      job.created_at = Time.parse(xml.at('created-at').inner_text)
+    end
+  end
+
+  def inspect
+    inspect_these :id, :status, :result, :created_at
+  end
+
+  private
+
+  def replace(with)
+    with.instance_variables.each {|ivar| instance_variable_set(ivar, with.instance_variable_get(ivar))}
+  end
+end

data/lib/wesabe/request.rb

@@ -0,0 +1,186 @@
+class Wesabe::Request
+  attr_reader :url, :username, :password, :method, :proxy, :payload
+
+  DEFAULT_HEADERS = {
+    'User-Agent' => "Wesabe-RubyGem/#{Wesabe::VERSION} (Ruby #{RUBY_VERSION}; #{RUBY_PLATFORM})"
+  }
+
+  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
+    http = net_http_class.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 net_http_class
+    if proxy
+      proxy_uri = URI.parse(proxy)
+      Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
+    else
+      Net::HTTP
+    end
+  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, res
+    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, DEFAULT_HEADERS)
+    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
+
+  class Exception < RuntimeError; end
+  class ServerBrokeConnection < Exception; end
+  class Redirect < Exception
+    attr_reader :location
+
+    def initialize(location)
+      @location = location
+    end
+
+    def message
+      "You've been redirected to #{location}"
+    end
+
+    def inspect
+      "#<#{self.class.name} Location=#{location.inspect}>"
+    end
+  end
+  class Unauthorized < Exception; end
+  class ResourceNotFound < Exception; end
+  class RequestFailed < Exception
+    attr_reader :response
+
+    def initialize(response=nil)
+      @response = response
+    end
+
+    def message
+      begin
+        (Hpricot.XML(response.body) / :error / :message).inner_text
+      rescue
+        response.body
+      end
+    end
+
+    def to_s
+      message
+    end
+
+    def inspect
+      "#<#{self.class.name} Status=#{response.code} Message=#{message.inspect}>"
+    end
+  end
+end

data/lib/wesabe/target.rb

@@ -0,0 +1,35 @@
+class Wesabe::Target < Wesabe::BaseModel
+  # The tag name
+  attr_accessor :tag
+  # This target's monthly limit ($)
+  attr_accessor :monthly_limit
+  # This target's amount remaining ($)
+  attr_accessor :amount_remaining
+
+  # Initializes a +Wesabe::Target+ and yields itself.
+  #
+  # @yieldparam [Wesabe::Target] Target
+  #   The newly-created Target.
+  def initialize
+    yield self if block_given?
+  end
+
+  # Returns a +Wesabe::Target+ generated from Wesabe's API XML.
+  #
+  # @param [Hpricot::Element] xml
+  #   The <Target> element from the API.
+  #
+  # @return [Wesabe::Target]
+  #   The newly-created Target populated by +xml+.
+  def self.from_xml(xml)
+    new do |target|
+      target.tag = xml.at("tag").at("name").inner_text
+      target.monthly_limit = xml.at("monthly-limit").inner_text.to_f
+      target.amount_remaining = xml.at("amount-remaining").inner_text.to_f
+    end
+  end
+
+  def inspect
+    inspect_these :tag, :monthly_limit, :amount_remaining
+  end
+end

data/lib/wesabe/upload.rb

@@ -0,0 +1,96 @@
+# Encapsulates an upload and allows uploading files to wesabe.com.
+class Wesabe::Upload < Wesabe::BaseModel
+  # The accounts this upload is associated with.
+  attr_accessor :accounts
+  # The financial institution this upload is associated with.
+  attr_accessor :financial_institution
+  # Whether this upload succeeded or failed, or +nil+ if it hasn't started.
+  attr_accessor :status
+  # The raw statement to post.
+  attr_accessor :statement
+
+  # Initializes a +Wesabe::Upload+ and yields itself.
+  #
+  # @yieldparam [Wesabe::Upload] upload
+  #   The newly-created upload.
+  def initialize
+    yield self if block_given?
+  end
+
+  # Uploads the statement to Wesabe, raising on problems. It can raise
+  # anything that is raised by +Wesabe::Request#execute+ in addition to
+  # the list below.
+  #
+  #   begin
+  #     upload.upload!
+  #   rescue Wesabe::Upload::StatementError => e
+  #     $stderr.puts "The file you chose to upload couldn't be imported."
+  #     $stderr.puts "This is what Wesabe said: #{e.message}"
+  #   rescue Wesabe::Request::Exception
+  #     $stderr.puts "There was a problem communicating with Wesabe."
+  #   end
+  #
+  # @raise [Wesabe::Upload::StatementError]
+  #   When the statement cannot be processed, this is returned (error code 5).
+  #
+  # @see Wesabe::Request#execute
+  def upload!
+    process_response do
+      post(:url => '/rest/upload/statement', :payload => pack_statement)
+    end
+  end
+
+  # Determines whether this upload succeeded or not.
+  #
+  # @return [Boolean]
+  #   +true+ if +status+ is +"processed"+, +false+ otherwise.
+  def successful?
+    status == "processed"
+  end
+
+  # Determines whether this upload failed or not.
+  #
+  # @return [Boolean]
+  #   +false+ if +status+ is +"processed"+, +true+ otherwise.
+  def failed?
+    !successful?
+  end
+
+  private
+
+  # Generates XML to upload to wesabe.com to create this +Upload+.
+  #
+  # @return [String]
+  #   An XML document containing the relevant upload data.
+  def pack_statement
+    upload = self
+
+    Hpricot.build do
+      tag! :upload do
+        tag! :statement, :accttype => upload.accounts[0].type, :acctid => upload.accounts[0].number, :wesabe_id => upload.financial_institution.id do
+          text! upload.statement
+        end
+      end
+    end.inner_html
+  end
+
+  # Processes the response that is the result of +yield+ing.
+  #
+  # @see upload!
+  def process_response
+    self.status = nil
+    raw = yield
+    doc = Hpricot.XML(raw)
+    response = doc.at("response")
+    raise Exception, "There was an error processing the response: #{raw}" unless response
+    self.status = response["status"]
+
+    if !successful?
+      message = response.at("error>message")
+      raise StatementError, message && message.inner_text
+    end
+  end
+end
+
+class Wesabe::Upload::Exception < RuntimeError; end
+class Wesabe::Upload::StatementError < Wesabe::Upload::Exception; end

data/lib/wesabe/util.rb

@@ -0,0 +1,16 @@
+module Wesabe::Util
+  extend self
+
+  # Yields +what+ or, if +what+ is an array, each element of +what+. It's
+  # sort of like an argument-agnostic +map+.
+  #
+  # @yieldparam [Object] element
+  #   If +what+ is an +Array+, this is +what+. Otherwise it's elements of +what+.
+  #
+  # @return [Array<Object>,Object]
+  #   If +what+ is an array, it acts like +what.map+. Otherwise +yield(what)+.
+  def all_or_one(what, &block)
+    result = Array(what).each(&block)
+    return what.is_a?(Array) ? result : result.first
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: wesabe
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Brian Donovan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-19 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  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
+- bin/console
+- lib/cacert.pem
+- lib/wesabe/account.rb
+- lib/wesabe/base_model.rb
+- lib/wesabe/credential.rb
+- lib/wesabe/currency.rb
+- lib/wesabe/financial_institution.rb
+- lib/wesabe/job.rb
+- lib/wesabe/request.rb
+- lib/wesabe/target.rb
+- lib/wesabe/upload.rb
+- lib/wesabe/util.rb
+- lib/wesabe.rb
+has_rdoc: true
+homepage: https://www.wesabe.com/page/api
+licenses: []
+
+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.3.5
+signing_key: 
+specification_version: 3
+summary: Wraps communication with the Wesabe API
+test_files: []
+