ebayr 0.0.4 → 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c6a8d014c48da465ef9813378975e782f1b64728
+  data.tar.gz: 1bcc92d6f405c47d8935a036f32a1023640a2aa6
+SHA512:
+  metadata.gz: 35164d75bf6bcd6fc85e6d8754086bad689333df0489e9d613300f5fe7bda8cb8eaa72afcf0806db6fb8cc9762a645a8ae98dc53aa6e151d24f50f1cc1825aec
+  data.tar.gz: 7d92802f8b38331c70196e349c75b9f794533ba8451c4b58eba94fd37d4bb56d59a069a272e193546ae70ad4ea314dbccf4e1e305d2436b12992e6b301cded75

data/.gitignore

@@ -15,4 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.ebayr.conf
 *.sw?

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+- 2.0.0
+- 1.9.3
+- 1.8.7

data/Guardfile

@@ -0,0 +1,8 @@
+# -*- encoding : utf-8 -*-
+guard :test do
+  watch(%r{^lib/(.+)\.rb$})       { |m| "test/#{m[1]}_test.rb" }
+  watch(%r{^test/(.+)_test\.rb$}) { |m| "test/#{m[1]}_test.rb" }
+  watch('test/test_helper.rb')  { "test" }
+end
+
+# vi:ft=ruby

data/README.md

@@ -29,28 +29,28 @@ stuff - look at the [eBay developer docs][1] for details).
 ```ruby
 require 'ebayr'
 
-Ebay.dev_id = "my-dev-id"
+Ebayr.dev_id = "my-dev-id"
 
 # This is only needed if you want to retrieve user tokens
-Ebay.authorization_callback_url = "https://my-site/callback-url"
+Ebayr.authorization_callback_url = "https://my-site/callback-url"
 
-Ebay.auth_token = "myverylongebayauthtoken"
+Ebayr.auth_token = "myverylongebayauthtoken"
 
-Ebay.app_id = "my-ebay-app-id"
+Ebayr.app_id = "my-ebay-app-id"
 
-Ebay.cert_id = "my-ebay-cert-id"
+Ebayr.cert_id = "my-ebay-cert-id"
 
-Ebay.ru_name = "my-ebay-ru-name"
+Ebayr.ru_name = "my-ebay-ru-name"
 
 # Set this to true for testing in the eBay Sandbox (but remember to use the
 # appropriate keys!). It's true by default.
-Ebay.sandbox = false
+Ebayr.sandbox = false
 ```
 
 Now you're ready to make calls
-
 ```ruby
 Ebayr.call(:GeteBayOfficialTime)
+session = Ebayr.call(:GetSessionID, :RuName => Ebayr.ru_name)[:SessionID]
 ```
 
 To use an authorized user's key, pass in an `auth_token` parameter
