xero_gateway 2.0.14 → 2.0.15

data/Rakefile

@@ -1,6 +1,6 @@
 require 'rake'
 require 'rake/testtask'
-require 'rake/rdoctask'
+require 'rdoc/task'
 
 desc 'Default: run unit tests.'
 task :default => :test

data/lib/xero_gateway/accounts_list.rb

@@ -1,10 +1,6 @@
 module XeroGateway
   class AccountsList
     
-    class Error < RuntimeError; end
-    class NoGatewayError < Error; end
-    class AccountsListNotLoadedError < Error; end
-    
     # Xero::Gateway associated with this invoice.
     attr_accessor :gateway
     

data/lib/xero_gateway/bank_transaction.rb

@@ -3,8 +3,6 @@ module XeroGateway
     include Dates
     include LineItemCalculations
 
-    class NoGatewayError < Error; end
-
     GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/ unless defined?(GUID_REGEX)
 
     TYPES = {
@@ -27,7 +25,7 @@ module XeroGateway
     attr_accessor :line_items_downloaded
 
     # accessible fields
-    attr_accessor :bank_transaction_id, :type, :date, :reference, :status, :contact, :line_items, :bank_account, :url
+    attr_accessor :bank_transaction_id, :type, :date, :reference, :status, :contact, :line_items, :bank_account, :url, :is_reconciled
 
     def initialize(params = {})
       @errors ||= []
@@ -128,11 +126,12 @@ module XeroGateway
         b.BankTransactionID bank_transaction_id if bank_transaction_id
         b.Type type
         # b.CurrencyCode self.currency_code if self.currency_code
-        contact.to_xml(b)
-        bank_account.to_xml(b, :name => 'BankAccount')
+        contact.to_xml(b) if contact
+        bank_account.to_xml(b, :name => 'BankAccount') if bank_account
         b.Date BankTransaction.format_date(date || Date.today)
         b.Status status if status
         b.Reference reference if reference
+        b.IsReconciled true if self.is_reconciled
         b.LineItems {
           self.line_items.each do |line_item|
             line_item.to_xml(b)
@@ -165,6 +164,7 @@ module XeroGateway
           # when "AmountPaid" then invoice.amount_paid = BigDecimal.new(element.text)
           # when "AmountCredited" then invoice.amount_credited = BigDecimal.new(element.text)
           # when "SentToContact" then invoice.sent_to_contact = (element.text.strip.downcase == "true")
+          when "IsReconciled" then bank_transaction.is_reconciled = (element.text.strip.downcase == "true")
           when "Url" then bank_transaction.url = element.text
         end
       end

data/lib/xero_gateway/contact.rb

@@ -1,10 +1,7 @@
 module XeroGateway
   class Contact
     include Dates
-    
-    class Error < RuntimeError; end
-    class NoGatewayError < Error; end
-    
+        
     GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/ unless defined?(GUID_REGEX)
     
     CONTACT_STATUS = {
@@ -126,14 +123,14 @@ module XeroGateway
     end
     
     # Creates this contact record (using gateway.create_contact) with the associated gateway.
-    # If no gateway set, raise a Xero::Contact::NoGatewayError exception.
+    # If no gateway set, raise a NoGatewayError exception.
     def create
       raise NoGatewayError unless gateway
       gateway.create_contact(self)
     end
     
     # Creates this contact record (using gateway.update_contact) with the associated gateway.
-    # If no gateway set, raise a Xero::Contact::NoGatewayError exception.
+    # If no gateway set, raise a NoGatewayError exception.
     def update
       raise NoGatewayError unless gateway
       gateway.update_contact(self)

data/lib/xero_gateway/credit_note.rb

@@ -4,8 +4,6 @@ module XeroGateway
     include Money
     include LineItemCalculations
     
-    class NoGatewayError < Error; end
-    
     CREDIT_NOTE_TYPE = {
       'ACCRECCREDIT' =>           'Accounts Receivable',
       'ACCPAYCREDIT' =>           'Accounts Payable'
@@ -163,7 +161,7 @@ module XeroGateway
     end
     
     # Creates this credit_note record (using gateway.create_credit_note) with the associated gateway.
-    # If no gateway set, raise a Xero::CreditNote::NoGatewayError exception.
+    # If no gateway set, raise a NoGatewayError exception.
     def create
       raise NoGatewayError unless gateway
       gateway.create_credit_note(self)

data/lib/xero_gateway/exceptions.rb

@@ -1,4 +1,8 @@
 module XeroGateway
+  class NoGatewayError < StandardError; end
+  class AccountsListNotLoadedError < StandardError; end
+  class InvalidLineItemError < StandardError; end
+
   class ApiException < StandardError
     
     def initialize(type, message, request_xml, response_xml)
@@ -43,4 +47,5 @@ module XeroGateway
   class InvoiceNotFoundError < StandardError; end
   class BankTransactionNotFoundError < StandardError; end
   class CreditNoteNotFoundError < StandardError; end
+  class ManualJournalNotFoundError < StandardError; end
 end

data/lib/xero_gateway/gateway.rb

@@ -418,6 +418,56 @@ module XeroGateway
       parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/BankTransaction'})
     end
 
+    # Creates a manual journal in Xero based on a manual journal object.
+    #
+    # Manual journal and line item totals are calculated automatically.
+    #
+    # Usage : # TODO
+
+    def create_manual_journal(manual_journal)
+      save_manual_journal(manual_journal)
+    end
+
+    #
+    # Updates an existing Xero manual journal
+    #
+    # Usage :
+    #
+    # manual_journal = xero_gateway.get_manual_journal(some_manual_journal_id)
+    #
+    # xero_gateway.update_manual_journal(manual_journal)
+    def update_manual_journal(manual_journal)
+      raise "manual_journal_id is required for updating manual journals" if manual_journal.manual_journal_id.nil?
+      save_manual_journal(manual_journal)
+    end
+
+    # Retrieves all manual journals from Xero
+    #
+    # Usage : get_manual_journal
+    #         getmanual_journal(:manual_journal_id => " 297c2dc5-cc47-4afd-8ec8-74990b8761e9")
+    #
+    # Note  : modified_since is in UTC format (i.e. Brisbane is UTC+10)
+    def get_manual_journals(options = {})
+      request_params = {}
+      request_params[:ManualJournalID]  = options[:manual_journal_id] if options[:manual_journal_id]
+      request_params[:ModifiedAfter]      = options[:modified_since] if options[:modified_since]
+
+      response_xml = http_get(@client, "#{@xero_url}/ManualJournals", request_params)
+
+      parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/ManualJournals'})
+    end
+
+    # Retrieves a single manual journal
+    #
+    # Usage : get_manual_journal("297c2dc5-cc47-4afd-8ec8-74990b8761e9") # By ID
+    #         get_manual_journal("OIT-12345") # By number
+    def get_manual_journal(manual_journal_id)
+      request_params = {}
+      url = "#{@xero_url}/ManualJournals/#{URI.escape(manual_journal_id)}"
+      response_xml = http_get(@client, url, request_params)
+      parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/ManualJournal'})
+    end
+
     #
     # Gets all accounts for a specific organization in Xero.
     #
@@ -555,6 +605,33 @@ module XeroGateway
       response
     end
 
+    # Create or update a manual journal record based on if it has an manual_journal_id.
+    def save_manual_journal(manual_journal)
+      request_xml = manual_journal.to_xml
+      response_xml = nil
+      create_or_save = nil
+
+      if manual_journal.manual_journal_id.nil?
+        # Create new manual journal record.
+        response_xml = http_put(@client, "#{@xero_url}/ManualJournals", request_xml, {})
+        create_or_save = :create
+      else
+        # Update existing manual journal record.
+        response_xml = http_post(@client, "#{@xero_url}/ManualJournals", request_xml, {})
+        create_or_save = :save
+      end
+
+      response = parse_response(response_xml, {:request_xml => request_xml}, {:request_signature => "#{create_or_save == :create ? 'PUT' : 'POST'}/ManualJournals"})
+
+      # Xero returns manual journals inside an <ManualJournals> tag, even though there's only ever
+      # one for this request
+      response.response_item = response.manual_journals.first
+
+      manual_journal.manual_journal_id = response.manual_journal.manual_journal_id if response.success? && response.manual_journal && response.manual_journal.manual_journal_id
+
+      response
+    end
+
     def parse_response(raw_response, request = {}, options = {})
 
       response = XeroGateway::Response.new
@@ -576,12 +653,18 @@ module XeroGateway
           when "Invoice" then response.response_item = Invoice.from_xml(element, self, {:line_items_downloaded => options[:request_signature] != "GET/Invoices"})
           when "BankTransaction"
             response.response_item = BankTransaction.from_xml(element, self, {:line_items_downloaded => options[:request_signature] != "GET/BankTransactions"})
+          when "ManualJournal"
+            response.response_item = ManualJournal.from_xml(element, self, {:journal_lines_downloaded => options[:request_signature] != "GET/ManualJournals"})
           when "Contacts" then element.children.each {|child| response.response_item << Contact.from_xml(child, self) }
           when "Invoices" then element.children.each {|child| response.response_item << Invoice.from_xml(child, self, {:line_items_downloaded => options[:request_signature] != "GET/Invoices"}) }
           when "BankTransactions"
             element.children.each do |child|
               response.response_item << BankTransaction.from_xml(child, self, {:line_items_downloaded => options[:request_signature] != "GET/BankTransactions"})
             end
+          when "ManualJournals"
+            element.children.each do |child|
+              response.response_item << ManualJournal.from_xml(child, self, {:journal_lines_downloaded => options[:request_signature] != "GET/ManualJournals"})
+            end
           when "CreditNotes" then element.children.each {|child| response.response_item << CreditNote.from_xml(child, self, {:line_items_downloaded => options[:request_signature] != "GET/CreditNotes"}) }
           when "Accounts" then element.children.each {|child| response.response_item << Account.from_xml(child) }
           when "TaxRates" then element.children.each {|child| response.response_item << TaxRate.from_xml(child) }

data/lib/xero_gateway/http.rb

@@ -125,6 +125,7 @@ module XeroGateway
       def handle_object_not_found!(response, request_url)
         case(request_url)
           when /Invoices/ then raise InvoiceNotFoundError.new("Invoice not found in Xero.")
+          when /BankTransactions/ then raise BankTransactionNotFoundError.new("Bank Transaction not found in Xero.")
           when /CreditNotes/ then raise CreditNoteNotFoundError.new("Credit Note not found in Xero.")
           else raise ObjectNotFound.new(request_url)
         end

data/lib/xero_gateway/invoice.rb

@@ -4,8 +4,6 @@ module XeroGateway
     include Money
     include LineItemCalculations
     
-    class NoGatewayError < Error; end
-    
     INVOICE_TYPE = {
       'ACCREC' =>           'Accounts Receivable',
       'ACCPAY' =>           'Accounts Payable'
@@ -165,14 +163,14 @@ module XeroGateway
     end
     
     # Creates this invoice record (using gateway.create_invoice) with the associated gateway.
-    # If no gateway set, raise a Xero::Invoice::NoGatewayError exception.
+    # If no gateway set, raise a NoGatewayError exception.
     def create
       raise NoGatewayError unless gateway
       gateway.create_invoice(self)
     end
     
     # Updates this invoice record (using gateway.update_invoice) with the associated gateway.
-    # If no gateway set, raise a Xero::Invoice::NoGatewayError exception.
+    # If no gateway set, raise a NoGatewayError exception.
     def update
       raise NoGatewayError unless gateway
       gateway.update_invoice(self)

data/lib/xero_gateway/journal_line.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__), 'account')
+
+module XeroGateway
+  class JournalLine
+    include Money
+    
+    TAX_TYPE = Account::TAX_TYPE unless defined?(TAX_TYPE)
+
+    # Any errors that occurred when the #valid? method called.
+    attr_reader :errors
+
+    # All accessible fields
+    attr_accessor :journal_line_id, :line_amount, :account_code, :description, :tax_type, :tracking
+        
+    def initialize(params = {})
+      @errors ||= []
+      @tracking ||= []
+      
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+    
+    # Validate the JournalLineItem record according to what will be valid by the gateway.
+    #
+    # Usage: 
+    #  journal_line_item.valid?     # Returns true/false
+    #  
+    #  Additionally sets journal_line_item.errors array to an array of field/error.
+    def valid?
+      @errors = []
+      
+      if !journal_line_id.nil? && journal_line_id !~ GUID_REGEX
+        @errors << ['journal_line_id', 'must be blank or a valid Xero GUID']
+      end
+      
+      unless line_amount
+        @errors << ['line_amount', "can't be blank"]
+      end
+
+      unless account_code
+        @errors << ['account_code', "can't be blank"]
+      end
+      
+      @errors.size == 0
+    end
+    
+    def has_tracking?
+      return false if tracking.nil?
+      
+      if tracking.is_a?(Array)
+        return tracking.any?
+      else
+        return tracking.is_a?(TrackingCategory)
+      end
+    end
+    
+    def to_xml(b = Builder::XmlMarkup.new)
+      b.JournalLine {
+        b.LineAmount line_amount # mandatory
+        b.AccountCode account_code # mandatory
+        b.Description description if description # optional
+        b.TaxType tax_type if tax_type # optional
+        if has_tracking?
+          b.Tracking { # optional
+            # Due to strange retardness in the Xero API, the XML structure for a tracking category within
+            # an invoice is different to a standalone tracking category.
+            # This means rather than going category.to_xml we need to call the special category.to_xml_for_invoice_messages
+            (tracking.is_a?(TrackingCategory) ? [tracking] : tracking).each do |category|
+              category.to_xml_for_invoice_messages(b)
+            end
+          }
+        end
+      }
+    end
+    
+    def self.from_xml(journal_line_element)
+      journal_line = JournalLine.new
+      journal_line_element.children.each do |element|
+        case(element.name)
+          when "LineAmount" then journal_line.line_amount = BigDecimal.new(element.text)
+          when "AccountCode" then journal_line.account_code = element.text
+          when "JournalLineID" then journal_line.journal_line_id = element.text
+          when "Description" then journal_line.description = element.text
+          when "TaxType" then journal_line.tax_type = element.text
+          when "Tracking" then
+            element.children.each do | tracking_element |
+              journal_line.tracking << TrackingCategory.from_xml(tracking_element)
+            end
+        end
+      end
+      journal_line
+    end    
+
+    def ==(other)
+      [:description, :line_amount, :account_code, :tax_type].each do |field|
+        return false if send(field) != other.send(field)
+      end
+      return true
+    end
+  end  
+end

data/lib/xero_gateway/line_item_calculations.rb

@@ -1,9 +1,5 @@
 module XeroGateway
   module LineItemCalculations
-
-    class Error < RuntimeError; end
-    class InvalidLineItemError < Error; end
-
     def add_line_item(params = {})
       line_item = nil
       case params

data/lib/xero_gateway/manual_journal.rb

@@ -0,0 +1,163 @@
+module XeroGateway
+  class ManualJournal
+  	include Dates
+
+    GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/ unless defined?(GUID_REGEX)
+
+    STATUSES = {
+      'DRAFT' 	=> 'Draft Manual Journal',
+      'POSTED' 	=> 'Posted Manual Journal',
+      'DELETED' => 'Deleted Draft Manual Journal',
+      'VOIDED'	=> 'Voided Posted Manual Journal'
+    } unless defined?(STATUSES)
+
+    # Xero::Gateway associated with this invoice.
+    attr_accessor :gateway
+
+    # Any errors that occurred when the #valid? method called.
+    attr_reader :errors
+
+    # Represents whether the journal lines have been downloaded when getting from GET /API.XRO/2.0/ManualJournals
+    attr_accessor :journal_lines_downloaded
+
+    # accessible fields
+    attr_accessor :manual_journal_id, :narration, :date, :status, :journal_lines, :url, :show_on_cash_basis_reports
+
+    def initialize(params = {})
+      @errors ||= []
+      @payments ||= []
+
+      # Check if the line items have been downloaded.
+      @journal_lines_downloaded = (params.delete(:journal_lines_downloaded) == true)
+
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+
+      @journal_lines ||= []
+    end
+
+    def ==(other)
+      ['narration', 'status', 'journal_lines', 'show_on_cash_basis_reports'].each do |field|
+        return false if send(field) != other.send(field)
+      end
+
+      ["date"].each do |field|
+        return false if send(field).to_s != other.send(field).to_s
+      end
+      return true
+    end
+
+    # Validate the ManualJournal record according to what will be valid by the gateway.
+    #
+    # Usage:
+    #  manual_journal.valid?     # Returns true/false
+    #
+    #  Additionally sets manual_journal.errors array to an array of field/error.
+    def valid?
+      @errors = []
+
+      if !manual_journal_id.nil? && manual_journal_id !~ GUID_REGEX
+        @errors << ['manual_journal_id', 'must be blank or a valid Xero GUID']
+      end
+
+      if narration.blank?
+      	@errors << ['narration', "can't be blank"]
+      end
+
+      unless date
+        @errors << ['date', "can't be blank"]
+      end
+
+      # Make sure all journal_items are valid.
+      unless journal_lines.all? { | journal_line | journal_line.valid? }
+        @errors << ['journal_lines', "at least one journal line invalid"]
+      end
+
+      # make sure there are at least 2 journal lines
+      unless journal_lines.length > 1
+      	@errors << ['journal_lines', "journal must contain at least two individual journal lines"]
+      end
+
+      if journal_lines.length > 100
+      	@errors << ['journal_lines', "journal must contain less than one hundred journal lines"]
+      end
+
+      unless journal_lines.sum(&:line_amount).to_f == 0.0
+      	@errors << ['journal_lines', "the total debits must be equal to total credits"]
+      end
+
+      @errors.size == 0
+    end
+
+
+    def journal_lines_downloaded?
+      @journal_lines_downloaded
+    end
+
+    # If line items are not downloaded, then attempt a download now (if this record was found to begin with).
+    def journal_lines
+      if journal_lines_downloaded?
+        @journal_lines
+
+      elsif manual_journal_id =~ GUID_REGEX && @gateway
+        # There is a manual_journal_id so we can assume this record was loaded from Xero.
+        # Let's attempt to download the journal_line records (if there is a gateway)
+
+        response = @gateway.get_manual_journal(manual_journal_id)
+        raise ManualJournalNotFoundError, "Manual Journal with ID #{manual_journal_id} not found in Xero." unless response.success? && response.manual_journal.is_a?(XeroGateway::ManualJournal)
+
+        @journal_lines = response.manual_journal.journal_lines
+        @journal_lines_downloaded = true
+
+        @journal_lines
+
+      # Otherwise, this is a new manual journal, so return the journal_lines reference.
+      else
+        @journal_lines
+      end
+    end
+
+    def to_xml(b = Builder::XmlMarkup.new)
+      b.ManualJournal {
+        b.ManualJournalID manual_journal_id if manual_journal_id
+        b.Narration narration        
+        b.JournalLines {
+          self.journal_lines.each do |journal_line|
+            journal_line.to_xml(b)
+          end
+        }
+        b.Date ManualJournal.format_date(date || Date.today)
+        b.Status status if status
+        b.Url url if url
+      }
+    end
+
+    def self.from_xml(manual_journal_element, gateway = nil, options = {})
+      manual_journal = ManualJournal.new(options.merge({:gateway => gateway}))
+      manual_journal_element.children.each do |element|
+        case(element.name)
+          when "ManualJournalID" then manual_journal.manual_journal_id = element.text
+          when "Date" then manual_journal.date = parse_date(element.text)
+          when "Status" then manual_journal.status = element.text
+          when "Narration" then manual_journal.narration = element.text
+          when "JournalLines" then element.children.each {|journal_line| manual_journal.journal_lines_downloaded = true; manual_journal.journal_lines << JournalLine.from_xml(journal_line) }
+          when "Url" then manual_journal.url = element.text
+        end
+      end
+      manual_journal
+    end # from_xml
+
+    def add_journal_line(params = {})
+      journal_line = nil
+      case params
+        when Hash 			 then  journal_line = JournalLine.new(params)
+        when JournalLine then  journal_line = params
+        else             raise InvalidLineItemError
+      end
+      @journal_lines << journal_line
+      journal_line
+    end
+
+  end
+end

data/lib/xero_gateway/response.rb

@@ -9,11 +9,13 @@ module XeroGateway
     alias_method :invoice,              :response_item
     alias_method :credit_note,          :response_item
     alias_method :bank_transaction,     :response_item
+    alias_method :manual_journal,       :response_item
     alias_method :contact,              :response_item
     alias_method :organisation,         :response_item
     alias_method :invoices,             :array_wrapped_response_item
     alias_method :credit_notes,         :array_wrapped_response_item
     alias_method :bank_transactions,    :array_wrapped_response_item
+    alias_method :manual_journals,      :array_wrapped_response_item
     alias_method :contacts,             :array_wrapped_response_item
     alias_method :accounts,             :array_wrapped_response_item
     alias_method :tracking_categories,  :array_wrapped_response_item

data/lib/xero_gateway.rb

@@ -26,6 +26,8 @@ require File.join(File.dirname(__FILE__), 'xero_gateway', 'payment')
 require File.join(File.dirname(__FILE__), 'xero_gateway', 'invoice')
 require File.join(File.dirname(__FILE__), 'xero_gateway', 'bank_transaction')
 require File.join(File.dirname(__FILE__), 'xero_gateway', 'credit_note')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'journal_line')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'manual_journal')
 require File.join(File.dirname(__FILE__), 'xero_gateway', 'address')
 require File.join(File.dirname(__FILE__), 'xero_gateway', 'phone')
 require File.join(File.dirname(__FILE__), 'xero_gateway', 'organisation')

data/test/integration/accounts_list_test.rb

@@ -21,10 +21,10 @@ class AccountsListTest < Test::Unit::TestCase
   def test_raise_error_on_not_loaded
     accounts_list = @gateway.get_accounts_list(false)
     assert_equal(false, accounts_list.loaded?)
-    assert_raise(XeroGateway::AccountsList::AccountsListNotLoadedError) { accounts_list[200] }
-    assert_raise(XeroGateway::AccountsList::AccountsListNotLoadedError) { accounts_list.find_by_code(200) }
-    assert_raise(XeroGateway::AccountsList::AccountsListNotLoadedError) { accounts_list.find_all_by_type('EXPENSE') }
-    assert_raise(XeroGateway::AccountsList::AccountsListNotLoadedError) { accounts_list.find_all_by_tax_type('OUTPUT') }
+    assert_raise(XeroGateway::AccountsListNotLoadedError) { accounts_list[200] }
+    assert_raise(XeroGateway::AccountsListNotLoadedError) { accounts_list.find_by_code(200) }
+    assert_raise(XeroGateway::AccountsListNotLoadedError) { accounts_list.find_all_by_type('EXPENSE') }
+    assert_raise(XeroGateway::AccountsListNotLoadedError) { accounts_list.find_all_by_tax_type('OUTPUT') }
   end
   
   # Test simple lookup by account code (from cache).

data/test/integration/create_manual_journal_test.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CreateManualJournalTest < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
+
+    if STUB_XERO_CALLS
+      @gateway.xero_url = "DUMMY_URL"
+
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /ManualJournals$/ }.returns(get_file_as_string("create_manual_journal.xml"))
+      @gateway.stubs(:http_post).with {|client, url, body, params| url =~ /ManualJournals$/ }.returns(get_file_as_string("manual_journal.xml"))
+    end
+  end
+
+  def test_create_manual_journal
+    example_manual_journal = create_test_manual_journal.dup
+
+    result = @gateway.create_manual_journal(example_manual_journal)
+    assert_kind_of XeroGateway::Response, result
+    assert result.success?
+    assert !result.request_xml.nil?
+    assert !result.response_xml.nil?
+    assert !result.manual_journal.manual_journal_id.nil?
+    assert example_manual_journal.manual_journal_id =~ GUID_REGEX
+  end
+
+  def test_create_manual_journal_valid
+    example_manual_journal = create_test_manual_journal.dup
+    assert_equal true, example_manual_journal.valid?,
+      "manual_journal is invalid - errors:\n\t#{example_manual_journal.errors.map { | error | "#{error[0]} #{error[1]}"}.join("\n\t")}"
+  end
+
+end

