betfair 1.0.3 → 1.0.6

data/Gemfile

@@ -1,11 +1,12 @@
 source 'http://rubygems.org'
 
 gem 'rake'
-gem 'savon'
+gem 'savon', '<= 0.8.6'
 gem 'gemcutter'
 
 gem 'rspec'
-gem 'savon_spec'
+gem 'savon_spec', '= 0.1.5'
+gem 'mocha', '=0.10.4'
 
 gemspec
 

data/README.md

@@ -161,9 +161,9 @@ The API PlaceBets service allows you to place multiple (1 to 60) bets on a singl
 
     exchange_id     = 1
     bets            = []
-    bets <<  { market_id: 12345, runner_id: 58805, bet_type: 'B', price: 2.0, size: 2.0, asian_line_id: 0, 
+    bets <<  { market_id: 12345, selection_id: 58805, bet_type: 'B', price: 2.0, size: 2.0, asian_line_id: 0, 
                 bet_category_type: 'E', bet_peristence_type: 'NONE', bsp_liability: 0 }
-    bets <<  { market_id: 12345, runner_id: 1234, bet_type: 'L', price: 1.5, size: 2.0, asian_line_id: 0, 
+    bets <<  { market_id: 12345, selection_id: 1234, bet_type: 'L', price: 1.5, size: 2.0, asian_line_id: 0, 
                   bet_category_type: 'E', bet_peristence_type: 'NONE', bsp_liability: 0 }
 
     place_multiple_bets =               
@@ -238,7 +238,7 @@ foo[100388290] returns
     
     { :market_id=>100388290, :market_name=>"Premiers 2012", :market_type=>"O", :market_status=>"ACTIVE", :event_date=>2012-03-24 16:20:00 +0800, 
       :menu_path=>"\\Australian Rules\\AFL 2012", :event_hierarchy=>"/61420/26759191/100388290", :bet_delay=>"0", :exchange_id=>2, 
-      :iso3_country_code=>"AUS", :last_refresh=>2012-03-29 16:35:21 +0800, :number_of_runners=>18, :number_of_winners=>1, 
+      :iso3_country_code=>"AUS", :last_refresh=>2012-03-29 16:35:21 +0800, :number_of_selections=>18, :number_of_winners=>1, 
       :total_amount_matched=>193599.58, :bsp_market=>false, :turning_in_play=>false
     } 
 
@@ -255,7 +255,7 @@ foo.first returns
     
     { :market_id=>100388290, :market_name=>"Premiers 2012", :market_type=>"O", :market_status=>"ACTIVE", :event_date=>2012-03-24 08:20:00 UTC, 
       :menu_path=>"\\Australian Rules\\AFL 2012", :event_heirachy=>"/61420/26759191/100388290", :bet_delay=>0, :exchange_id=>2, 
-      :iso3_country_code=>"AUS", :last_refresh=>2012-03-29 09:10:12 UTC, :number_of_runners=>18, :number_of_winners=>1, 
+      :iso3_country_code=>"AUS", :last_refresh=>2012-03-29 09:10:12 UTC, :number_of_selections=>18, :number_of_winners=>1, 
       :total_amount_matched=>193657.0, :bsp_market=>false, :turning_in_play=>false
     }
     
@@ -263,7 +263,7 @@ foo.first returns
 This helper sorts out a nice hash from the 
     
     market  = bf.get_market(session_token, 2, 100388290)
-    foo     = helpers.market_info(details)
+    foo     = helpers.market_info(market)
 
 Which returns
 
@@ -276,7 +276,7 @@ This helper cleans up the prices
     foo     = helpers.prices(prices)
 
 ## Combine ##
-Use this to combine `runner_names` and prices from the #market_info and #prices helpers
+Use this to combine `selection_names` and prices from the #market_info and #prices helpers
     
     market  = bf.get_market(session_token, 2, 100388290)
     prices  = bf.get_market_prices_compressed(session_token, 2, 100388290)    
@@ -284,14 +284,14 @@ Use this to combine `runner_names` and prices from the #market_info and #prices
 
 foo.first returns
 
-    { :runner_id=>39983, :runner_name=>"Collingwood Magpies", :market_id=>100388290, :market_type_id=>61420, 
+    { :selection_id=>39983, :selection_name=>"Collingwood Magpies", :market_id=>100388290, :market_type_id=>61420, 
       :prices_string=>"39983~0~89899.79~4.2~~~false~~~~|4.2~430.35~L~1~4.1~311.51~L~2~3.85~4.75~L~3~|4.4~155.46~B~1~4.6~230.69~B~2~5.9~100.3~B~3~", 
-      :runner_matched=>89899.79, :last_back_price=>4.2, :wom=>0.6054936499440416, :b1=>4.2, :b1_available=>430.35, :b2=>4.1, :b2_available=>311.51, 
+      :selection_matched=>89899.79, :last_back_price=>4.2, :wom=>0.6054936499440416, :b1=>4.2, :b1_available=>430.35, :b2=>4.1, :b2_available=>311.51, 
       :b3=>3.85, :b3_available=>4.75, :l1=>4.4, :l1_available=>155.46, :l2=>4.6, :l2_available=>230.69, :l3=>5.9, :l3_available=>100.3 
     } 
 
 ## Details ##
-Gets the `market_id`/`market_name` and the `runner_id`/`runner_name` 
+Gets the `market_id`/`market_name` and the `selection_id`/`selection_name` 
 
     market  = bf.get_market(session_token, 2, 100388290)
     foo     = helpers.details(market)
@@ -299,15 +299,15 @@ Gets the `market_id`/`market_name` and the `runner_id`/`runner_name`
 Which returns
 
     { :market_id=>100388290, :market_type_id=>61420, 
-      :runners=>[{:runner_id=>39983, :runner_name=>"Collingwood Magpies"}, {:runner_id=>244664, :runner_name=>"Hawthorn Hawks"}, 
-      {:runner_id=>244663, :runner_name=>"Geelong Cats"}, {:runner_id=>244689, :runner_name=>"Carlton Blues"}, 
-      {:runner_id=>210344, :runner_name=>"West Coast Eagles"}, {:runner_id=>244666, :runner_name=>"Fremantle Dockers"}, 
-      {:runner_id=>244688, :runner_name=>"St Kilda Saints"}, {:runner_id=>244665, :runner_name=>"Sydney Swans"}, 
-      {:runner_id=>173363, :runner_name=>"Adelaide Crows"}, {:runner_id=>210343, :runner_name=>"Essendon Bombers"}, 
-      {:runner_id=>39986, :runner_name=>"Western Bulldogs"}, {:runner_id=>244667, :runner_name=>"Richmond Tigers"}, 
-      {:runner_id=>2013991, :runner_name=>"North Melbourne Kangaroos"}, {:runner_id=>39987, :runner_name=>"Melbourne Demons"}, 
-      {:runner_id=>39984, :runner_name=>"Brisbane Lions"}, {:runner_id=>217710, :runner_name=>"Port Adelaide Power"}, 
-      {:runner_id=>4997061, :runner_name=>"Gold Coast Suns"}, {:runner_id=>5149403, :runner_name=>"Greater Western Sydney Giants"}]
+      :selections=>[{:selection_id=>39983, :selection_name=>"Collingwood Magpies"}, {:selection_id=>244664, :selection_name=>"Hawthorn Hawks"}, 
+      {:selection_id=>244663, :selection_name=>"Geelong Cats"}, {:selection_id=>244689, :selection_name=>"Carlton Blues"}, 
+      {:selection_id=>210344, :selection_name=>"West Coast Eagles"}, {:selection_id=>244666, :selection_name=>"Fremantle Dockers"}, 
+      {:selection_id=>244688, :selection_name=>"St Kilda Saints"}, {:selection_id=>244665, :selection_name=>"Sydney Swans"}, 
+      {:selection_id=>173363, :selection_name=>"Adelaide Crows"}, {:selection_id=>210343, :selection_name=>"Essendon Bombers"}, 
+      {:selection_id=>39986, :selection_name=>"Western Bulldogs"}, {:selection_id=>244667, :selection_name=>"Richmond Tigers"}, 
+      {:selection_id=>2013991, :selection_name=>"North Melbourne Kangaroos"}, {:selection_id=>39987, :selection_name=>"Melbourne Demons"}, 
+      {:selection_id=>39984, :selection_name=>"Brisbane Lions"}, {:selection_id=>217710, :selection_name=>"Port Adelaide Power"}, 
+      {:selection_id=>4997061, :selection_name=>"Gold Coast Suns"}, {:selection_id=>5149403, :selection_name=>"Greater Western Sydney Giants"}]
     }
 
 ## Prices Complete ##
@@ -320,7 +320,7 @@ foo.first returns
     
     [ 39983, {:selection_id=>39983, :order_index=>0, :total_amount_matched=>89899.79, :last_price_matched=>4.2, :handicap=>0.0, 
       :reduction_factor=>0.0, :vacant=>false, :far_sp_price=>0.0, :near_sp_price=>0.0, :actual_sp_price=>0.0, :prices_string=>nil, 
-      :runner_matched=>0, :last_back_price=>0, :wom=>0.5516492637413943, :b1=>4.2, :b1_available=>429.06, :b2=>4.1, :b2_available=>310.58, 
+      :selection_matched=>0, :last_back_price=>0, :wom=>0.5516492637413943, :b1=>4.2, :b1_available=>429.06, :b2=>4.1, :b2_available=>310.58, 
       :b3=>3.85, :b3_available=>4.75, :l1=>4.3, :l1_available=>20.0, :l2=>4.4, :l2_available=>355.0, :l3=>4.6, :l3_available=>230.0}
     ] 
 
@@ -329,7 +329,7 @@ foo.first returns
     prices  = bf.get_market_prices_compressed(session_token, 2, 100388290)
     foo     = helpers.price_string(prices, true)
 
-    { :prices_string=>nil, :runner_matched=>0, :last_back_price=>0, :wom=>0.6054936499440416, :b1=>4.2, :b1_available=>430.35, :b2=>4.1, :b2_available=>311.51, :b3=>3.85, 
+    { :prices_string=>nil, :selection_matched=>0, :last_back_price=>0, :wom=>0.6054936499440416, :b1=>4.2, :b1_available=>430.35, :b2=>4.1, :b2_available=>311.51, :b3=>3.85, 
       :b3_available=>4.75, :l1=>4.4, :l1_available=>155.46, :l2=>4.6, :l2_available=>230.69, :l3=>5.9, :l3_available=>100.3
     }
 
@@ -375,10 +375,11 @@ trying to set a threshold on when to place a bet.
 * rake
 
 ## To Do ##
-* Work out how to implement this https://github.com/jfairbairn/em-net-http, so that the libary uses eventmachine no blocking
+* Add gzip support option
+* Add em-http support as per this once this gets pulled https://github.com/rubiii/httpi/pull/40
 * The WOM of money in Helpers#price_string returns 0 if either all b1,b2,b3 or l1,l2,l3 are all 0
 * Add some error checking to the Betfair::Helper methods
-* Finish of the mash method, to return a nice hash of all market and runner info
+* Finish of the mash method, to return a nice hash of all market and selection info
 * Write a spec for the mashed method
 
 ## Contribute ##

data/betfair.gemspec

@@ -18,9 +18,10 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'savon'
+  s.add_runtime_dependency 'savon', '<= 0.8.6'
   
   s.add_development_dependency  'rake'
   s.add_development_dependency  'rspec'
-  s.add_development_dependency  'savon_spec'
-end
+  s.add_development_dependency  'savon_spec', '= 0.1.5'
+  s.add_development_dependency  'mocha', '= 0.10.4'
+end

data/examples/README.md

@@ -0,0 +1,3 @@
+# Betfair SDK
+
+Check it out here [RubyGems](https://github.com/lukebyrne/betfair_sdk)

data/lib/betfair/api.rb

@@ -4,8 +4,13 @@ module Betfair
 
     ## Some handy constants...
 
-    EXCHANGE_IDS = { aus: 2, uk:  1 }
+    EXCHANGE_IDS = {
+      :aus => 2,
+      :uk  => 1
+    }
+    
     PRODUCT_ID_FREE = 82
+
     BET_TYPE_LAY  = 'L'
     BET_TYPE_BACK = 'B'
 
@@ -26,70 +31,70 @@ module Betfair
     ## Bet Placement API METHODS
     #
 
-    def place_bet(session_token, exchange_id, market_id, selection_id, bet_type, price, size)
-      bf_bet = {
-        marketId:           market_id,
-        selectionId:        selection_id,
-        betType:            bet_type,
-        price:              price,
-        size:               size,
-        asianLineId:        0,
-        betCategoryType:    'E',
-        betPersistenceType: 'NONE',
-        bspLiability:       0
+    def place_bet(session_token, exchange_id, market_id, selection_id, bet_type, price, size)		
+      bf_bet = { 
+        :marketId           => market_id, 
+        :selectionId        => selection_id, 
+        :betType            => bet_type, 
+        :price              => price, 
+        :size               => size, 
+        :asianLineId        => 0, 
+        :betCategoryType    => 'E', 
+        :betPersistenceType => 'NONE', 
+        :bspLiability       => 0 
       }
 
       response = exchange(exchange_id).
         session_request( session_token,
-                         :placeBets,
+                         :placeBets, 
                          :place_bets_response,
-                         bets: { 'PlaceBets' => [bf_bet] } )
+                         :bets => { 'PlaceBets' => [bf_bet] } )
 
       return response.maybe_result( :bet_results, :place_bets_result )
     end
 
     
-   def place_multiple_bets(session_token, exchange_id, bets)
+   def place_multiple_bets(session_token, exchange_id, bets)		
       bf_bets = []
       bets.each do |bet|
-        bf_bets << {
-          marketId:           bet[:market_id],
-          selectionId:        bet[:runner_id],
-          betType:            bet[:bet_type],
-          price:              bet[:price],
-          size:               bet[:size],
-          asianLineId:        bet[:asian_line_id],
-          betCategoryType:    bet[:bet_category_type],
-          betPersistenceType: bet[:bet_peristence_type],
-          bspLiability:       bet[:bsp_liability]
+        bf_bets << { 
+          :marketId           => bet[:market_id], 
+          :selectionId        => bet[:selection_id], 
+          :betType            => bet[:bet_type], 
+          :price              => bet[:price], 
+          :size               => bet[:size], 
+          :asianLineId        => bet[:asian_line_id], 
+          :betCategoryType    => bet[:bet_category_type], 
+          :betPersistenceType => bet[:bet_peristence_type], 
+          :bspLiability       => bet[:bsp_liability] 
         }
       end
 
       response = exchange(exchange_id).
         session_request( session_token,
-                         :placeBets,
+                         :placeBets, 
                          :place_bets_response,
-                         bets: { 'PlaceBets' => bf_bets } )
+                         :bets => { 'PlaceBets' => bf_bets } )
 
       return response.maybe_result( :bet_results, :place_bets_result )
     end      
     
     def update_bet(session_token, exchange_id, bet_id, new_bet_persitence_type, new_price, new_size, old_bet_persitance_type, old_price, old_size)
-       bf_bet = {
-          betId:                  bet_id,
-          newBetPersistenceType:  new_bet_persitence_type,
-          newPrice:               new_price,
-          newSize:                new_size,
-          oldBetPersistenceType:  old_bet_persitance_type,
-          oldPrice:               old_price,
-          oldSize:                old_size
+       bf_bet = { 
+          :betId                  => bet_id, 
+          :newBetPersistenceType  => new_bet_persitence_type, 
+          :newPrice               => new_price, 
+          :newSize                => new_size, 
+          :oldBetPersistenceType  => old_bet_persitance_type, 
+          :oldPrice               => old_price, 
+          :oldSize                => old_size
         }
 
         response = exchange(exchange_id).
           session_request( session_token,
-                           :updateBets,
+                           :updateBets, 
                            :update_bets_response,
-                           bets: { 'UpdateBets' => [bf_bet] } )
+                           :bets => { 'UpdateBets' => [bf_bet] } )
 
         return response.maybe_result( :bet_results, :update_bets_result )
     end
@@ -97,47 +102,47 @@ module Betfair
     def update_multiple_bets(session_token, exchange_id, bets)
       bf_bets = []
       bets.each do |bet|
-        bf_bets << {
-          betId:                  bet[:bet_id],
-          newBetPersistenceType:  bet[:new_bet_persitence_type],
-          newPrice:               bet[:new_price],
-          newSize:                bet[:new_size],
-          oldBetPersistenceType:  bet[:old_bet_persitance_type],
-          oldPrice:               bet[:old_price],
-          oldSize:                bet[:old_size]
+        bf_bets << { 
+          :betId                  => bet[:bet_id], 
+          :newBetPersistenceType  => bet[:new_bet_persitence_type], 
+          :newPrice               => bet[:new_price], 
+          :newSize                => bet[:new_size], 
+          :oldBetPersistenceType  => bet[:old_bet_persitance_type], 
+          :oldPrice               => bet[:old_price], 
+          :oldSize                => bet[:old_size] 
         }
       end
 
       response = exchange(exchange_id).
         session_request( session_token,
-                         :updateBets,
+                         :updateBets, 
                          :update_bets_response,
-                         bets: { 'UpdateBets' => bf_bets } )
+                         :bets => { 'UpdateBets' => bf_bets } )
 
-      return response.maybe_result( :bet_results, :update_bets_result )
+      return response.maybe_result( :bet_results, :update_bets_result )     
     end
     
     def cancel_bet(session_token, exchange_id, bet_id)
-      bf_bet = { betId: bet_id }
+      bf_bet = { :betId => bet_id }
 
       response = exchange(exchange_id).
         session_request( session_token,
-                         :cancelBets,
+                         :cancelBets, 
                          :cancel_bets_response,
-                         bets: { 'CancelBets' => [bf_bet] } ) # "CancelBets" has to be a string, not a symbol!
+                         :bets => { 'CancelBets' => [bf_bet] } ) # "CancelBets" has to be a string, not a symbol!
       
       return response.maybe_result( :bet_results, :cancel_bets_result )
     end
         
     def cancel_multiple_bets(session_token, exchange_id, bets)
       bf_bets = []
-      bets.each { |bet_id| bf_bets << { betId: bet_id } }
+      bets.each { |bet_id| bf_bets << { :betId => bet_id } }
 
       response = exchange(exchange_id).
         session_request( session_token,
-                         :cancelBets,
+                         :cancelBets, 
                          :cancel_bets_response,
-                         bets: { 'CancelBets' => bf_bets } ) # "CancelBets" has to be a string, not a symbol!
+                         :bets => { 'CancelBets' => bf_bets } ) # "CancelBets" has to be a string, not a symbol!
       
       return response.maybe_result( :bet_results, :cancel_bets_result )
     end
@@ -151,31 +156,31 @@ module Betfair
     
     def get_mu_bets( session_token, exchange_id, market_id = 0, bet_status = 'MU', start_record = 0, record_count = 200, sort_order = 'ASC', order_by =  'PLACED_DATE') #, bet_ids = nil, , exclude_last_second = nil, matched_since = nil
       response = exchange(exchange_id).
-        session_request( session_token,
-                         :getMUBets,
+        session_request( session_token, 
+                         :getMUBets, 
                          :get_mu_bets_response,
-                         #betIds:             bet_ids,
-                         betStatus:           bet_status,
-                         #excludeLastSecond:  exclude_last_second,
-                         marketId:            market_id,
-                         #matchedSince:       matched_since,
-                         orderBy:             order_by,
-                         recordCount:         record_count,
-                         sortOrder:           sort_order,
-                         startRecord:         start_record
+                         #:betIds => bet_ids,
+                         :betStatus => bet_status,
+                         #:excludeLastSecond => exclude_last_second,
+                         :marketId => market_id,
+                         #:matchedSince => matched_since,
+                         :orderBy => order_by,
+                         :recordCount => record_count,
+                         :sortOrder => sort_order,
+                         :startRecord => start_record
                          )
 
       return response.maybe_result( :bets, :mu_bet )
     end
     
     
-    def get_market(session_token, exchange_id, market_id, locale = nil)
+    def get_market(session_token, exchange_id, market_id, locale = nil) 
       response = exchange(exchange_id).
-        session_request( session_token,
-                         :getMarket,
+        session_request( session_token, 
+                         :getMarket, 
                          :get_market_response,
-                         marketId:  market_id, 
-                         locale:    locale )
+                         :marketId => market_id, 
+                         :locale   => locale )
 
       return response.maybe_result( :market )
     end
@@ -184,10 +189,10 @@ module Betfair
     def get_market_prices_compressed(session_token, exchange_id, market_id, currency_code = nil)
       response = exchange(exchange_id).
         session_request( session_token,
-                         :getMarketPricesCompressed,
+                         :getMarketPricesCompressed, 
                          :get_market_prices_compressed_response,
-                         marketId:      market_id,
-                         currencyCode:  currency_code )
+                         :marketId => market_id,
+                         :currencyCode => currency_code )
       
       return response.maybe_result( :market_prices )
     end
@@ -196,9 +201,9 @@ module Betfair
     def get_active_event_types(session_token, locale = nil)
       response = @global_service.
         session_request( session_token,
-                         :getActiveEventTypes,
+                         :getActiveEventTypes, 
                          :get_active_event_types_response,
-                         locale: locale )
+                         :locale => locale )
 
       return response.maybe_result( :event_type_items, :event_type )
     end
@@ -206,14 +211,14 @@ module Betfair
 
     def get_all_markets(session_token, exchange_id, event_type_ids = nil, locale = nil, countries = nil, from_date = nil, to_date = nil)
       response = exchange(exchange_id).
-        session_request( session_token,
-                         :getAllMarkets,
+        session_request( session_token, 
+                         :getAllMarkets, 
                          :get_all_markets_response,
-                         eventTypeIds: { 'int' => event_type_ids },
-                         locale:       locale,
-                         countries:    { 'Country' => countries },
-                         fromDate:     from_date,
-                         toDate:       to_date )
+                         :eventTypeIds => { 'int' => event_type_ids }, 
+                         :locale       => locale, 
+                         :countries    => { 'country' => countries }, 
+                         :fromDate     => from_date, 
+                         :toDate       => to_date )
       
       return response.maybe_result( :market_data )
     end
@@ -221,22 +226,22 @@ module Betfair
 
     def get_account_funds( session_token, exchange_id )
       response = exchange(exchange_id).
-        session_request( session_token,
-                         :getAccountFunds,
+        session_request( session_token, 
+                         :getAccountFunds, 
                          :get_account_funds_response )
 
       return response.maybe_result
     end
 
     def login(username, password, product_id, vendor_software_id, location_id, ip_address)
-      response = @global_service.request( :login,
-                                          :login_response,
-                                          username:         username,
-                                          password:         password,
-                                          productId:        product_id,
-                                          vendorSoftwareId: vendor_software_id,
-                                          locationId:       location_id,
-                                          ipAddress:        ip_address )
+      response = @global_service.request( :login, 
+                                          :login_response, 
+                                          :username         => username, 
+                                          :password         => password, 
+                                          :productId        => product_id, 
+                                          :vendorSoftwareId => vendor_software_id, 
+                                          :locationId       => location_id, 
+                                          :ipAddress        => ip_address )
 
       return response.maybe_result( :header, :session_token )
     end
@@ -247,19 +252,21 @@ module Betfair
     def keep_alive(session_token)
       response = @global_service.
         session_request( session_token,
-                         :keep_alive,
+                         :keep_alive, 
                          :keep_alive_response )
       
-      # Need to do the old school way of checking as the keep_alive response doesn't return a minorErrorCode, so fails
-      error_code = response[:header][:error_code]
-      #return error_code == 'OK' ? response[:header][:session_token] : error_code
-      return error_code == 'OK' ? response[:header][:session_token].extend( Success ) : error_code.extend( Failure )
+      # Need to do the old school way of checking as the keep_alive
+      # response doesn't return a minorErrorCode, so fails
+      error_code = response[:header][:error_code]     
+      return error_code == 'OK' ? 
+        response[:header][:session_token].extend( Success ) : 
+        error_code.extend( Failure )
     end
     
     def logout(session_token)
       response = @global_service.
         session_request( session_token,
-                         :logout,
+                         :logout, 
                          :logout_response )
       return response.maybe_result( :header, :session_token )
     end
@@ -268,11 +275,11 @@ module Betfair
     ## END OF API METHODS
 
 
-    def exchange(exchange_id)
+    def exchange(exchange_id)   
       exchange_id == EXCHANGE_IDS[:aus] ? @aus_service : @uk_service
     end
 
-    def session_token(response_header)
+    def session_token(response_header)      
       response_header[:error_code] == 'OK' ? response_header[:session_token] : response_header[:error_code]
     end
 
@@ -297,13 +304,13 @@ module Betfair
 
       # Handy constants
       NAMESPACES = {
-        aus:    'http://www.betfair.com/exchange/v3/BFExchangeService/AUS',
-        global: 'https://www.betfair.com/global/v3/BFGlobalService',
-        uk:     'http://www.betfair.com/exchange/v3/BFExchangeService/UK' }
+        :aus    => 'http://www.betfair.com/exchange/v3/BFExchangeService/AUS',
+        :global => 'https://www.betfair.com/global/v3/BFGlobalService',
+        :uk     => 'http://www.betfair.com/exchange/v3/BFExchangeService/UK' }
       ENDPOINTS  = {
-        aus:    'https://api-au.betfair.com/exchange/v5/BFExchangeService',
-        global: 'https://api.betfair.com/global/v3/BFGlobalService',
-        uk:     'https://api.betfair.com/exchange/v5/BFExchangeService' }
+        :aus    => 'https://api-au.betfair.com/exchange/v5/BFExchangeService',
+        :global => 'https://api.betfair.com/global/v3/BFGlobalService',
+        :uk     => 'https://api.betfair.com/exchange/v5/BFExchangeService' }
 
 
       # Factory methods for building clients to the different endpoints
@@ -345,15 +352,15 @@ module Betfair
       # For those requests which take place in the context of a session,
       # this method constructs the correct header and delegates to #request.
       def session_request( session_token, method, result_field, body = {})
-        header_body = { header: api_request_header(session_token) }
+        header_body = { :header => api_request_header(session_token) }
         full_body = header_body.merge( body )
 
         request method, result_field, full_body
       end
 
 
-      def api_request_header(session_token)
-        { client_stamp: 0, session_token: session_token }
+      def api_request_header(session_token)      
+        { :client_stamp => 0, :session_token => session_token }
       end
       protected :api_request_header
 
@@ -366,7 +373,7 @@ module Betfair
     module ErrorPresenter
 
       def success?
-        self[:error_code] == 'OK'
+        self[:error_code] == "OK"
       end
 
 
@@ -403,26 +410,26 @@ module Betfair
       markets.each do |piece|
         piece.gsub! "\0", '\:'
         foo = piece.split('~')
-        market_hash[foo[0].to_i] = {
-          market_id:            foo[0].to_i,
-          market_name:          foo[1].to_s,
-          market_type:          foo[2].to_s,
-          market_status:        foo[3].to_s,
+        market_hash[foo[0].to_i] = { 
+          :market_id            => foo[0].to_i,
+          :market_name          => foo[1].to_s,
+          :market_type          => foo[2].to_s,
+          :market_status        => foo[3].to_s,
           # bf returns in this case time in Epoch, but in milliseconds
-          event_date:           Time.at(foo[4].to_i/1000),
-          menu_path:            foo[5].to_s,
-          event_hierarchy:      foo[6].to_s,
-          bet_delay:            foo[7].to_s,
-          exchange_id:          foo[8].to_i,
-          iso3_country_code:    foo[9].to_s,
-          # bf returns in this case time in Epoch, but in milliseconds
-          last_refresh:         Time.at(foo[10].to_i/1000),
-          number_of_runners:    foo[11].to_i,
-          number_of_winners:    foo[12].to_i,
-          total_amount_matched: foo[13].to_f,
-          bsp_market:           foo[14] == 'Y' ? true : false,
-          turning_in_play:      foo[15] == 'Y' ? true : false
-        }
+          :event_date           => Time.at(foo[4].to_i/1000),
+          :menu_path            => foo[5].to_s,
+          :event_hierarchy      => foo[6].to_s,
+          :bet_delay            => foo[7].to_s,
+          :exchange_id          => foo[8].to_i,
+          :iso3_country_code    => foo[9].to_s,
+          # bf returns in this case time in Epoch, but in milliseconds 
+          :last_refresh         => Time.at(foo[10].to_i/1000),
+          :number_of_selections    => foo[11].to_i,
+          :number_of_winners    => foo[12].to_i,
+          :total_amount_matched => foo[13].to_f,
+          :bsp_market           => foo[14] == 'Y' ? true : false,
+          :turning_in_play      => foo[15] == 'Y' ? true : false
+        } 
       end
       return market_hash
     end
@@ -441,25 +448,9 @@ module Betfair
           event_date        = Time.at(bar[4].to_i/1000).utc
           last_refresh      = Time.at(bar[10].to_i/1000).utc
           
-          doh = {
-            market_id:            bar[0].to_i,
-            market_name:          bar[1],
-            market_type:          bar[2],
-            market_status:        bar[3],
-            event_date:           event_date,
-            menu_path:            bar[5],
-            event_heirachy:       bar[6],
-            bet_delay:            bar[7].to_i,
-            exchange_id:          bar[8].to_i,
-            iso3_country_code:    bar[9],
-            last_refresh:         last_refresh,
-            number_of_runners:    bar[11].to_i,
-            number_of_winners:    bar[12].to_i,
-            total_amount_matched: bar[13].to_f,
-            bsp_market:           bsp_market,
-            turning_in_play:      turning_in_play
-          }
-                  
+          doh = { market_id: bar[0].to_i, market_name: bar[1], market_type: bar[2], market_status: bar[3], event_date: event_date, menu_path: bar[5], event_heirachy: bar[6], 
+                  bet_delay: bar[7].to_i, exchange_id: bar[8].to_i, iso3_country_code: bar[9], last_refresh: last_refresh, number_of_selections: bar[11].to_i, number_of_winners: bar[12].to_i, 
+                  total_amount_matched: bar[13].to_f, bsp_market: bsp_market, turning_in_play: turning_in_play }        
           foo << doh if !doh[:market_name].nil?
         end
       end
@@ -467,24 +458,24 @@ module Betfair
     end
 
     def market_info(details)
-      { exchange_id:      nil,
-        market_type_id:   nil,
-        market_matched:   nil,
-        menu_path:        details[:menu_path],
-        market_id:        details[:market_id],
-        market_name:      details[:name],
-        market_type_name: details[:menu_path].to_s.split('\\')[1]
+      { :exchange_id => nil,
+        :market_type_id => nil,
+        :market_matched => nil,
+        :menu_path => details[:menu_path], 
+        :market_id => details[:market_id], 
+        :market_name => details[:name],
+        :market_type_name => details[:menu_path].to_s.split('\\')[1]
       }
     end
 
     def details(market)
-      runners = []
-      market[:runners][:runner].each { |runner| runners << { runner_id: runner[:selection_id].to_i, runner_name: runner[:name] } }
-      return { market_id: market[:market_id].to_i, market_type_id: market[:event_type_id].to_i, runners: runners }
+      selections = []
+      market[:runners][:runner].each { |selection| selections << { :selection_id => selection[:selection_id].to_i, :selection_name => selection[:name] } }
+      return { :market_id => market[:market_id].to_i, :market_type_id => market[:event_type_id].to_i, :selection => selections }
     end
 
     def prices(prices)
-      price_hash = {}
+      price_hash = {}					
       prices.gsub! '\:', "\0"
       pieces = prices.split ":"
       pieces.each do |piece|
@@ -495,24 +486,24 @@ module Betfair
     end
     
     def combine(market, prices)
-      market = details(market)
+      market = details(market)            
       prices = prices(prices)
-      market[:runners].each do |runner|
-        runner.merge!( { market_id: market[:market_id] } )
-        runner.merge!( { market_type_id: market[:market_type_id] } )
-        runner.merge!(price_string(prices[runner[:runner_id]]))
+      market[:selection].each do |selection|
+        selection.merge!( { :market_id => market[:market_id] } )
+        selection.merge!( { :market_type_id => market[:market_type_id] } )
+        selection.merge!(price_string(prices[selection[:selection_id]]))
       end
     end
 
     ##
     #
     # Complete representation of market price data response, 
-    # except "removed runners" which is returned as raw string. 
+    # except "removed selection" which is returned as raw string. 
     #
     ##
     def prices_complete(prices)
       aux_hash   = {}
-      price_hash = {}
+      price_hash = {}         
 
       prices.gsub! '\:', "\0"
       pieces = prices.split ":"
@@ -521,21 +512,21 @@ module Betfair
       aux = pieces.first
       aux.gsub! "\0", '\:'
       foo = aux.split('~')
-      aux_hash =   {
-        market_id:                      foo[0].to_i,
-        currency:                       foo[1].to_s,
-        market_status:                  foo[2].to_s,
-        in_play_delay:                  foo[3].to_i,
-        number_of_winners:              foo[4].to_i,
-        market_information:             foo[5].to_s,
-        discount_allowed:               foo[6] == 'true' ? true : false,
-        market_base_rate:               foo[7].to_s,
-        refresh_time_in_milliseconds:   foo[8].to_i,
-        removed_runners:                foo[9].to_s,
-        bsp_market:                     foo[10] == 'Y' ? true : false
+      aux_hash =   {  
+        :market_id                      => foo[0].to_i,
+        :currency                       => foo[1].to_s,
+        :market_status                  => foo[2].to_s,
+        :in_play_delay                  => foo[3].to_i,
+        :number_of_winners              => foo[4].to_i,
+        :market_information             => foo[5].to_s,
+        :discount_allowed               => foo[6] == 'true' ? true : false,
+        :market_base_rate               => foo[7].to_s,
+        :refresh_time_in_milliseconds   => foo[8].to_i,
+        :removed_selections             => foo[9].to_s,
+        :bsp_market                     => foo[10] == 'Y' ? true : false
       }
 
-      # now iterating over the prices excluding the first piece that we already parsed above
+      # now iterating over the prices excluding the first piece that we already parsed above 
       pieces[1..-1].each do |piece|
         piece.gsub! "\0", '\:'
         
@@ -543,17 +534,17 @@ module Betfair
         # using the selection_id as hash key
         price_hash_key = bar[0].to_i
 
-        price_hash[price_hash_key] = {
-          selection_id:                 bar[0].to_i,
-          order_index:                  bar[1].to_i,
-          total_amount_matched:         bar[2].to_f,
-          last_price_matched:           bar[3].to_f,
-          handicap:                     bar[4].to_f,
-          reduction_factor:             bar[5].to_f,
-          vacant:                       bar[6] == 'true' ? true : false,
-          far_sp_price:                 bar[7].to_f,
-          near_sp_price:                bar[8].to_f,
-          actual_sp_price:              bar[9].to_f
+        price_hash[price_hash_key] = {  
+          :selection_id                 => bar[0].to_i,
+          :order_index                  => bar[1].to_i,
+          :total_amount_matched         => bar[2].to_f,
+          :last_price_matched           => bar[3].to_f,
+          :handicap                     => bar[4].to_f,
+          :reduction_factor             => bar[5].to_f,
+          :vacant                       => bar[6] == 'true' ? true : false,
+          :far_sp_price                 => bar[7].to_f,
+          :near_sp_price                => bar[8].to_f,
+          :actual_sp_price              => bar[9].to_f                           
         }
 
         # merge lay and back prices into price_hash
@@ -569,43 +560,29 @@ module Betfair
       string_raw = string
       string = string.split('|')
 
-      price = {
-        prices_string:    nil,
-        runner_matched:   0,
-        last_back_price:  0,
-        wom:              0,
-        b1:               0,
-        b1_available:     0,
-        b2:               0,
-        b2_available:     0,
-        b3:               0,
-        b3_available:     0,
-        l1:               0,
-        l1_available:     0,
-        l2:               0,
-        l2_available:     0,
-        l3:               0,
-        l3_available:     0
+      price = { :prices_string => nil, :selection_matched => 0, :last_back_price => 0, :wom => 0, 
+        :b1 => 0, :b1_available => 0, :b2 => 0, :b2_available => 0, :b3 => 0, :b3_available => 0,
+        :l1 => 0, :l1_available => 0, :l2 => 0, :l2_available => 0, :l3 => 0, :l3_available => 0 
       }    			
 
       if !string[0].nil? and !prices_only
-        str = string[0].split('~')
+        str = string[0].split('~')	
         price[:prices_string] = string_raw
-        price[:runner_matched] = str[2].to_f
+        price[:selection_matched] = str[2].to_f
         price[:last_back_price]   = str[3].to_f
       end
 
       # Get the b prices (which are actually the l prices)
       if !string[1].nil?
-        b = string[1].split('~')
+        b = string[1].split('~')	
         price[:b1]             = b[0].to_f if !b[0].nil?
         price[:b1_available]   = b[1].to_f if !b[1].nil?
         price[:b2]             = b[4].to_f if !b[5].nil?
         price[:b2_available]   = b[5].to_f if !b[6].nil?
         price[:b3]             = b[8].to_f if !b[8].nil?
-        price[:b3_available]   = b[9].to_f if !b[9].nil?
+        price[:b3_available]   = b[9].to_f if !b[9].nil?  				 				
         combined_b = price[:b1_available] + price[:b2_available] + price[:b3_available]
-      end
+      end				
 
       # Get the l prices (which are actually the l prices)
       if !string[2].nil?
@@ -615,16 +592,16 @@ module Betfair
         price[:l2]             = l[4].to_f if !l[4].nil?
         price[:l2_available]   = l[5].to_f if !l[5].nil?
         price[:l3]             = l[8].to_f if !l[8].nil?
-        price[:l3_available]   = l[9].to_f if !l[9].nil?
+        price[:l3_available]   = l[9].to_f if !l[9].nil?  				  				
         combined_l = price[:l1_available] + price[:l2_available] + price[:l3_available]
       end			
 
       price[:wom] = combined_b / ( combined_b + combined_l ) unless combined_b.nil? or combined_l.nil?
 
-      return price
+      return price			  		
     end
-    
-    def odds_table
+
+		def odds_table
       odds_table = []
       (1.01..1.99).step(0.01).each  { |i| odds_table << i.round(2) }
       (2..2.98).step(0.02).each     { |i| odds_table << i.round(2) }