xero-min 0.0.9

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+.rvmrc
+Gemfile.lock
+pkg/*
+keys/
+data/

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', version: 2 do
+  watch(%r{^spec/.+_spec\.rb})
+  watch(%r{^lib/(.+)\.rb})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/README.md

@@ -0,0 +1,88 @@
+tiny lib for xero
+
+existing ruby xero libraires are crowded with models : Payroll, Contact, Invoice that map each xml structure available through api
+
+But what if I dont care with Payroll or I have already one ... Will I have to build an XXX::Invoice with mine ?
+
+Here is the minimal workflow for a POST request to xero :
+
+* send a http request, with xml in params (in body for PUT, ohnoes oauth)
+* sign request with oauth
+* parse response
+
+What this library does is the minimal wire, that is a functional api to GET|POST|PUT any xero call, with the following workflow
+
+* use your model to build proper xml
+* call xero-min
+* parse response to get data your app need
+
+Library was built and tested for a private app
+
+Abstract
+========
+Uses
+
+* typhoeus, to configure uri, headers, body, params
+* nokogiri to parse response
+
+Get some data
+=============
+You will get a Nokogiri node.
+
+Then you can scrap it and extract what you require, no more, no less
+
+extract [id, name] for each contact
+-----------------------------------
+    doc = client.get! :contacts
+    doc.xpath('//Contact').map{|c| ['ContactID', 'Name'].map{|e| c.xpath("./#{e}").text}}
+
+Post! some data
+===============
+lib is raw : you have to post well xml, as it is what xero understand
+
+    client.post! :contacts, body: xml
+
+    client.post! 'https://api.xero.com/api.xro/2.0/contacts', body: xml
+
+What xml to post! or put! ?
+---------------------------
+XeroMin::Erb implements basic xml building
+
+    bill = {id: '4d73c0f91c94a2c47500000a', name: 'Billy', first_name: 'Bill', last_name: 'Kid', email: 'bill@kid.com'}
+    xml=erb.render contact: bill
+
+and xml should be
+
+    <Contact>
+      <ContactNumber>4d73c0f91c94a2c47500000a</ContactNumber>
+      <Name>Billy</Name>
+      <FirstName>Bill</FirstName>
+      <LastName>Kid</LastName>
+      <EmailAddress>bill@kid.com</EmailAddress>
+    </Contact>
+
+see XeroMin::Erb source code for precisions, templates for example, documentation
+
+Use anything else you feel more comfortable with
+
+Get!
+====
+    doc = client.get! :contacts
+
+    doc = 'https://api.xero.com/api.xro/2.0/invoices'
+
+    doc = client.get! "#{client.url_for(:contacts)}/#{bill.id}"
+
+
+What is the return value from post! or get! ?
+=============================================
+It is a Nokogiri node if post is success, extract what you need
+
+    invoice.ref = node.xpath('/Response/Invoices/Invoice/InvoiceNumber').first.content
+
+Else, it raise a XeroMin::Problem with a message
+
+Caveats
+=======
+use PUT to post data ... or use POST + params: {xml: xml} rather than body: xml with following patch : https://github.com/oauth/oauth-ruby/pull/24
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/xero-min.rb

@@ -0,0 +1,2 @@
+require 'xero-min/client'
+require 'xero-min/erb'

data/lib/xero-min/client.rb

@@ -0,0 +1,145 @@
+require 'oauth'
+require 'oauth/signature/rsa/sha1'
+require 'oauth/request_proxy/typhoeus_request'
+require 'typhoeus'
+require 'nokogiri'
+require 'escape_utils'
+
+require 'xero-min/urls'
+
+module XeroMin
+  class Client
+    include XeroMin::Urls
+
+    @@signature = {
+      signature_method: 'HMAC-SHA1'
+    }
+    @@options = {
+      site: 'https://api.xero.com/api.xro/2.0',
+      request_token_path: "/oauth/RequestToken",
+      access_token_path: "/oauth/AccessToken",
+      authorize_path: "/oauth/Authorize",
+      headers: {
+        'Accept' => 'text/xml',
+        'Content-Type' => 'application/x-www-form-urlencoded; charset=utf-8'
+      }
+    }.merge(@@signature)
+
+    # Public : body is transformed using body_proc if present
+    # proc has one param
+    # defaults to `lambda{|body| EscapeUtils.escape_url(body)}`, that is url encode body
+    attr_accessor :body_proc
+
+    def initialize(consumer_key=nil, secret_key=nil, options={})
+      @options = @@options.merge(options)
+      @consumer_key, @secret_key  = consumer_key , secret_key
+      self.body_proc = lambda{|body| EscapeUtils.escape_url(body)}
+    end
+
+    # Public returns whether it has already requested an access token
+    def token?
+      !!@token
+    end
+
+    # Public : enables client to act as a private application
+    # resets previous access token if any
+    def private!(private_key_file='keys/xero.rsa')
+      @token = nil if token?
+      @options.merge!({signature_method: 'RSA-SHA1', private_key_file: private_key_file})
+      self
+    end
+
+    # Public : creates a signed request
+    # url of request is XeroMin::Urls.url_for sym_or_url, when string_or_url_for is not a String
+    # available options are the one of a Typhoeus::Request
+    # request is yielded to block if present
+    # first request ask for access token
+    def request(string_or_url_for, options={}, &block)
+      url = (string_or_url_for.is_a?(String) ? string_or_url_for : url_for(string_or_url_for))
+      options[:body] = body_proc.call(options[:body]) if (options[:body] and body_proc)
+      accept_option = options.delete(:accept)
+      if accept_option
+        options[:headers] ||= {}
+        options[:headers].merge! 'Accept' => accept_option
+      end
+      req = Typhoeus::Request.new(url, @options.merge(options))
+
+      # sign request with oauth
+      helper = OAuth::Client::Helper.new(req, @options.merge(consumer: token.consumer, token: token, request_uri: url))
+      req.headers.merge!({'Authorization' => helper.header})
+      yield req if block_given?
+      req
+    end
+
+    # Public : runs a request
+    def run(request=nil)
+      queue(request) if request
+      hydra.run
+    end
+
+    # Public : creates and runs a request and parse! its body
+    def request!(sym_or_url, options={}, &block)
+      parse!(request(sym_or_url, options, &block).tap{|r| run(r)}.response)
+    end
+
+    # Public: returns response body if Content-Type is application/pdf or a nokogiri node
+    def self.parse(response)
+      case content_type = response.headers_hash['Content-Type']
+      when 'application/pdf'
+        response.body
+      when %r(^text/xml)
+        Nokogiri::XML(response.body)
+      else
+        raise Problem, "Unsupported Content-Type : #{content_type}"
+      end
+    end
+
+    # try to doctorify failing response
+    def self.diagnose(response)
+      diagnosis = case response.code
+      when 400
+        Nokogiri::XML(response.body).xpath('//Message').to_a.map{|e| e.content}.uniq.join("\n")
+      when 401
+        EscapeUtils.unescape_url(response.body).gsub('&', "\n")
+      else
+        response.body
+      end
+      "code=#{response.code}\n#{diagnosis}\nbody=\n#{response.body}"
+    end
+
+    # Public : parse response or die if response fails
+    def parse!(response)
+      response.success?? Client.parse(response) : raise(Problem, Client.diagnose(response))
+    end
+
+    # Public : get, put, and post are shortcut for a request using this verb (question mark available)
+    [:get, :put, :post].each do |method|
+      module_eval <<-EOS, __FILE__, __LINE__ + 1
+        def #{method}(sym_or_url, options={}, &block)
+          request(sym_or_url, {method: :#{method}}.merge(options), &block)
+        end
+        def #{method}!(sym_or_url, options={}, &block)
+          request!(sym_or_url, {method: :#{method}}.merge(options), &block)
+        end
+      EOS
+    end
+
+    private
+    def hydra
+      @hydra ||= Typhoeus::Hydra.new
+    end
+    def queue(request)
+      hydra.queue(request)
+      self
+    end
+    def token
+      @token ||= OAuth::AccessToken.new(OAuth::Consumer.new(@consumer_key, @secret_key, @options),
+        @consumer_key, @secret_key)
+    end
+    def options
+      @options
+    end
+  end
+  class Problem < StandardError
+  end
+end

data/lib/xero-min/erb.rb

@@ -0,0 +1,42 @@
+require 'erb'
+
+module XeroMin
+  class Erb
+    # Public : dir where templates are looked for
+    attr_accessor :template_dir
+    # Public : post processing for raw erb
+    # default compacts xml, removing \n and spaces
+    attr_accessor :post_processing_proc
+
+    def initialize(template_dir=nil)
+      self.template_dir = template_dir || File.expand_path('../templates', __FILE__)
+      self.post_processing_proc = lambda {|xml| xml.gsub(%r((\s*)<), '<')}
+    end
+
+    # Public : renders a single entity with an infered template
+    # eg : render(contact: {first_name: 'me'}) will render #{template_dir}/contact.xml.erb with {first_name: 'me'} as lvar
+    def render(locals={})
+      erb = ERB.new(read_template(infered_template(locals.keys.first)))
+      inject_locals(locals)
+      post_processing_proc.call(self.instance_eval {erb.result binding})
+    end
+
+    def infered_template(sym)
+      "#{sym}.xml.erb"
+    end
+
+    private
+    def inject_locals(hash)
+      hash.each_pair do |key, value|
+        symbol = key.to_s
+        class << self;self;end.module_eval("attr_accessor :#{symbol}")
+        self.send "#{symbol}=", value
+      end
+      self
+    end
+
+    def read_template(template)
+      File.read(File.join(template_dir, template))
+    end
+  end
+end

data/lib/xero-min/templates/contact.xml.erb

@@ -0,0 +1,7 @@
+<Contact>
+  <ContactNumber><%= contact[:id] %></ContactNumber>
+  <Name><%= contact[:name] %></Name>
+  <FirstName><%= contact[:first_name] %></FirstName>
+  <LastName><%= contact[:last_name] %></LastName>
+  <EmailAddress><%= contact[:email] %></EmailAddress>
+</Contact>

data/lib/xero-min/templates/invoice.xml.erb

@@ -0,0 +1,19 @@
+<Invoice>
+  <Type>ACCREC</Type>
+  <Contact>
+    <ContactID><%= invoice[:contact][:id] %></ContactID>
+  </Contact>
+  <Date><%= Time.now.strftime('%Y-%m-%d') %></Date>
+  <DueDate><%= Time.now.strftime('%Y-%m-%d') %></DueDate>
+  <LineAmountTypes>Exclusive</LineAmountTypes>
+  <LineItems>
+  <% invoice[:items].each do |item| %>
+    <LineItem>
+      <Description><%= item[:description] %></Description>
+      <Quantity><%= item[:quantity] %></Quantity>
+      <UnitAmount><%= item[:price] %></UnitAmount>
+      <AccountCode><%= item[:ref] %></AccountCode>
+    </LineItem>
+  <% end %>
+  </LineItems>
+</Invoice>

data/lib/xero-min/urls.rb

@@ -0,0 +1,16 @@
+module XeroMin
+  module Urls
+    # Public : use plural to get a collection or use singular and value
+    # url_for(:invoices) OR url_for(invoice: 'INV-001')
+    def url_for(sym_or_hash)
+      key, value = case sym_or_hash
+      when Hash
+        sym_or_hash.first
+      else
+        sym_or_hash
+      end
+      base = "https://api.xero.com/api.xro/2.0/#{key.to_s.capitalize}"
+      value ? "#{base}s/#{value}" : base
+    end
+  end
+end

data/lib/xero-min/version.rb

@@ -0,0 +1,3 @@
+module XeroMin
+  VERSION = "0.0.9"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rspec'
+require 'wrong/adapters/rspec'
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/xero-min/client_spec.rb

@@ -0,0 +1,143 @@
+#encoding: utf-8
+require 'spec_helper'
+require 'xero-min/client'
+require 'ostruct'
+
+def google
+  'http://google.com'
+end
+
+def parse_authorization(header)
+  header['Authorization'].split(',').map{|s| s.strip.gsub("\"", '').split('=')}.reduce({}) {|acc, (k,v)| acc[k]=v; acc}
+end
+
+describe "#request" do
+  let(:client) {XeroMin::Client.new}
+  let(:xml) {'<Name>Vélo</Name>'}
+  it "yields request to block" do
+    headers = nil
+    request = client.request('https://api.xero.com/api.xro/2.0/Contacts') {|r| headers = r.headers}
+    headers.should == request.headers
+  end
+  it "can use plain url" do
+    client.request(google).url.should == google
+  end
+  it "can use a symbol for an url, using transformation XeroMin::Urls" do
+    client.stubs(:url_for).with(:google).returns(google)
+    client.request(:google).url.should == google
+  end
+  it "can initialize body" do
+    r = client.tap{|c| c.body_proc = nil}.request google, body: xml
+    r.body.should == xml
+  end
+  it "can use xml option to set body with urlencoded xml" do
+    r = client.request google, body: xml
+    r.body.should == '%3CName%3EV%C3%A9lo%3C%2FName%3E'
+  end
+  it "has default headers" do
+    request = client.request google
+    request.headers['Accept'].should == 'text/xml'
+    request.headers['Content-Type'].should == 'application/x-www-form-urlencoded; charset=utf-8'
+  end
+  it "handles :accept option as a shortcut to Accept header" do
+    request = client.request google, accept: 'application/pdf'
+    request.headers['Accept'].should == 'application/pdf'
+  end
+end
+
+describe "#request!" do
+  let(:client) {XeroMin::Client.new}
+  it "runs request and parse it" do
+    request = OpenStruct.new(response: OpenStruct.new(code: 200))
+    client.stubs(:request).with(google, {}).returns(request)
+    client.expects(:run).with(request)
+    client.expects(:parse!).with(request.response)
+    client.request!(google)
+  end
+end
+
+[:get, :put, :post].each do |method|
+  describe "#{method}" do
+    let(:client) {XeroMin::Client.new}
+    it "uses #{method} method" do
+      r = client.send(method, google)
+      r.method.should == method
+    end
+  end
+end
+
+[:get, :put, :post].each do |method|
+  describe "#{method}!" do
+    let(:client) {XeroMin::Client.new}
+    it "executes a #{method} request!" do
+      client.stubs("request!").with(google, {method: method}).returns(404)
+      client.send("#{method}!", google).should == 404
+    end
+  end
+end
+
+describe "#body_proc" do
+  let(:client) {XeroMin::Client.new}
+  it "has default value has a url_encode function" do
+    client.body_proc.should_not be_nil
+  end
+end
+
+describe 'private #token' do
+  let(:key) {'key'}
+  let(:secret) {'secret'}
+  let(:consumer) {Object.new}
+  let(:token) {Object.new}
+
+  it 'lazily initialize token with appropriate parameters' do
+    OAuth::Consumer.stubs(:new).with(key, secret, anything).returns(consumer)
+    OAuth::AccessToken.stubs(:new).with(consumer, key, secret).returns(token)
+
+    XeroMin::Client.new(key, secret).send(:token).should == token
+  end
+
+  it 'reuse existing token' do
+    cli = XeroMin::Client.new
+    cli.send(:token).should be cli.send(:token)
+  end
+end
+
+describe ".diagnose" do
+  it "reports oauth problem" do
+    body = "oauth_problem=signature_method_rejected&oauth_problem_advice=No%20certificates%20have%20been%20registered%20for%20the%20consumer"
+    response = OpenStruct.new(code: 401, body: body)
+    diagnosis = XeroMin::Client.diagnose(response)
+    assert {diagnosis =~ %r(code=401\noauth_problem=signature_method_rejected\noauth_problem_advice=No certificates have been registered for the consumer)}
+  end
+end
+
+describe "signature options" do
+  let(:cli) {XeroMin::Client.new}
+  it "default to public app behavior (HMAC-SHA1)" do
+    authorization = parse_authorization(cli.request(google).headers)
+    assert {authorization['oauth_signature_method'] == 'HMAC-SHA1'}
+  end
+  it "#private! resets headers if called after obtaining an access token" do
+    cli.request(google)
+    authorization = parse_authorization(cli.private!.request(google).headers)
+    assert {authorization['oauth_signature_method'] == 'RSA-SHA1'}
+  end
+end
+
+describe ".parse" do
+  it "returns raw content when ContentType is application/pdf" do
+    body = 'a.pdf'
+    response = OpenStruct.new(code: 401, body: body, headers_hash: {"Content-Type"=>"application/pdf"})
+    XeroMin::Client.parse(response).should be body
+  end
+  it "returns Nokogiri when ContentType is text/xml" do
+    body = '<foo>bar</foo>'
+    response = OpenStruct.new(code: 401, body: body, headers_hash: {"Content-Type"=>"text/xml; charset=utf-8"})
+    content = XeroMin::Client.parse(response)
+    content.should be_a Nokogiri::XML::Document
+  end
+  it "raises elsewhere (argh)" do
+    response = OpenStruct.new(code: 401, headers_hash: {"Content-Type"=>"application/json"})
+    expect {XeroMin::Client.parse(response)}.to raise_error(XeroMin::Problem, 'Unsupported Content-Type : application/json')
+  end
+end

data/spec/xero-min/erb_spec.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+require 'xero-min/erb'
+
+describe XeroMin::Erb do
+  let(:erb) {XeroMin::Erb.new}
+  describe "#template_dir" do
+    it "is default ./templates from source file" do
+      erb.template_dir.should =~ %r(xero-min/templates$)
+    end
+  end
+
+  describe "#infered_template" do
+    [:contact, :invoice].each do |sym|
+      it "is #{sym}.xml.erb for #{sym}" do
+        erb.infered_template(sym).should == "#{sym}.xml.erb"
+      end
+    end
+  end
+
+  describe "#render" do
+    let(:contact) {{name: 'Héloise Dupont', first_name: 'Héloise', last_name: 'Dupont', email: 'heloise@dupont.com'}}
+    it "should be nice" do
+      erb.render(contact: contact).should =~ %r(<Name>Héloise Dupont</Name>)
+    end
+    it "post processes erb output with #post_process_proc, that compacts xml" do
+      erb.render(contact: contact).should =~ %r(^<Contact><ContactNumber>)
+    end
+  end
+end

data/spec/xero-min/urls_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+load 'xero-min/urls.rb'
+
+describe XeroMin::Urls do
+  include XeroMin::Urls
+  {contact: 'Contact', contacts: 'Contacts'}.each do |k,v|
+    specify {url_for(k).should == "https://api.xero.com/api.xro/2.0/#{v}"}
+  end
+  it "can take a hash and and id" do
+    url_for(invoice: 'INV-001').should == "https://api.xero.com/api.xro/2.0/Invoices/INV-001"
+  end
+end

data/spec/xero-min/utils_spec.rb

@@ -0,0 +1,15 @@
+# describe 'extract_invoice_id' do
+#   it 'should extract InvoiceNumber from happy xml, under xpath' do
+#     xml = <<XML
+# <Response>
+# <Invoices>
+#   <Invoice>
+#     <InvoiceNumber>INV-0011</InvoiceNumber>
+#   </Invoice>
+# </Invoices>
+# </Response>
+# XML
+#     response = HttpDuck.new(200, xml)
+#     @connector.extract_invoice_id(response).should == 'INV-0011'
+#   end
+# end

data/xero-min.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.expand_path("../lib", __FILE__)
+require "xero-min/version"
+
+Gem::Specification.new do |s|
+  s.name        = "xero-min"
+  s.version     = XeroMin::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Thierry Henrio"]
+  s.email       = ["thierry.henrio@gmail.com"]
+  s.homepage    = "https://github.com/thierryhenrio/xero-min"
+  s.summary     = <<-EOS
+    Minimal xero lib, no models, just wires
+  EOS
+  s.description = <<-EOS
+    Wires are oauth-ruby, typhoeus, nokogiri
+  EOS
+  s.rubyforge_project = "xero-min"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'oauth', '~> 0.4'
+  s.add_dependency 'nokogiri', '~> 1'
+  s.add_dependency 'typhoeus', '~> 0.2'
+  s.add_dependency 'escape_utils', '~> 0.2'
+  s.add_development_dependency 'rspec', '~> 2'
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: xero-min
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+  prerelease: 
+platform: ruby
+authors:
+- Thierry Henrio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-05-17 00:00:00.000000000 +02:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oauth
+  requirement: &2153946460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153946460
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &2153945960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153945960
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: &2153945500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153945500
+- !ruby/object:Gem::Dependency
+  name: escape_utils
+  requirement: &2153945040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153945040
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2153944580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: *2153944580
+description: ! '    Wires are oauth-ruby, typhoeus, nokogiri
+
+'
+email:
+- thierry.henrio@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Guardfile
+- README.md
+- Rakefile
+- lib/xero-min.rb
+- lib/xero-min/client.rb
+- lib/xero-min/erb.rb
+- lib/xero-min/templates/contact.xml.erb
+- lib/xero-min/templates/invoice.xml.erb
+- lib/xero-min/urls.rb
+- lib/xero-min/version.rb
+- spec/spec_helper.rb
+- spec/xero-min/client_spec.rb
+- spec/xero-min/erb_spec.rb
+- spec/xero-min/urls_spec.rb
+- spec/xero-min/utils_spec.rb
+- xero-min.gemspec
+has_rdoc: true
+homepage: https://github.com/thierryhenrio/xero-min
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: xero-min
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Minimal xero lib, no models, just wires
+test_files:
+- spec/spec_helper.rb
+- spec/xero-min/client_spec.rb
+- spec/xero-min/erb_spec.rb
+- spec/xero-min/urls_spec.rb
+- spec/xero-min/utils_spec.rb