data/test/integration/get_bank_transaction_test.rb

@@ -25,6 +25,7 @@ class GetBankTransactionTest < Test::Unit::TestCase
     assert !result.response_xml.nil?
     assert_equal result.bank_transaction.bank_transaction_id, bank_transaction.bank_transaction_id
     assert_equal result.bank_transaction.reference, bank_transaction.reference
+    assert result.bank_transaction.is_reconciled
 
     result = @gateway.get_bank_transaction(bank_transaction.bank_transaction_id)
     assert result.success?

data/test/integration/get_manual_journal_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class GetManualJournalTest < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
+
+    if STUB_XERO_CALLS
+      @gateway.xero_url = "DUMMY_URL"
+
+      @gateway.stubs(:http_get).with {|client, url, params| url =~ /ManualJournals(\/[0-9a-z\-]+)?$/i }.returns(get_file_as_string("manual_journal.xml"))
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /ManualJournals$/ }.returns(get_file_as_string("create_manual_journal.xml"))
+    end
+  end
+
+  def test_get_manual_journal
+    # Make sure there is a manual journal in Xero to retrieve
+    response = @gateway.create_manual_journal(create_test_manual_journal)
+    manual_journal = response.manual_journal
+
+    result = @gateway.get_manual_journal(manual_journal.manual_journal_id)
+    assert result.success?
+    assert !result.request_params.nil?
+    assert !result.response_xml.nil?
+    assert_equal result.manual_journal.manual_journal_id, manual_journal.manual_journal_id
+    assert_equal result.manual_journal.narration, manual_journal.narration
+
+    result = @gateway.get_manual_journal(manual_journal.manual_journal_id)
+    assert result.success?
+    assert !result.request_params.nil?
+    assert !result.response_xml.nil?
+    assert_equal result.manual_journal.manual_journal_id, manual_journal.manual_journal_id
+  end
+
+  def test_journal_lines_downloaded_set_correctly
+    # Make sure there is a manual journal in Xero to retrieve.
+    example_manual_journal = @gateway.create_manual_journal(create_test_manual_journal).manual_journal
+  
+    # No line items.
+    response = @gateway.get_manual_journal(example_manual_journal.manual_journal_id)
+    assert response.success?
+  
+    manual_journal = response.manual_journal
+    assert_kind_of(XeroGateway::JournalLine, manual_journal.journal_lines.first)
+    assert_kind_of(XeroGateway::ManualJournal, manual_journal)
+    assert manual_journal.journal_lines_downloaded?
+  end
+
+end

