utapi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 918543a3d5824f1f6a853a55cb907a2a4c104a12
+  data.tar.gz: fdf9a795faddcaa22d2ebe7dfbb76c7360f4f684
+SHA512:
+  metadata.gz: bbbab1563cd57f25b76675028634476a246992eff6ce34697d0ca6da1e3892d3eb717621f4d65765e37b6ffbaab6aa73bfad780e3a01f8e4365e2e410101548e
+  data.tar.gz: 5ba150f13bf9d25e2582a3a1e8df6580979442f27e70e27a3cb3ff47b140fca57dfd0e4341105af110195c15f6897495a4c57f5ba1aee6874b202cde6aacd892

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+spec/cassettes/*
+.env

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in utapi.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Cameron Martin
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,66 @@
+# UTApi
+
+A thin api in ruby for ultimate team. It handles logging in, retrying requests, and http errors.
+All the api calls (see below) return a hash which is just the json returned by that request
+(I said it was thin).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'utapi'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install utapi
+
+## Usage
+
+```ruby
+client = UTApi::Client.new(email, password, hash, platform)
+client.login # true
+client.credits
+
+#  {
+#    'credits' => 16659,
+#    'currencies' => [
+#        { 'name' => 'COINS', 'funds' => 16659, 'finalFunds' => 16659 },
+#        { 'name' => 'POINTS', 'funds' => 0, 'finalFunds' => 0 }
+#    ],
+#    'unopenedPacks' => {
+#        'preOrderPacks' => 0,
+#        'recoveredPacks' => 0
+#    },
+#    'bidTokens' => {}
+#  }
+
+```
+
+### Api Methods
+
+* search(params)
+* auction_status(ids)
+* bid(trade_id, value)
+* list_item(item_id, start_price, bin_price, duration)
+* move_card(item_id, pile)
+* trade_pile
+* watch_list
+* unassigned_items
+* delete_from_trade_pile(trade_id)
+* delete_from_watch_list(trade_id1, trade_id2, ...)
+* get_credits
+
+If you need more adding, just open an issue.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/faraday/error_handler.rb

@@ -0,0 +1,40 @@
+require 'faraday'
+require 'utapi/exceptions'
+
+module Faraday
+  class ErrorHandler < Middleware
+
+
+    def call(env)
+
+      begin
+        response = @app.call(env)
+      rescue Net::ReadTimeout, Errno::ETIMEDOUT, Timeout::Error, Faraday::Error::TimeoutError => e # Timeout Errors
+        raise UTApi::ConnectionError.new(e, response_values(env))
+      end
+
+      response.on_complete do |env|
+        handle_return_errors(env)
+      end
+
+    end
+
+    def handle_return_errors(env)
+      case env[:status]
+        when 302, 200, 461
+          # Let them pass through
+        when 401
+          raise UTApi::NotLoggedInError, response_values(env)
+        else
+          raise UTApi::ServerError, response_values(env)
+      end
+    end
+
+    def response_values(env)
+      {:status => env.status, :headers => env.response_headers, :body => env.body}
+    end
+
+  end
+end
+
+Faraday::Middleware.register_middleware(:error_handler => Faraday::ErrorHandler)

data/lib/utapi.rb

@@ -0,0 +1,6 @@
+require 'utapi/version'
+require 'utapi/client'
+
+module Utapi
+  # Your code goes here...
+end

data/lib/utapi/account.rb

@@ -0,0 +1,7 @@
+require 'rattributes'
+
+module UTApi
+  class Account
+    include Rattributes.new(:email, :password, :hash, :platform)
+  end
+end

data/lib/utapi/authorization.rb

@@ -0,0 +1,7 @@
+require 'rattributes'
+
+module UTApi
+  class Authorization
+    include Rattributes.new(:server, :phishing_token, :sid)
+  end
+end

data/lib/utapi/client.rb

@@ -0,0 +1,149 @@
+# Provides the public interface for the api
+
+require 'utapi/exceptions'
+require 'utapi/connection'
+require 'utapi/login_service'
+require 'utapi/account'
+require 'utapi/util'
+
+module UTApi
+  class Client
+
+    attr_reader :logged_in
+
+    def initialize(email, password, hash, platform)
+      @account = Account.new(email: email, password: password, hash: hash, platform: platform)
+      @logged_in = false
+    end
+
+    def login
+      @authorization = generate_authorization
+    rescue LoginError
+      false
+    else
+      true
+    end
+
+    def search(params)
+
+      action = 'transfermarket?' + Util.encode_query_string(params)
+
+      do_request(action).tap do |response|
+        raise ApiCallFailed, "response has no auctionInfo: #{response}" unless response.is_a?(Hash) and response.has_key?('auctionInfo')
+      end
+
+    end
+
+    def auction_status(ids)
+
+      action = 'trade/status?' +  Util.encode_query_string(tradeIds: ids.join(','))
+
+      do_request(action).tap do |response|
+        raise ApiCallFailed, "response has no auctionInfo: #{response}" unless response.is_a?(Hash) and response.has_key?('auctionInfo')
+      end
+
+    end
+
+    def bid(trade_id, value)
+      response = do_request("trade/#{trade_id}/bid", :put, {bid: value})
+      response.is_a?(Hash) and response.has_key?('auctionInfo')
+    end
+
+
+    def list_item(item_id, start_price, bin_price, duration)
+
+      response = do_request('auctionhouse', :post, {
+          startingBid: start_price,
+          duration: duration,
+          itemData: {
+              id: item_id
+          },
+          buyNowPrice: bin_price
+      })
+
+      response.is_a?(Hash) and response.has_key?('id')
+    end
+
+    def move_card(item_id, pile)
+
+      response = do_request('item', :put, {
+          itemData: [{ id: item_id, pile: pile }]
+      })
+
+      response.is_a?(Hash) and response.has_key?('itemData') and response['itemData'][0]['success']
+    end
+
+    def trade_pile
+      do_request('tradepile', :get).tap do |response|
+        raise ApiCallFailed, "Cannot get trade pile, response: #{response}" unless response.is_a?(Hash) and response.has_key?('auctionInfo')
+      end
+    end
+
+    def watch_list
+      do_request('watchlist', :get)
+    end
+
+    def unassigned_items
+      do_request('purchased/items', :get)
+    end
+
+    def delete_from_trade_pile(trade_id)
+      do_request("trade/#{trade_id}", :delete)
+    end
+
+    def delete_from_watch_list(*trade_ids)
+      action = 'watchlist?' +  Util.encode_query_string(tradeId: trade_ids.join(','))
+      do_request(action, :delete)
+    end
+
+    def get_credits
+      do_request('user/credits')
+    end
+
+  private
+
+    def do_request(action, verb=:get, payload=nil)
+
+      retried = false
+
+      begin
+
+        headers = {
+            'Content-Type' => 'application/json',
+            'X-HTTP-Method-Override' => verb.to_s.upcase,
+            'X-UT-PHISHING-TOKEN' => authorization.phishing_token,
+            'X-UT-SID' => authorization.sid
+        }
+
+        response = connection.post("#{authorization.server}/ut/game/fifa14/#{action}", payload, headers)
+      rescue NotLoggedInError
+        @logged_in = false
+        if !retried && login
+          retried = true
+          retry
+        else
+          raise
+        end
+      end
+
+      response.env[:body]
+    end
+
+    # REVIEW: LoginError can leak out if login is not explicitly called
+
+    def authorization
+      @authorization ||= generate_authorization
+    end
+
+    def generate_authorization
+      LoginService.new(@account).execute.tap do |*|
+        @logged_in = true
+      end
+    end
+
+    def connection
+      @connection ||= Connection.new
+    end
+
+  end
+end

data/lib/utapi/connection.rb

@@ -0,0 +1,52 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'faraday-cookie_jar'
+require 'faraday-rate_limiter'
+require 'faraday/error_handler'
+
+module UTApi
+  class Connection
+
+    attr_writer :cookie_jar
+    attr_writer :request_interval
+
+    def initialize
+      @user_agent = 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; .NET CLR 2.0.50727)'
+    end
+
+    # TODO: Define a better interface for these function
+    def get(*args, &block)
+      connection.get(*args, &block)
+    end
+
+    def post(*args, &block)
+      connection.post(*args, &block)
+    end
+
+    def cookie_jar
+      @cookie_jar ||= HTTP::CookieJar.new
+    end
+
+    def request_interval
+      @request_interval ||= 2
+    end
+
+  private
+
+    def connection
+      @connection ||= Faraday.new(ssl: {verify: false}, request: {timeout: 20, open_timeout: 20}, headers: { 'User-Agent' => @user_agent }) do |faraday|
+        faraday.response :follow_redirects, limit: 5
+        #faraday.response :raise_error # This catches generic http errors
+        faraday.request :retry, exceptions: [UTApi::ConnectionError, UTApi::ServerError], interval: 1, backoff_factor: 2, max: 3
+        faraday.use :error_handler # This is custom error handling
+        faraday.use :cookie_jar, jar: cookie_jar
+        faraday.request :url_encoded
+        faraday.request :json
+        faraday.response :json, content_type: 'application/json'
+        faraday.request :rate_limiter, interval: request_interval if request_interval > 0
+        faraday.adapter  :net_http_persistent
+      end
+    end
+
+  end
+end

data/lib/utapi/exceptions.rb

@@ -0,0 +1,20 @@
+module UTApi
+  class NotLoggedInError < RuntimeError; end # Raised when the client is not logged in/the session has expired
+  class LoginError < RuntimeError; end # Raised when there is an error logging in
+  class ServerError < RuntimeError; end # Raised when the server returns something strange
+  class ApiCallFailed < RuntimeError; end
+
+  class ConnectionError < RuntimeError # Raised when we cannot connect to the server (timeouts mainly)
+    attr_reader :wrapped_exception
+
+    def initialize(wrapped_exception, *args, &block)
+      @wrapped_exception = wrapped_exception
+      super(*args, &block)
+    end
+
+    def to_s
+      "#{@wrapped_exception.class}: #{super}"
+    end
+  end
+
+end

data/lib/utapi/login_service.rb

@@ -0,0 +1,141 @@
+require 'utapi/authorization'
+require 'utapi/persona'
+require 'utapi/exceptions'
+require 'utapi/connection'
+
+# Returns a new instance of Authorization
+
+# TODO: Do something with this, its a bit messy.
+module UTApi
+  class LoginService
+
+    def initialize(account)
+      @account = account
+
+      @connection = Connection.new
+      @connection.request_interval = 0
+    end
+
+
+    def execute
+      @nucleus_user_id = do_initial_login
+      do_futweb_cookie_stage
+      @server = get_server
+      @persona = get_account_info
+      @sid = get_sid
+      @phishing_token = get_phishing_token
+
+      Authorization.new(server: @server, phishing_token: @phishing_token, sid: @sid)
+    end
+
+  private
+
+    def require_instance_variables(*vars)
+      vars.map!(&:to_s)
+      unless vars.all? { |var| instance_variable_defined?("@#{var}") }
+        raise "Required instance variables #{vars.join(', ')} not set"
+      end
+    end
+
+    def generate_headers(*fields)
+      {}.tap do |headers|
+        headers['Easw-Session-Data-Nucleus-Id'] = @nucleus_user_id.to_s if fields.include?(:nuc)
+        headers['X-UT-Route'] = @server || 'https://utas.fut.ea.com' if fields.include?(:route)
+        headers['X-UT-SID'] = @sid if fields.include?(:sid)
+      end
+    end
+
+    # Returns nucleus user id
+    def do_initial_login
+      response = @connection.get 'http://www.easports.com/fifa/football-club/ultimate-team'
+
+      r2 = @connection.post(
+          response.env[:url],
+          {email: @account.email, password: @account.password, rememberMe: 'on', _rememberMe: 'on', _eventId: 'submit', facebookAuth: ''},
+          {referer: response.env[:url].to_s}
+      )
+
+      extract_nucleus_user_id(r2.env[:body])
+    end
+
+    def extract_nucleus_user_id(body)
+      nucleus_user_id = body.match /userid : "(\d+)"/
+      raise LoginError, 'Cannot get nucleus user id' if nucleus_user_id.nil? or nucleus_user_id[1].to_i == 0
+      nucleus_user_id[1].to_i
+    end
+
+    def do_futweb_cookie_stage
+      @connection.get('http://www.easports.com/iframe/fut/', {
+          locale: 'en_GB',
+          baseShowoffUrl: 'http://www.easports.com/uk/fifa/football-club/ultimate-team/show-off',
+          guest_app_uri:'http://www.easports.com/uk/fifa/football-club/ultimate-team'
+      })
+    end
+
+    def get_server
+      # REVIEW: Do we need to send the route here?
+      require_instance_variables :nucleus_user_id
+
+      shards = @connection.get('http://www.easports.com/iframe/fut/p/ut/shards', {}, generate_headers(:nuc, :route))
+
+      shard = shards.env[:body]['shardInfo'].find do |shard|
+        shard['platforms'].include?(@account.platform.to_s)
+      end
+
+      raise LoginError, 'Could not find the server' if shard.nil?
+
+      "#{shard['clientProtocol']}://#{shard['clientFacingIpPort']}"
+    end
+
+    def get_account_info
+      require_instance_variables :server, :nucleus_user_id
+
+      account_info = @connection.get('http://www.easports.com/iframe/fut/p/ut/game/fifa14/user/accountinfo', {}, generate_headers(:nuc, :route))
+
+      raise LoginError, "Could not get account info: #{account_info}" unless account_info.env[:body].is_a?(Hash)
+
+      persona = account_info.env[:body]['userAccountInfo']['personas'][0]
+
+      Persona.new(persona_id: persona['personaId'], persona_name: persona['personaName'])
+    end
+
+    def get_sid
+      require_instance_variables :persona, :nucleus_user_id, :server
+
+      payload = {
+          isReadOnly: false,
+          sku: 'FUT14IOS',
+          clientVersion: 8,
+          #sku: 'FUT14WEB',
+          #clientVersion: 1,
+          nuc: @nucleus_user_id,
+          nucleusPersonaId: @persona.persona_id,
+          nucleusPersonaDisplayName: @persona.persona_name,
+          #nucleusPersonaPlatform: 'ps3', # 360 or ps3 REVIEW: Where do these come from? and is it needed?
+          locale: 'en-GB',
+          method: 'authcode',
+          priorityLevel: 4,
+          identification: { authCode: '' }
+      }
+
+      headers = generate_headers(:nuc, :route).merge({'Content-Type' => 'application/json'})
+
+      auth = @connection.post('http://www.easports.com/iframe/fut/p/ut/auth', payload, headers)
+
+      auth.env[:body]['sid']
+
+    end
+
+    def get_phishing_token
+
+      payload = { answer: @account.hash }
+
+      response = @connection.post('http://www.easports.com/iframe/fut/p/ut/game/fifa14/phishing/validate', payload, generate_headers(:nuc, :route, :sid))
+
+      # This must be parsed manually, because the content-type sent isn't right!
+      JSON.parse(response.env[:body])['token']
+
+    end
+
+  end
+end

data/lib/utapi/persona.rb

@@ -0,0 +1,7 @@
+require 'rattributes'
+
+module UTApi
+  class Persona
+    include Rattributes.new(:persona_id, :persona_name)
+  end
+end

data/lib/utapi/util.rb

@@ -0,0 +1,5 @@
+module Util
+  def self.encode_query_string(query_hash)
+    query_hash.map { |key, value| "#{CGI::escape(key.to_s)}=#{CGI::escape(value.to_s)}" }.join('&')
+  end
+end

data/lib/utapi/version.rb

@@ -0,0 +1,3 @@
+module UTApi
+  VERSION = '0.0.1'
+end

data/spec/client_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+require 'utapi/client'
+
+describe UTApi::Client, vcr: { cassette_name: 'requests' } do
+
+  subject(:client) do
+    UTApi::Client.new(
+      ENV['TEST_ACCOUNT_EMAIL'],
+      ENV['TEST_ACCOUNT_PASSWORD'],
+      ENV['TEST_ACCOUNT_HASH'],
+      ENV['TEST_ACCOUNT_PLATFORM']
+    )
+  end
+
+  describe '#get_credits' do
+    it 'should return credits' do
+      response = client.get_credits
+
+      expect(response['credits']).to be_kind_of(Integer)
+    end
+  end
+end

data/spec/login_service_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+require 'utapi/login_service'
+require 'utapi/connection'
+require 'utapi/account'
+
+describe UTApi::LoginService, vcr: { cassette_name: 'requests' } do
+
+  let(:account) do
+    UTApi::Account.new(
+        email: ENV['TEST_ACCOUNT_EMAIL'],
+        password: ENV['TEST_ACCOUNT_PASSWORD'],
+        hash: ENV['TEST_ACCOUNT_HASH'],
+        platform: ENV['TEST_ACCOUNT_PLATFORM']
+    )
+  end
+
+  let(:login_service) { UTApi::LoginService.new(account) }
+
+  describe '#execute' do
+    it 'does not raise error' do
+      expect { login_service.execute }.to_not raise_error
+    end
+
+    it 'returns Authorization instance' do
+      expect(login_service.execute).to be_a(UTApi::Authorization)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'vcr'
+require 'dotenv'
+
+Dotenv.load
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/cassettes'
+  c.hook_into :webmock
+  c.configure_rspec_metadata!
+end
+
+#require 'net-http-spy'
+#
+#Net::HTTP.http_logger = Logger.new(File.expand_path("../tmp/logs/login-#{Time.now}.log", File.dirname(__FILE__)))
+#Net::HTTP.http_logger_options = { verbose: true }

data/utapi.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'utapi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'utapi'
+  spec.version       = UTApi::VERSION
+  spec.authors       = ['Cameron Martin']
+  spec.email         = ['cameronmartin123@gmail.com']
+  spec.description   = %q{FIFA 14 Ultimate Team api in Ruby}
+  spec.summary       = spec.description
+  spec.homepage      = 'https://github.com/cameron-martin/utapi'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'vcr'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'dotenv'
+
+  spec.add_runtime_dependency 'faraday', '~> 0.9.0'
+  spec.add_runtime_dependency 'faraday_middleware', '~> 0.9.0'
+  spec.add_runtime_dependency 'faraday-cookie_jar'
+  spec.add_runtime_dependency 'faraday-rate_limiter'
+
+  spec.add_runtime_dependency 'net-http-persistent'
+  spec.add_runtime_dependency 'rattributes'
+end

metadata

@@ -0,0 +1,236 @@
+--- !ruby/object:Gem::Specification
+name: utapi
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Cameron Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: faraday-cookie_jar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday-rate_limiter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rattributes
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: FIFA 14 Ultimate Team api in Ruby
+email:
+- cameronmartin123@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/faraday/error_handler.rb
+- lib/utapi.rb
+- lib/utapi/account.rb
+- lib/utapi/authorization.rb
+- lib/utapi/client.rb
+- lib/utapi/connection.rb
+- lib/utapi/exceptions.rb
+- lib/utapi/login_service.rb
+- lib/utapi/persona.rb
+- lib/utapi/util.rb
+- lib/utapi/version.rb
+- spec/client_spec.rb
+- spec/login_service_spec.rb
+- spec/spec_helper.rb
+- utapi.gemspec
+homepage: https://github.com/cameron-martin/utapi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: FIFA 14 Ultimate Team api in Ruby
+test_files:
+- spec/client_spec.rb
+- spec/login_service_spec.rb
+- spec/spec_helper.rb
+has_rdoc: