wesabe-wesabe 0.0.1 → 0.0.2

data/README.markdown

@@ -1,4 +1,9 @@
 wesabe
 ======
 
-Access the Wesabe API. See the examples directory for usage examples.
+Access the Wesabe API. See the examples directory for usage examples.
+
+Installation
+------------
+
+    $ sudo gem install -r --source http://gems.github.com/ wesabe-wesabe

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

@@ -1,29 +1,38 @@
 $:.unshift(File.dirname(__FILE__))
 
-require 'net/https'
+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
-  
-  # Initializes access to the Wesabe API with a certain user. All requests 
+
+  VERSION = "0.0.1"
+
+  # 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,
@@ -47,24 +56,24 @@ class Wesabe
   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=[],
@@ -75,48 +84,81 @@ class Wesabe
   #       @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(
-        Request.execute(
-          :url => '/accounts.xml', 
-          :username => username, 
-          :password => password)))
+    process_accounts( Hpricot::XML( get(:url => '/accounts.xml') ) )
   end
-  
+
   def process_accounts(xml)
-    (xml / :accounts / :account).map do |element|
+    associate((xml / :accounts / :account).map do |element|
       Account.from_xml(element)
-    end
+    end)
   end
-  
+
   def load_credentials
-    process_credentials(
-      Hpricot::XML(
-        Request.execute(
-          :url => '/credentials.xml', 
-          :username => username, 
-          :password => password)))
+    process_credentials( Hpricot::XML( get(:url => '/credentials.xml') ) )
   end
-  
+
   def process_credentials(xml)
-    (xml / :credentials / :credential).map do |element|
+    associate((xml / :credentials / :credential).map do |element|
       Credential.from_xml(element)
-    end
+    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/financial_institution'
+require 'wesabe/job'
+require 'wesabe/target'

data/lib/wesabe/account.rb

@@ -1,34 +1,53 @@
-class Wesabe::Account
+# 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"))
@@ -36,4 +55,8 @@ class Wesabe::Account
       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

@@ -1,24 +1,32 @@
-class Wesabe::Credential
+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)
@@ -31,4 +39,14 @@ class Wesabe::Credential
       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

@@ -1,22 +1,22 @@
-class Wesabe::Currency
+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)
@@ -27,4 +27,8 @@ class Wesabe::Currency
       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

@@ -1,4 +1,4 @@
-class Wesabe::FinancialInstitution
+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").
@@ -7,20 +7,20 @@ class Wesabe::FinancialInstitution
   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)
@@ -31,4 +31,8 @@ class Wesabe::FinancialInstitution
       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

@@ -1,30 +1,27 @@
 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'" 
+    @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)
+    http = net_http_class.new(uri.host, uri.port)
     if uri.scheme == 'https'
       http.use_ssl = true
       http.verify_mode = OpenSSL::SSL::VERIFY_PEER
@@ -32,91 +29,100 @@ class Wesabe::Request
     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, url
+      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)
+    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")
@@ -124,21 +130,57 @@ class Wesabe::Request
     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
+  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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wesabe-wesabe
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Brian Donovan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-04 00:00:00 -07:00
+date: 2009-02-03 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,13 +34,19 @@ files:
 - LICENSE
 - README.markdown
 - Rakefile
+- bin/console
 - lib/cacert.pem
 - lib/wesabe
 - 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