data/test/integration/get_manual_journals_test.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class GetManualJournalsTest < Test::Unit::TestCase
+  include TestHelper
+
+  INVALID_MANUAL_JOURNAL_ID = "99999999-9999-9999-9999-999999999999" unless defined?(INVALID_MANUAL_JOURNAL_ID)
+
+  def setup
+    @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
+
+    if STUB_XERO_CALLS
+      @gateway.xero_url = "DUMMY_URL"
+
+      @gateway.stubs(:http_get).with {|client, url, params| url =~ /ManualJournals(\/[0-9a-z\-]+)?$/i }.returns(get_file_as_string("manual_journals.xml"))
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /ManualJournals$/ }.returns(get_file_as_string("create_manual_journal.xml"))
+
+      # Get a manual journal with an invalid ID.
+      @gateway.stubs(:http_get).with {|client, url, params| url =~ Regexp.new("ManualJournals/#{INVALID_MANUAL_JOURNAL_ID}") }.returns(get_file_as_string("manual_journal_not_found_error.xml"))
+    end
+  end
+
+  def test_get_manual_journals
+    # Make sure there is a manual journal in Xero to retrieve
+    manual_journal = @gateway.create_manual_journal(create_test_manual_journal).manual_journal
+
+    result = @gateway.get_manual_journals
+    assert result.success?
+    assert !result.request_params.nil?
+    assert !result.response_xml.nil?
+    assert result.manual_journals.collect {|i| i.narration}.include?(manual_journal.narration)
+    assert result.manual_journals.collect {|i| i.manual_journal_id}.include?(manual_journal.manual_journal_id)
+  end
+
+  def test_get_manual_journals_with_modified_since_date
+    # Create a test manual journal
+    @gateway.create_manual_journal(create_test_manual_journal)
+
+    # Check that it is returned
+    result = @gateway.get_manual_journals(:modified_since => Date.today - 1)
+    assert result.success?
+    assert !result.request_params.nil?
+    assert !result.response_xml.nil?
+    assert result.request_params.keys.include?(:ModifiedAfter) # make sure the flag was sent
+  end
+
+  def test_journal_lines_downloaded_set_correctly
+    # No line items.
+    response = @gateway.get_manual_journals
+    assert_equal(true, response.success?)
+
+    manual_journal = response.manual_journals.first
+    assert_kind_of(XeroGateway::ManualJournal, manual_journal)
+    assert !manual_journal.journal_lines_downloaded?
+  end
+
+  # Make sure that a reference to gateway is passed when the get_manual_journals response is parsed.
+  def test_get_manual_journals_gateway_reference
+    result = @gateway.get_manual_journals
+    assert(result.success?)
+    assert_not_equal(0, result.manual_journals.size)
+
+    result.manual_journals.each do |manual_journal|
+      assert(manual_journal.gateway === @gateway)
+    end
+  end
+
+  # Test to make sure that we correctly error when a manual journal doesn't have an ID.
+  # This should usually never be ecountered.
+  def test_to_ensure_that_a_manual_journal_with_invalid_id_errors
+    # Make sure there is a manual journal to retrieve, even though we will mangle it later.
+    manual_journal = @gateway.create_manual_journal(create_test_manual_journal).manual_journal
+
+    result = @gateway.get_manual_journals
+    assert_equal(true, result.success?)
+
+    manual_journal = result.manual_journals.first
+    assert !manual_journal.journal_lines_downloaded?
+
+    # Mangle invoice_id to invalid one.
+    manual_journal.manual_journal_id = INVALID_MANUAL_JOURNAL_ID
+
+    # Make sure we fail here.
+    journal_lines = nil
+    assert_raise(XeroGateway::ManualJournalNotFoundError) { journal_lines = manual_journal.journal_lines }
+    assert_nil(journal_lines)
+  end
+
+end