@@ -58,6 +58,7 @@ To use an authorized user's key, pass in an `auth_token` parameter
 Ebayr.call(:GetOrders, :auth_token => "another-ebay-auth-token")
 ```
 
+
 ### Configuration
 
 Ebayr will look for the following Ruby files, and load them *once* in order (if
@@ -78,6 +79,8 @@ repository.
 
 ## Testing
 
+[![Status](https://travis-ci.org/bjjb/ebayr.png?branch=master)](https://travis-ci.org/bjjb/ebayr)
+
 When running test, you generally won't want to use up your API call-limit too
 quickly, so it makes sense to stub out calls to the eBay API.
 

data/Rakefile

@@ -1,10 +1,12 @@
 #!/usr/bin/env rake
+# -*- encoding : utf-8 -*-
+
 require "bundler/gem_tasks"
 require "rake/testtask"
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = FileList["test/test*.rb"]
+  t.test_files = FileList["test/**/*_test.rb"]
 end
 
 task :default => :test

data/ebayr.gemspec

@@ -1,20 +1,30 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/ebayr/version', __FILE__)
+# -*- encoding : utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["JJ Buckley"]
-  gem.email         = ["jj@bjjb.org"]
-  gem.description   = %q{A tidy library for using the eBay Trading API with Ruby}
-  gem.summary       = %q{eBayR is a gem that makes it (relatively) easy to use the eBay Trading API from Ruby. Includes a self-contained XML parser, a flexible callback system, and easy integration into Rails.}
-  gem.homepage      = "http://jjbuckley.github.com/ebayr"
+  gem.authors       = ["Bryan JJ Buckley"]
+  gem.email         = ["jjbuckley@gmail.org"]
+  gem.description   = "A tidy library for using the eBay Trading API with Ruby"
+  gem.summary       = <<-DESCRIPTION
+eBayR is a gem that makes it (relatively) easy to use the eBay Trading API from
+Ruby. Includes a self-contained XML parser, a flexible callback system, and a
+command-line client which aids integration into other projects.
+  DESCRIPTION
+  gem.homepage      = "http://bjjb.github.com/ebayr"
 
   gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^test/})
   gem.name          = "ebayr"
   gem.require_paths = ["lib"]
-  gem.version       = Ebayr::VERSION
-  gem.add_dependency 'activesupport'
+  gem.version       = "0.0.5"
+  if RUBY_VERSION < "1.9"
+    gem.add_dependency 'activesupport', '~> 3.2'
+    gem.add_development_dependency 'minitest'
+  else
+    gem.add_dependency 'activesupport', '~> 4.0'
+  end
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'fakeweb'
 end

data/lib/ebayr/record.rb

@@ -0,0 +1,49 @@
+# -*- encoding : utf-8 -*-
+module Ebayr
+  class Record < Hash
+    def initialize(initial = {})
+      super()
+      initial.each { |k, v| self[k] = v }
+    end
+
+    def <=>(another)
+      return false unless another.respond_to(:keys) and another.respond_to(:"[]")
+      another.keys.each do |k|
+        return false unless convert_value(another[k]) == self[k]
+      end
+      true
+    end
+
+    def [](key)
+      super(convert_key(key))
+    end
+
+    def []=(key, value)
+      key = convert_key(key)
+      value = convert_value(value)
+      (class << self; self; end).send(:define_method, key) { value }
+      super(key, value)
+    end
+
+  protected
+    def convert_key(k)
+      self.class.convert_key(k)
+    end
+
+    def self.convert_key(k)
+      k.to_s.underscore.gsub(/e_bay/, "ebay").to_sym
+    end
+
+    def convert_value(arg)
+      self.class.convert_value(arg)
+    end
+
+    def self.convert_value(arg)
+      case arg
+        when Hash then Record.new(arg)
+        when Array then arg.map { |a| convert_value(a) }
+        else arg
+      end
+    end
+  end
+end

data/lib/ebayr/request.rb

@@ -0,0 +1,122 @@
+# -*- encoding : utf-8 -*-
+module Ebayr #:nodoc:
+  # Encapsulates a request which is sent to the eBay Trading API.
+  class Request
+    include Ebayr
+
+    attr_reader :command
+
+    # Make a new call. The URI used will be that of Ebayr::uri, unless
+    # overridden here (same for auth_token, site_id and compatability_level).
+    def initialize(command, options = {})
+      @command = self.class.camelize(command.to_s)
+      @uri = options.delete(:uri) || self.uri
+      @uri = URI.parse(@uri) unless @uri.is_a? URI
+      @auth_token = (options.delete(:auth_token) || self.auth_token).to_s
+      @site_id = (options.delete(:site_id) || self.site_id).to_s
+      @compatability_level = (options.delete(:compatability_level) || self.compatability_level).to_s
+      # Remaining options are converted and used as input to the call
+      @input = self.class.serialize_input(options)
+    end
+
+    # Gets the path to which this request will be posted
+    def path
+      @uri.path
+    end
+
+    # Gets the headers that will be sent with this request.
+    def headers
+      {
+        'X-EBAY-API-COMPATIBILITY-LEVEL' => @compatability_level.to_s,
+        'X-EBAY-API-DEV-NAME' => dev_id.to_s,
+        'X-EBAY-API-APP-NAME' => app_id.to_s,
+        'X-EBAY-API-CERT-NAME' => cert_id.to_s,
+        'X-EBAY-API-CALL-NAME' => @command.to_s,
+        'X-EBAY-API-SITEID' => @site_id.to_s,
+        'Content-Type' => 'text/xml'
+      }
+    end
+
+    # Gets the body of this request (which is XML)
+    def body
+      <<-XML
+        <?xml version="1.0" encoding="utf-8"?>
+        <#{@command}Request xmlns="urn:ebay:apis:eBLBaseComponents">
+          <RequesterCredentials>
+            <eBayAuthToken>#{@auth_token}</eBayAuthToken>
+          </RequesterCredentials>
+          #{self.class.xml(@input)}
+        </#{@command}Request>
+      XML
+    end
+
+    # Makes a HTTP connection and sends the request, returning an
+    # Ebayr::Response
+    def send
+      http = Net::HTTP.new(@uri.host, @uri.port)
+
+      if @uri.port == 443
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      post = Net::HTTP::Post.new(@uri.path, headers)
+      post.body = body
+
+      response = http.start { |http| http.request(post) }
+
+      @response = Response.new(self, response)
+    end
+
+    def to_s
+      "#{@command}[#{@input}] <#{@uri}>"
+    end
+
+    # A very, very simple XML serializer.
+    #
+    #     Ebayr.xml("Hello!")       # => "Hello!"
+    #     Ebayr.xml(:foo=>"Bar")  # => <foo>Bar</foo>
+    #     Ebayr.xml(:foo=>["Bar","Baz"])  # => <foo>Bar</foo>
+    def self.xml(*args)
+      args.map do |structure|
+        case structure
+          when Hash then structure.map { |k, v| "<#{k.to_s}>#{xml(v)}</#{k.to_s}>" }.join
+          when Array then structure.map { |v| xml(v) }.join
+          else structure.to_s
+        end
+      end.join
+    end
+
+    # Prepares a hash of arguments for input to an eBay Trading API XML call.
+    # * Times are converted to ISO 8601 format
+    def self.serialize_input(args)
+      result = {}
+      args.each do |k, v|
+        result[k] = case v
+          when Time then v.to_time.utc.iso8601
+          else v
+        end
+      end
+      result
+    end
+
+    # Converts a command like get_ebay_offical_time to GeteBayOfficialTime
+    def self.camelize(string)
+      string = string.to_s
+      return string unless string == string.downcase
+      string.split('_').map(&:capitalize).join.gsub('Ebay', 'eBay')
+    end
+
+    # Gets a HTTP connection for this request. If you pass in a block, it will
+    # be run on that HTTP connection.
+    def http(&block)
+      http = Net::HTTP.new(@uri.host, @uri.port)
+      if @uri.port == 443
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      return http.start(&block) if block_given?
+      http
+    end
+  end
+end

data/lib/ebayr/response.rb

@@ -0,0 +1,15 @@
+# -*- encoding : utf-8 -*-
+module Ebayr #:nodoc:
+  # A response to an Ebayr::Request.
+  class Response < Record
+    def initialize(request, response)
+      @request = request
+      @command = @request.command if @request
+      @response = response
+      @body = response.body if @response
+      hash = self.class.from_xml(@body) if @body
+      response_data = hash["#{@command}Response"] if hash
+      super(response_data) if response_data
+    end
+  end
+end

data/lib/ebayr/test_helper.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Ebayr
   module TestHelper
     @@success = Ebayr.xml(:Ack => "Success")
@@ -17,7 +18,13 @@ module Ebayr
     #       assert Ebayr.call(:GeteBayOfficialTime) # => stubbed call
     #     end
     #   end
+    #
+    # This method is deprecated, and will be removed in a future release.
     def stub_ebay_call!(call, content, &block)
+      puts <<DEPRECATION
+stub_ebay_call! is deprecated, and will be removed in a future release. Please
+use Ruby techniques to stub eBay calls your way. See the wiki for details.
+DEPRECATION
       content = Ebayr.xml(content) unless content.is_a?(String)
       _allow_net_connect_ = FakeWeb.allow_net_connect?
       FakeWeb.allow_net_connect = false
@@ -27,11 +34,10 @@ module Ebayr
           #{content}
         </#{call}Response>
       XML
-      FakeWeb.register_uri( :any, Ebayr.uri, :body => body)
+      FakeWeb.register_uri(:any, Ebayr.uri, :body => body)
       yield
       FakeWeb.clean_registry
       FakeWeb.allow_net_connect = _allow_net_connect_
     end
-
   end
 end

data/lib/ebayr/user.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+module Ebayr
+  module User
+    # Shorthand for call(call, arguments.merge(:auth_token => this.ebay_token))
+    # Allows objects which mix in this module to use their own token.
+    def ebay_call(call, arguments = {})
+      raise "#{self} has no eBay token" unless ebay_token
+      Ebayr.call(call, arguments.merge(:auth_token => ebay_token))
+    end
+
+    # Gets the user's data
+    def get_ebay_data
+      ebay_call(:GetUser)
+    end
+  end
+end

data/lib/ebayr.rb

@@ -1,52 +1,92 @@
 # -*- encoding : utf-8 -*-
-require "ebayr/version"
+require 'logger'
 require 'net/https'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/hash/conversions'
-require 'active_support/buffered_logger'
 
+# A library to assist in using the eBay Trading API.
 module Ebayr
-  mattr_accessor :dev_id,
-                 :app_id,
-                 :cert_id,
-                 :ru_name,
-                 :auth_token,
-                 :sandbox,
-                 :authorization_callback_url,
-                 :callbacks,
-                 :site_id,
-                 :compatability_level,
-                 :logger
-
-  @@logger ||= if defined?(Rails) 
-    Rails.logger
-  else
-    ActiveSupport::BufferedLogger.new(STDOUT) 
+  autoload :Record,   File.expand_path('../ebayr/record', __FILE__)
+  autoload :Request,  File.expand_path('../ebayr/request',  __FILE__)
+  autoload :Response, File.expand_path('../ebayr/response', __FILE__)
+  autoload :User,     File.expand_path('../ebayr/user',     __FILE__)
+
+  # To make a call, you need to have a registered user and app. Then you must
+  # fill in the <code>dev_id</code>, <code>app_id</code>, <code>cert_id</code>
+  # and <code>ru_name</code>. You will also need an <code>auth_token</code>,
+  # though you may use any user's token here.
+  # See http://developer.ebay.com/DevZone/XML/docs/HowTo/index.html for more
+  # details.
+  mattr_accessor :dev_id
+  mattr_accessor :app_id
+  mattr_accessor :cert_id
+  mattr_accessor :ru_name
+  mattr_accessor :auth_token
+
+  # Determines whether to use the eBay sandbox or the real site.
+  mattr_accessor :sandbox
+  self.sandbox = true
+
+  # Set to true to generate fancier objects for responses (will decrease
+  # performance).
+  mattr_accessor :normalize_responses
+
+  def self.normalize_responses?
+    !!normalize_responses
   end
 
-  %W(/etc/ebayrc.conf /usr/local/etc/ebayrc.conf ~/.ebayrc.conf ./.ebayrc.conf).each do |path|
-    load path if File.exists?(path = File.expand_path(path))
-  end
-
-
-  @@site_id             ||= 0   # US
-  @@compatability_level ||= 745
-
-  def self.sandbox?
+  def sandbox?
     !!sandbox
   end
 
+  # This URL is used to redirect the user back after a successful registration.
+  # For more details, see here:
+  # http://developer.ebay.com/DevZone/XML/docs/WebHelp/wwhelp/wwhimpl/js/html/wwhelp.htm?context=eBay_XML_API&topic=GettingATokenViaFetchToken
+  mattr_accessor :authorization_callback_url
+  self.authorization_callback_url = 'https://example.com/'
+
+  # This URL is used if the authorization process fails - usually because the user
+  # didn't click 'I agree'. If you leave it nil, the
+  # <code>authorization_callback_url</code> will be used (but the parameters will be
+  # different).
+  mattr_accessor :authorization_failure_url
+  self.authorization_failure_url = nil
+
+  # Callbacks which are invoked at various points throughout a request.
+  mattr_accessor :callbacks
+  self.callbacks = {
+    :before_request   => [],
+    :after_request    => [],
+    :before_response  => [],
+    :after_response   => [],
+    :on_error         => []
+  }
+
+  # The eBay Site to use for calls. The full list of available sites can be
+  # retrieved with <code>GeteBayDetails(:DetailName => "SiteDetails")</code>
+  mattr_accessor :site_id
+  self.site_id = 0
+
+  # eBay Trading API version to use. For more details, see
+  # http://developer.ebay.com/devzone/xml/docs/HowTo/eBayWS/eBaySchemaVersioning.html
+  mattr_accessor :compatability_level
+  self.compatability_level = 745
+
+  mattr_accessor :logger
+  self.logger = Logger.new(STDOUT)
+  self.logger.level = Logger::INFO
+
   # Gets either ebay.com/ws or sandbox.ebay.com/ws, as appropriate, with
   # "service" prepended. E.g.
   #
   #     Ebayr.uri_prefix("blah")  # => https://blah.ebay.com/ws
   #     Ebayr.uri_prefix          # => https://api.ebay.com/ws
-  def self.uri_prefix(service = "api")
+  def uri_prefix(service = "api")
     "https://#{service}#{sandbox ? ".sandbox" : ""}.ebay.com/ws"
   end
 
   # Gets the URI used for API calls (as a URI object)
-  def self.uri(*args)
+  def uri(*args)
     URI::parse("#{uri_prefix(*args)}/api.dll")
   end
 
@@ -54,24 +94,12 @@ module Ebayr
   # via an API call to GetSessionID (be sure to use the right ru_name), and the
   # ru_params can contain anything (they will be passed back to your app in the
   # redirect from eBay upon successful login and authorization).
-  def self.authorization_uri(session_id, ru_params = {})
+  def authorization_uri(session_id, ru_params = {})
     ruparams = CGI::escape(ru_params.map { |k, v| "#{k}=#{v}" }.join("&"))
     URI::parse("#{uri_prefix("signin")}/eBayISAPI.dll?SignIn&RuName=#{ru_name}&SessId=#{session_id}&ruparams=#{ruparams}")
   end
 
-  # A very, very simple XML serializer.
-  #
-  #     Ebayr.xml("Hello!")       # => "Hello!"
-  #     Ebayr.xml({:foo=>"Bar"})  # => <foo>Bar</foo>
-  def self.xml(structure)
-    case structure
-      when Hash then structure.map { |k, v| "<#{k.to_s}>#{xml(v)}</#{k.to_s}>" }.join
-      when Array then structure.map { |v| xml(v) }
-      else structure.to_s
-    end
-  end
-
-  # Make an eBay call (symbol or string). You can pass in these arguments:
+  # Perform an eBay call (symbol or string). You can pass in these arguments:
   #
   # auth_token:: to use a user's token instead of the general token
   # site_id:: to use a specific eBay site (default is 0, which is US ebay.com)
@@ -79,111 +107,38 @@ module Ebayr
   #
   # All other arguments are passed into the API call, and may be nested.
   #
-  # Remember, case matters.
+  #     response = call(:GeteBayOfficialTime)
+  #     response = call(:get_ebay_official_time)
   #
-  #     call(:GeteBayOfficialTime)
+  # See Ebayr::Request for details.
   #
-  # The response is a Hash of the response, deserialized from the XML by
-  # ActiveSupport's XML deserializer.
-  def self.call(call, arguments = {})
-    call = call.to_s
-
-    auth_token = arguments.delete(:auth_token) || self.auth_token.to_s
-    site_id = arguments.delete(:site_id) || self.site_id.to_s
-    compatability_level = arguments.delete(:compatability_level) || self.compatability_level.to_s
-
-    headers = {
-      'X-EBAY-API-COMPATIBILITY-LEVEL' => compatability_level.to_s,
-      'X-EBAY-API-DEV-NAME' => dev_id.to_s,
-      'X-EBAY-API-APP-NAME' => app_id.to_s,
-      'X-EBAY-API-CERT-NAME' => cert_id.to_s,
-      'X-EBAY-API-CALL-NAME' => call.to_s,
-      'X-EBAY-API-SITEID' => site_id.to_s,
-      'Content-Type' => 'text/xml'
-    }
-
-    xml = xml(arguments)
-
-    xml = <<-XML
-      <?xml version="1.0" encoding="utf-8"?>
-      <#{call}Request xmlns="urn:ebay:apis:eBLBaseComponents">
-        <RequesterCredentials>
-          <eBayAuthToken>#{auth_token}</eBayAuthToken>
-        </RequesterCredentials>
-        #{xml}
-      </#{call}Request>
-    XML
-
-    request = Net::HTTP::Post.new(uri.path, headers)
-
-    request.body = xml.to_s
-
-    http = Net::HTTP.new(uri.host, uri.port)
-
-    if uri.port == 443
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    end
-
-    response = http.start { |http| http.request(request) }
-
-    if callbacks
-      callbacks.each do |callback|
-        if callback.is_a?(Symbol)
-          send(callback, request, response)
-        elsif callback.respond_to?(:call)
-          callback.call(request, response)
-        else
-          throw Error.new("Invalid callback: #{callback.to_s}")
-        end
-      end
-    end
-
-    case response
-    when Net::HTTPSuccess 
-      result = Hash.from_xml(response.body)["#{call}Response"]
-      unless result
-        raise Exception.new("No #{call}Response in response", request, response)
-      end
-      case result['Ack']
-      when 'Success'
-        return result
-      when 'Warning'
-        @@logger.warn(result['Errors'].inspect)
-        return result
-      else
-        raise Error.new(result['Errors'], request, response)
-      end
-      return result
-    else
-      raise Exception.new("Unexpected response from server", request, response)
-    end
+  # The response is a special Hash of the response, deserialized from the XML
+  #
+  #     response.timestamp     # => 2010-10-10 10:00:00 UTC
+  #     response[:timestamp]   # => 2010-10-10 10:00:00 UTC
+  #     response['Timestamp']  # => "2012-10-10T10:00:00.000Z"
+  #     response[:Timestamp]   # => "2012-10-10T10:00:00.000Z"
+  #     response.ack           # "Success"
+  #     response.success?      # true
+  #
+  #  See Ebayr::Response for details.
+  #
+  #  To see a list of available calls, check out
+  #  http://developer.ebay.com/DevZone/XML/docs/Reference/ebay/index.html
+  def call(command, arguments = {})
+    Request.new(command, arguments).send
   end
 
-  # Shorthand for call(call, arguments.merge(:auth_token => this.ebay_token))
-  # Allows objects which mix in this module to use their own token.
-  def ebay_call(call, arguments = {})
-    raise "#{self} has no eBay token" unless ebay_token
-    Ebay.call(call, arguments.merge(:auth_token => ebay_token))
-  end
 
-  class Exception < ::Exception
-    attr_reader :request, :response
-    def initialize(message, request, response)
-      super message
-      @request, @response = request, response
-    end
+  def self.included(mod)
+    mod.extend(self)
   end
 
-  class Error < Exception
-    attr_reader :request, :response, :errors
-    def initialize(errors, request, response)
-      @errors, @request, @response = errors, request, response
-      super
-    end
-    
-    def to_s
-      [@errors].flatten.map { |e| "<#{e['LongMessage']}>" }.join(", ")
-    end
-  end
+  extend self
+end
+
+# Override defaults with values from a config file, if there is one.
+%W(/etc/ebayr.conf /usr/local/etc/ebayr.conf ~/.ebayr.conf ./.ebayr.conf).each do |path|
+  load path if File.exists?(path = File.expand_path(path))
 end
+

data/test/ebayr/record_test.rb

@@ -0,0 +1,21 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+require 'ebayr/record'
+
+module Ebayr
+  class RecordTest < MiniTest::Unit::TestCase
+    def test_lookup_is_case_insensitive
+      record = Record.new('Foo' => 'Bar')
+      assert_equal 'Bar', record['Foo']
+    end
+
+    def test_records_are_nested
+      record = Record.new(:Foo => { "Bar" => "Baz" })
+      assert_equal "Baz", record.foo.bar
+
+      record = Record.new('Foo' => { 'Bars' => [{ 'Value' => 1 }, { 'Value' => 2 }] })
+      assert_equal 1, record.foo.bars[0].value
+      assert_equal 2, record.foo.bars[1].value
+    end
+  end
+end

data/test/ebayr/request_test.rb

@@ -0,0 +1,45 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+require 'ebayr/request'
+
+describe Ebayr::Request do
+  describe "serializing input" do
+    it "converts times" do
+      result = Ebayr::Request.serialize_input("Time" => Time.utc(2010, 'oct', 31, 03, 15))
+      result['Time'].must_equal "2010-10-31T03:15:00Z"
+    end
+  end
+
+  describe "uri" do
+    it "is the Ebayr one" do
+      Ebayr::Request.new(:Blah).uri.must_equal(Ebayr.uri)
+    end
+  end
+
+  describe "xml" do
+    def request(*args)
+      Ebayr::Request.xml(*args)
+    end
+
+    it "convets a hash" do
+      request(:a => { :b => 123 }).must_equal '<a><b>123</b></a>'
+    end
+
+    it "converts an array" do
+      request([{ :a => 1 }, { :a => 2 }]).must_equal "<a>1</a><a>2</a>"
+    end
+
+    it "converts a string" do
+      request('boo').must_equal 'boo'
+    end
+
+    it "converts a number" do
+      request(1234).must_equal '1234'
+    end
+
+    it "converts multiple arguments" do
+      args = [{ :a => 1 }, { :a => [{:b => 1 }, { :b => 2 }] }]
+      request(*args).must_equal '<a>1</a><a><b>1</b><b>2</b></a>'
+    end
+  end
+end

data/test/ebayr/response_test.rb

@@ -0,0 +1,50 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+require 'ostruct'
+require 'ebayr/response'
+
+describe Ebayr::Response do
+  it "builds objects from XML" do
+    xml = "<GetSomethingResponse><Foo>Bar</Foo></GetSomethingResponse>"
+    response = Ebayr::Response.new(
+      OpenStruct.new(:command => 'GetSomething'),
+      OpenStruct.new(:body => xml))
+    response['Foo'].must_equal 'Bar'
+    response.foo.must_equal 'Bar'
+  end
+
+  it "handes responses" do
+    xml = "<GeteBayResponse><eBayFoo>Bar</eBayFoo></GeteBayResponse>"
+    response = Ebayr::Response.new(
+      OpenStruct.new(:command => 'GeteBay'),
+      OpenStruct.new(:body => xml))
+    response.ebay_foo.must_equal 'Bar'
+  end
+
+  def test_response_nesting
+    xml = <<-XML
+      <GetOrdersResponse>
+        <OrdersArray>
+          <Order>
+            <OrderID>1</OrderID>
+          </Order>
+          <Order>
+            <OrderID>2</OrderID>
+          </Order>
+          <Order>
+            <OrderID>3</OrderID>
+          </Order>
+        </OrdersArray>
+      </GetOrdersResponse>
+    XML
+    response = Ebayr::Response.new(
+      OpenStruct.new(:command => 'GetOrders'),
+      OpenStruct.new(:body => xml)
+    )
+    assert_kind_of Hash, response.orders_array
+    response.orders_array.order[0].order_id.must_equal "1"
+    response.orders_array.order[1].order_id.must_equal "2"
+    response.orders_array.order[2].order_id.must_equal "3"
+  end
+
+end

data/test/ebayr_test.rb

@@ -0,0 +1,87 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+require 'ebayr'
+require 'fakeweb'
+
+describe Ebayr do
+  before { Ebayr.sandbox = true }
+
+  def check_common_methods(mod = Ebayr)
+    assert_respond_to mod, :"dev_id"
+    assert_respond_to mod, :"dev_id="
+    assert_respond_to mod, :"cert_id"
+    assert_respond_to mod, :"cert_id="
+    assert_respond_to mod, :"ru_name"
+    assert_respond_to mod, :"ru_name="
+    assert_respond_to mod, :"auth_token"
+    assert_respond_to mod, :"auth_token="
+    assert_respond_to mod, :"compatability_level"
+    assert_respond_to mod, :"compatability_level="
+    assert_respond_to mod, :"site_id"
+    assert_respond_to mod, :"site_id="
+    assert_respond_to mod, :"sandbox"
+    assert_respond_to mod, :"sandbox="
+    assert_respond_to mod, :"sandbox?"
+    assert_respond_to mod, :"authorization_callback_url"
+    assert_respond_to mod, :"authorization_callback_url="
+    assert_respond_to mod, :"authorization_failure_url"
+    assert_respond_to mod, :"authorization_failure_url="
+    assert_respond_to mod, :"callbacks"
+    assert_respond_to mod, :"callbacks="
+    assert_respond_to mod, :"logger"
+    assert_respond_to mod, :"logger="
+    assert_respond_to mod, :"uri"
+  end
+
+  # If this passes without an exception, then we're ok.
+  describe "basic usage" do
+    before { FakeWeb.register_uri(:post, Ebayr.uri, :body => xml) }
+    let(:xml) { "<GeteBayOfficialTimeResponse><Ack>Succes</Ack><Timestamp>blah</Timestamp></GeteBayOfficialTimeResponse>" }
+
+    it "runs without exceptions" do
+      Ebayr.call(:GeteBayOfficialTime).timestamp.must_equal 'blah'
+    end
+  end
+
+  it "correctly reports its sandbox status" do
+    Ebayr.sandbox = false
+    Ebayr.wont_be :sandbox?
+    Ebayr.sandbox = true
+    Ebayr.must_be :sandbox?
+  end
+
+  it "has the right sandbox URIs" do
+    Ebayr.must_be :sandbox?
+    Ebayr.uri_prefix.must_equal "https://api.sandbox.ebay.com/ws"
+    Ebayr.uri_prefix("blah").must_equal "https://blah.sandbox.ebay.com/ws"
+    Ebayr.uri.to_s.must_equal "https://api.sandbox.ebay.com/ws/api.dll"
+  end
+
+  it "has the right real-world URIs" do
+    Ebayr.sandbox = false
+    Ebayr.uri_prefix.must_equal "https://api.ebay.com/ws"
+    Ebayr.uri_prefix("blah").must_equal "https://blah.ebay.com/ws"
+    Ebayr.uri.to_s.must_equal "https://api.ebay.com/ws/api.dll"
+    Ebayr.sandbox = true
+  end
+
+  it "works when as an extension" do
+    mod = Module.new { extend Ebayr }
+    check_common_methods(mod)
+  end
+
+  it "works as an inclusion" do
+    mod = Module.new { extend Ebayr }
+    check_common_methods(mod)
+  end
+
+  it "has the right methods" do
+    check_common_methods
+  end
+
+  it "has decent defaults" do
+    Ebayr.must_be :sandbox?
+    Ebayr.uri.to_s.must_equal "https://api.sandbox.ebay.com/ws/api.dll"
+    Ebayr.logger.must_be_kind_of Logger
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+# -*- encoding : utf-8 -*-
+require 'minitest/autorun'

metadata

@@ -1,97 +1,111 @@
 --- !ruby/object:Gem::Specification
 name: ebayr
 version: !ruby/object:Gem::Version
-  version: 0.0.4
-  prerelease: 
+  version: 0.0.5
 platform: ruby
 authors:
-- JJ Buckley
+- Bryan JJ Buckley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-18 00:00:00.000000000Z
+date: 2013-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &81893100 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
   type: :runtime
   prerelease: false
-  version_requirements: *81893100
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &81892860 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *81892860
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: fakeweb
-  requirement: &81892620 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *81892620
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A tidy library for using the eBay Trading API with Ruby
 email:
-- jj@bjjb.org
+- jjbuckley@gmail.org
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
+- Guardfile
 - LICENSE
 - README.md
 - Rakefile
 - ebayr.gemspec
 - lib/ebayr.rb
+- lib/ebayr/record.rb
+- lib/ebayr/request.rb
+- lib/ebayr/response.rb
 - lib/ebayr/test_helper.rb
-- lib/ebayr/version.rb
-- test/test_ebayr.rb
-homepage: http://jjbuckley.github.com/ebayr
+- lib/ebayr/user.rb
+- test/ebayr/record_test.rb
+- test/ebayr/request_test.rb
+- test/ebayr/response_test.rb
+- test/ebayr_test.rb
+- test/test_helper.rb
+homepage: http://bjjb.github.com/ebayr
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -317667633
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -317667633
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: eBayR is a gem that makes it (relatively) easy to use the eBay Trading API
   from Ruby. Includes a self-contained XML parser, a flexible callback system, and
-  easy integration into Rails.
+  a command-line client which aids integration into other projects.
 test_files:
-- test/test_ebayr.rb
+- test/ebayr/record_test.rb
+- test/ebayr/request_test.rb
+- test/ebayr/response_test.rb
+- test/ebayr_test.rb
+- test/test_helper.rb

data/lib/ebayr/version.rb

@@ -1,3 +0,0 @@
-module Ebayr
-  VERSION = "0.0.4"
-end

data/test/test_ebayr.rb

@@ -1,29 +0,0 @@
-require 'test/unit'
-require 'ebayr'
-require 'ebayr/test_helper'
-
-class TestEbayr < Test::Unit::TestCase
-  include Ebayr::TestHelper
-
-  # If this passes without an exception, then we're ok.
-  def test_sanity
-    t = Time.now.to_s
-    stub_ebay_call!(:GeteBayOfficialTime, :Timestamp => t) do
-      result = Ebayr.call(:GeteBayOfficialTime)
-      assert_equal t, result['Timestamp']
-    end
-  end
-
-  def test_sandbox_reports_accurately
-    Ebayr.sandbox = false
-    assert !Ebayr.sandbox?
-    Ebayr.sandbox = true
-    assert Ebayr.sandbox?
-  end
-
-  def test_ebayr_uris
-    assert_equal "https://api.sandbox.ebay.com/ws", Ebayr.uri_prefix
-    assert_equal "https://blah.sandbox.ebay.com/ws", Ebayr.uri_prefix("blah")
-    assert_equal "https://api.sandbox.ebay.com/ws/api.dll", Ebayr.uri.to_s
-  end
-end