data/test/integration/update_manual_journal_test.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class UpdateManualJournalTest < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
+
+    if STUB_XERO_CALLS
+      @gateway.xero_url = "DUMMY_URL"
+
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /ManualJournals$/ }.returns(get_file_as_string("create_manual_journal.xml"))
+      @gateway.stubs(:http_post).with {|client, url, body, params| url =~ /ManualJournals$/ }.returns(get_file_as_string("manual_journal.xml"))
+    end
+  end
+
+  def test_update_manual_journal
+    manual_journal = @gateway.create_manual_journal(create_test_manual_journal).manual_journal
+
+    today = Date.today
+    manual_journal.date = today
+
+    result = @gateway.update_manual_journal(manual_journal)
+
+    assert result.success?
+    assert !result.request_xml.nil?
+    assert !result.response_xml.nil?
+    assert_equal manual_journal.manual_journal_id, result.manual_journal.manual_journal_id
+    assert_equal today, result.manual_journal.date if !STUB_XERO_CALLS
+  end
+end

data/test/test_helper.rb

@@ -176,4 +176,42 @@ module TestHelper
     contact
   end
 
+  def create_test_manual_journal(params={}, journal_line_params={})
+    params = {      
+      :date       => Date.today,
+      :narration  => 'test narration',
+      :status     => 'POSTED'
+    }.merge(params)
+    manual_journal = XeroGateway::ManualJournal.new(params)
+    add_test_journal_lines(manual_journal, journal_line_params)
+  end
+
+  def add_test_journal_lines(manual_journal, journal_line_params)
+    if journal_line_params
+      journal_line_params = [journal_line_params].flatten # always use an array, even if only a single hash passed in
+
+      # At least one line item, make first have some defaults.
+      journal_line_params << {} if journal_line_params.size == 0
+      journal_line_params[0] = {
+        :description  => "FIRST LINE",
+        :account_code => "200",
+        :line_amount  => BigDecimal.new("100"),
+        :tracking     => XeroGateway::TrackingCategory.new(:name => "blah", :options => "hello")
+      }.merge(journal_line_params[0])
+      params_line_1 = journal_line_params[1] || {}
+      journal_line_params[1] = {
+        :description  => "SECOND LINE",
+        :account_code => "200",
+        :line_amount  => BigDecimal.new("-100"),        
+        :tracking     => XeroGateway::TrackingCategory.new(:name => "blah2", :options => "hello2")
+      }.merge(params_line_1)      
+
+      # Create line_items from line_item_params
+      journal_line_params.each do |journal_line|
+        manual_journal.add_journal_line(journal_line)
+      end
+    end
+    manual_journal
+  end
+
 end

data/test/unit/bank_transaction_test.rb

@@ -65,7 +65,7 @@ class BankTransactionTest < Test::Unit::TestCase
 
       # Test that pushing anything else into add_line_item fails.
       ["invalid", 100, nil, []].each do | invalid_object |
-        assert_raise(XeroGateway::Invoice::InvalidLineItemError) { @bank_transaction.add_line_item(invalid_object) }
+        assert_raise(XeroGateway::InvalidLineItemError) { @bank_transaction.add_line_item(invalid_object) }
         assert_equal(2, @bank_transaction.line_items.size)
       end
     end
@@ -100,6 +100,18 @@ class BankTransactionTest < Test::Unit::TestCase
       parsed_bank_transaction = XeroGateway::BankTransaction.from_xml(bank_transaction_element)
       assert_equal 'http://example.com?with=params&and=more', parsed_bank_transaction.url
     end
+
+    should "ignore missing contact" do
+      bank_transaction = create_test_bank_transaction
+      bank_transaction.contact = nil
+      bank_transaction.to_xml
+    end
+
+    should "ignore missing bank account" do
+      bank_transaction = create_test_bank_transaction
+      bank_transaction.bank_account = nil
+      bank_transaction.to_xml
+    end
   end
 
 private

data/test/unit/credit_note_test.rb

@@ -215,7 +215,7 @@ class CreditNoteTest < Test::Unit::TestCase
 
     # Test that pushing anything else into add_line_item fails.
     ["invalid", 100, nil, []].each do | invalid_object |
-      assert_raise(XeroGateway::CreditNote::InvalidLineItemError) { credit_note.add_line_item(invalid_object) }
+      assert_raise(XeroGateway::InvalidLineItemError) { credit_note.add_line_item(invalid_object) }
       assert_equal(2, credit_note.line_items.size)
     end
   end

data/test/unit/gateway_test.rb

@@ -7,7 +7,7 @@ class GatewayTest < Test::Unit::TestCase
     @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
   end
   
-  context "with oauth error handling" do
+  context "with error handling" do
     
     should "handle token expired" do
       XeroGateway::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("token_expired"), :code => "401"))
@@ -56,7 +56,31 @@ class GatewayTest < Test::Unit::TestCase
         @gateway.create_invoice(XeroGateway::Invoice.new)
       end
     end
-    
+
+    should "handle invoices not found" do
+      XeroGateway::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("api_exception.xml"), :code => "404"))
+
+      assert_raises XeroGateway::InvoiceNotFoundError do
+        @gateway.get_invoice('unknown-invoice-id')
+      end
+    end
+
+    should "handle bank transactions not found" do
+      XeroGateway::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("api_exception.xml"), :code => "404"))
+
+      assert_raises XeroGateway::BankTransactionNotFoundError do
+        @gateway.get_bank_transaction('unknown-bank-transaction-id')
+      end
+    end
+
+    should "handle credit notes not found" do
+      XeroGateway::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("api_exception.xml"), :code => "404"))
+
+      assert_raises XeroGateway::CreditNoteNotFoundError do
+        @gateway.get_credit_note('unknown-credit-note-id')
+      end
+    end
+
     should "handle random root elements" do
       XeroGateway::OAuth.any_instance.stubs(:put).returns(stub(:plain_body => "<RandomRootElement></RandomRootElement>", :code => "200"))
 

data/test/unit/invoice_test.rb

@@ -229,7 +229,7 @@ class InvoiceTest < Test::Unit::TestCase
 
     # Test that pushing anything else into add_line_item fails.
     ["invalid", 100, nil, []].each do | invalid_object |
-      assert_raise(XeroGateway::Invoice::InvalidLineItemError) { invoice.add_line_item(invalid_object) }
+      assert_raise(XeroGateway::InvalidLineItemError) { invoice.add_line_item(invalid_object) }
       assert_equal(2, invoice.line_items.size)
     end
   end

data/test/unit/manual_journal_test.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class ManualJournalTest < Test::Unit::TestCase
+  include TestHelper
+
+  context "creating test manual journals" do
+    should "work" do
+      manual_journal = create_test_manual_journal
+
+      # test transaction defaults
+      assert_equal 'POSTED', manual_journal.status
+      assert_kind_of Date, manual_journal.date
+      assert_equal 'test narration', manual_journal.narration      
+
+      # Test the journal_line defaults.
+      journal_line = manual_journal.journal_lines.first
+      assert_equal('FIRST LINE', journal_line.description)
+      assert_equal('200', journal_line.account_code)
+      assert_equal(BigDecimal.new('100'), journal_line.line_amount)
+    end
+
+    should "allow overriding transaction defaults" do
+      assert_equal 'DRAFT', create_test_manual_journal(:status => 'DRAFT').status
+    end
+  end
+
+  context "adding journal lines" do
+    setup do
+      @manual_journal = create_test_manual_journal
+    end
+
+    should "work" do
+      assert_equal 2, @manual_journal.journal_lines.size
+      assert @manual_journal.valid?
+
+      journal_line_params = {:description => "Test Item 1", :line_amount => 100, :account_code => '200'}
+
+      # Test adding line item by hash
+      journal_line = @manual_journal.add_journal_line(journal_line_params)
+      assert_kind_of(XeroGateway::JournalLine, journal_line)
+      assert_equal(journal_line_params[:description], journal_line.description)
+      assert_equal(journal_line_params[:line_amount], journal_line.line_amount)
+      assert_equal(3, @manual_journal.journal_lines.size)
+
+      # Test adding line item by XeroGateway::JournalLine
+      journal_line = @manual_journal.add_journal_line(journal_line_params)
+      assert_kind_of(XeroGateway::JournalLine, journal_line)
+      assert_equal(journal_line_params[:description], journal_line.description)
+      assert_equal(journal_line_params[:line_amount], journal_line.line_amount)
+      assert_equal(4, @manual_journal.journal_lines.size)
+
+      # Test that having only 1 journal line fails.      
+      @manual_journal.journal_lines = [] 
+      @manual_journal.add_journal_line(journal_line_params)
+      assert !@manual_journal.valid?
+    end
+  end
+
+
+  context "building and parsing XML" do
+    should "work vice versa" do
+      manual_journal = create_test_manual_journal
+      manual_journal_as_xml = manual_journal.to_xml
+      manual_journal_element = REXML::XPath.first(REXML::Document.new(manual_journal_as_xml), "/ManualJournal")
+
+      # checking for mandatory fields      
+      assert_xml_field manual_journal_element, 'Date'
+      assert_xml_field manual_journal_element, 'Narration', :value => 'test narration'
+      assert_xml_field manual_journal_element, 'Status', :value => 'POSTED'            
+
+      parsed_manual_journal = XeroGateway::ManualJournal.from_xml(manual_journal_element)
+      assert_equal(manual_journal, parsed_manual_journal)
+    end
+
+    should "work for optional params" do
+      manual_journal = create_test_manual_journal(:url => 'http://example.com?with=params&and=more')
+      manual_journal_element = REXML::XPath.first(REXML::Document.new(manual_journal.to_xml), "/ManualJournal")
+
+      assert_xml_field manual_journal_element, 'Url', :value => 'http://example.com\?with=params&amp;and=more'
+
+      parsed_manual_journal = XeroGateway::ManualJournal.from_xml(manual_journal_element)
+      assert_equal 'http://example.com?with=params&and=more', parsed_manual_journal.url
+    end
+  end
+
+private
+
+  def assert_xml_field(xml, field_name, options={})
+    assert_match /#{field_name}/, xml.to_s, "Didn't find the field #{field_name} in the XML document!"
+    assert_match /#{field_name}.*#{options[:value]}.*#{field_name}/, xml.to_s, "The field #{field_name} was expected to be '#{options[:value]}'!" if options[:value]    
+  end
+
+end

data/xero_gateway.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "xero_gateway"
-  s.version  = "2.0.14"
-  s.date     = "2012-05-07"
+  s.version  = "2.0.15"
+  s.date     = "2012-06-15"
   s.summary  = "Enables ruby based applications to communicate with the Xero API"
   s.email    = "tim@connorsoftware.com"
   s.homepage = "http://github.com/tlconnor/xero_gateway"

metadata

@@ -1,56 +1,79 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: xero_gateway
-version: !ruby/object:Gem::Version
-  version: 2.0.14
+version: !ruby/object:Gem::Version 
+  hash: 17
   prerelease: 
+  segments: 
+  - 2
+  - 0
+  - 15
+  version: 2.0.15
 platform: ruby
-authors:
+authors: 
 - Tim Connor
 - Nik Wakelin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-07 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-06-15 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: builder
-  requirement: &70356902601560 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 1
+        - 2
         version: 2.1.2
   type: :runtime
-  prerelease: false
-  version_requirements: *70356902601560
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: oauth
-  requirement: &70356902601080 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 3
+        - 6
         version: 0.3.6
   type: :runtime
-  prerelease: false
-  version_requirements: *70356902601080
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: activesupport
-  requirement: &70356902600700 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
-  prerelease: false
-  version_requirements: *70356902600700
+  version_requirements: *id003
 description: Enables ruby based applications to communicate with the Xero API
 email: tim@connorsoftware.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - Gemfile
 - LICENSE
 - Rakefile
@@ -74,8 +97,10 @@ files:
 - lib/xero_gateway/http.rb
 - lib/xero_gateway/http_encoding_helper.rb
 - lib/xero_gateway/invoice.rb
+- lib/xero_gateway/journal_line.rb
 - lib/xero_gateway/line_item.rb
 - lib/xero_gateway/line_item_calculations.rb
+- lib/xero_gateway/manual_journal.rb
 - lib/xero_gateway/money.rb
 - lib/xero_gateway/oauth.rb
 - lib/xero_gateway/organisation.rb
@@ -92,6 +117,7 @@ files:
 - test/integration/create_contact_test.rb
 - test/integration/create_credit_note_test.rb
 - test/integration/create_invoice_test.rb
+- test/integration/create_manual_journal_test.rb
 - test/integration/get_accounts_test.rb
 - test/integration/get_bank_transaction_test.rb
 - test/integration/get_bank_transactions_test.rb
@@ -102,12 +128,15 @@ files:
 - test/integration/get_currencies_test.rb
 - test/integration/get_invoice_test.rb
 - test/integration/get_invoices_test.rb
+- test/integration/get_manual_journal_test.rb
+- test/integration/get_manual_journals_test.rb
 - test/integration/get_organisation_test.rb
 - test/integration/get_tax_rates_test.rb
 - test/integration/get_tracking_categories_test.rb
 - test/integration/update_bank_transaction_test.rb
 - test/integration/update_contact_test.rb
 - test/integration/update_invoice_test.rb
+- test/integration/update_manual_journal_test.rb
 - test/test_helper.rb
 - test/unit/account_test.rb
 - test/unit/bank_transaction_test.rb
@@ -116,33 +145,45 @@ files:
 - test/unit/currency_test.rb
 - test/unit/gateway_test.rb
 - test/unit/invoice_test.rb
+- test/unit/manual_journal_test.rb
 - test/unit/oauth_test.rb
 - test/unit/organisation_test.rb
 - test/unit/tax_rate_test.rb
 - test/unit/tracking_category_test.rb
 - lib/xero_gateway/ca-certificates.crt
+has_rdoc: true
 homepage: http://github.com/tlconnor/xero_gateway
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Enables ruby based applications to communicate with the Xero API
 test_files: []
+