lloydpick-honstats 0.0.6

data/README

@@ -0,0 +1,120 @@
+Returns an object which contains all the player statistics avaialable for
+the user specified. You must specify a username rather than an account ID
+for this to function correctly.
+
+=== Examples
+
+This will return all the player statistics for the player named "Limi"
+
+    require 'honstats'
+    honstats = HonStats::API.new
+    char = honstats.get_character("Limi")
+    char.class.to_s
+    => HonStats::Classes::Character
+
+If you were to call <tt>to_s</tt> or <tt>to_i</tt> to the <tt>char</tt> variable
+you would get the character account name and account id respectively.
+
+From there you can access inidividual statistics by sections...
+
+    char.account.inspect
+    char.building.inspect
+    char.creep.inspect
+    char.hero.inspect
+    char.gamestats.inspect
+    char.lastmatch.inspect
+    char.neutral.inspect
+
+...or by querying them directly...
+
+    char.hero.kills
+    => 304
+    char.creep.kills
+    => 5329
+
+Each individual section holds different statistics...
+
+Account
+    :id                             Account ID number
+    :name                           Account name
+    :created_at                     Account creation date
+    :last_login                     Account last login date
+    :last_activity                  Account last activity date
+
+Building
+    :damage                         Damage done to buildings
+    :xp                             XP gained from raizing buildings (currently 0)
+    :raized                         Number of buildings raized
+    :gold                           Gold earned from buildings raized
+
+Clan
+    :id                             Clan ID number
+    :name                           Clan name
+    :tag                            Clan tag
+    :rank                           Clan rank
+    :icon                           Clan logo?
+
+Creep
+    :kills                          Number of creep kills
+    :damage                         Damage done to creep
+    :xp                             XP gained from killing creeps
+    :gold                           Gold earned from killing creeps
+    :denies                         Number of denied creeps
+    :denied_xp                      XP denied due to denied creeps
+    :kills_per_minute               Number of creep kills per minute
+    :xp_per_minute                  Amount of XP earned per minute from creep kills
+    :denies_per_minute              Number of denied creep kills per minute
+    :denied_xp_per_minute           Amount of XP denied per minute from creep denies
+
+Hero
+    :kills                          Number of hero kills
+    :damage                         Damage done to enemy heroes
+    :xp                             XP gained from killing heroes
+    :gold                           Gold earned from killing heroes
+    :assists                        Number of hero kills assisted in
+    :deaths                         Number of hero deaths
+    :gold_lost                      Amount of gold lost due to hero deaths
+    :seconds_dead                   Number of seconds spent dead
+    :buybacks                       Number of hero buybacks
+    :kills_per_minute               Number of hero kills per minute
+    :xp_per_minute                  XP gained per minute from hero kills
+    :time_dead_percentage           Percentage of the time spent dead
+    :assists_per_minute             Number of hero kill assists per minute
+    :kill_death_ratio               Hero kill to death ratio
+
+GameStats
+    :wins                           Number of games won
+    :losses                         Number of games lost
+    :win_percentage                 Percentage of games won
+    :disconnects                    Number of game disconnects
+    :time_played                    Time played in seconds
+    :level                          Account Level
+    :gold_earned                    Gold earned overall
+    :gold_spent                     Gold spent overall
+    :xp_earned                      XP earned overall
+    :actions_made                   Number of actions made
+    :average_score                  ?? - Unknown
+    :xp_earned_per_minute           XP earned per minute
+    :gold_earned_per_minute         Gold earned per minute
+    :actions_per_minute             Number of actions per minute
+    :average_game_length_in_seconds Average Number of seconds per game
+    :played                         Number of games played
+    :average_kills_per_game         Average number of hero kills per game
+    :average_deaths_per_game        Average number of hero deaths per game
+    :average_assists_per_game       Average number of hero assists per game
+    :disconnect_percentage          Percentage of number of games disconnected
+    :average_xp_earned_per_game     Average amount of XP earned per game
+    :average_creep_kills_per_game   Average number of creep kills per game
+    :average_creep_denies_per_game  Average number of creep denies per game
+
+Last_Match
+    :id                             Game ID of the last match
+    :date                           Date of the last match played
+
+Neutral
+    :kills                          Number of neutral creep kills
+    :damage                         Damage done to neutral creeps
+    :xp                             XP earned from neutral creep kills
+    :gold                           Gold earned from neutral creep kills
+    :kills_per_minute               Number of neutral creep kills per minute
+    :xp_per_minute                  XP earned per minute from neutral creep kills

data/lib/honstats/ban.rb

@@ -0,0 +1,37 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+module HonStats
+  module Classes
+    module Banlist
+      class Banlist
+        attr_reader :id, :bans
+        alias_method :to_i, :id
+
+        def initialize(data)
+          if bans[0]
+            bans = []
+            data.each do |ban|
+              bans << Ban.new(ban)
+            end
+            @bans =    bans
+            @id =      HonStats::API.get_data("account_id", bans[0]).to_i
+          end
+        end
+
+      end
+
+      class Ban
+        attr_reader :account_id, :banned_id, :nickname, :reason, :banned_at
+
+        def initialize(data)
+          @account_id =     HonStats::API.get_data("account_id", data).to_i
+          @banned_id =      HonStats::API.get_data("banned_id", data).to_i
+          @nickname =       HonStats::API.get_data("nickname", data).to_s
+#  				@reason =         HonStats::API.get_data("reason", data).to_s
+#	  			@banned_at =      Time.parse(HonStats::API.get_data("ban_date", data).to_s)
+        end
+      end
+    end
+  end
+end

data/lib/honstats/character.rb

@@ -0,0 +1,217 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+module HonStats
+  module Classes
+    class Character
+      attr_reader :account_id, :character_name, :account, :building, :clan,
+                  :creep, :gamestats, :hero, :last_match, :neutral
+
+      alias_method :to_s, :character_name
+      alias_method :to_i, :account_id
+
+      def initialize(data, api = nil)
+        @api = api
+
+        if data.is_a?(String)
+          output = data.split(";")
+
+          split = output[3].split("\"")
+          @account_id = split[1].to_i
+
+        elsif data.is_a?(Integer)
+          @account_id = data
+        end
+
+        url = base + @api.requester_file
+        data = Net::HTTP.post_form(URI.parse(url), {"f"=>"get_all_stats", "account_id[0]"=>"#{@account_id}"})
+        if data.class.to_s == "Net::HTTPOK"
+          data = data.body
+          @account_id =           HonStats::API.get_data("account_id", data).to_i
+          @character_name =       HonStats::API.get_data("nickname", data).to_s
+          @account =              Account.new(data)
+          @building =             Building.new(data)
+          @clan =                 SimpleClan.new(data)
+          @creep =                Creep.new(data)
+          @hero =                 Hero.new(data)
+          @gamestats =            GameStats.new(data, @hero, @creep)
+          @last_match =           LastMatch.new(data)
+          @neutral =              Neutral.new(data)
+        end
+      end
+
+      protected
+
+      # Return the base_url of the API if available, otherwise send back the default
+			def base
+				if @api
+					return @api.base_url
+				else
+					return 'http://masterserver.hon.s2games.com/'
+				end
+			end
+
+    end
+
+    # Consilidated Account stats
+		class Account
+			attr_reader :id, :name, :created_at, :last_login, :last_activity
+
+			def initialize(data)
+        @id =             HonStats::API.get_data("account_id", data).to_i
+        @name =           HonStats::API.get_data("nickname", data).to_s
+				@created_at =     Time.parse(HonStats::API.get_data("create_date", data).to_s)
+        @last_login =     Time.parse(HonStats::API.get_data("last_login", data).to_s)
+        @last_activity =  Time.parse(HonStats::API.get_data("last_activity", data).to_s)
+			end
+		end
+
+    # Consilidated game stats
+		class GameStats
+			attr_reader :wins, :losses, :win_percentage, :disconnects, :time_played,
+                  :level, :gold_earned, :gold_spent, :xp_earned, :actions_made,
+                  :average_score, :xp_earned_per_minute, :gold_earned_per_minute,
+                  :actions_per_minute, :average_game_length_in_seconds, :played,
+                  :average_kills_per_game, :average_deaths_per_game,
+                  :average_assists_per_game, :disconnect_percentage,
+                  :average_xp_earned_per_game, :average_creep_kills_per_game,
+                  :average_creep_denies_per_game
+
+			def initialize(data, hero_stats, creep_stats)
+				@wins =           HonStats::API.get_data("acc_wins", data).to_i
+        @losses =         HonStats::API.get_data("acc_losses", data).to_i
+        @disconnects =    HonStats::API.get_data("acc_discos", data).to_i
+        @played =         @wins + @losses
+        @disconnect_percentage = "%.02f" % ((@disconnects.to_f / @played) * 100)
+        @win_percentage = "%.02f" % ((@wins.to_f / @played) * 100)
+        @time_played =    HonStats::API.get_data("acc_secs", data).to_i
+        @level =          HonStats::API.get_data("level", data).to_i
+        @gold_earned =    HonStats::API.get_data("acc_gold", data).to_i
+        @gold_spent =     HonStats::API.get_data("acc_gold_spent", data).to_i
+        @xp_earned =      HonStats::API.get_data("acc_exp", data).to_i
+        @actions_made =   HonStats::API.get_data("acc_actions", data).to_i
+        @average_score =  HonStats::API.get_data("acc_avg_score", data).to_f
+        
+        if @time_played > 0
+          minutes_played = @time_played / 60
+          @xp_earned_per_minute = "%.02f" % (@xp_earned.to_f / minutes_played.to_f)
+          @gold_earned_per_minute = "%.02f" % (@gold_earned.to_f / minutes_played.to_f)
+          @actions_per_minute = "%.02f" % (@actions_made.to_f / minutes_played.to_f)
+
+          @average_game_length_in_seconds = (@time_played.to_f / @played).to_i
+
+          @average_kills_per_game = "%.02f" % (hero_stats.kills.to_f / @played)
+          @average_deaths_per_game = "%.02f" % (hero_stats.deaths.to_f / @played)
+          @average_assists_per_game = "%.02f" % (hero_stats.assists.to_f / @played)
+
+          @average_xp_earned_per_game = "%.02f" % (@xp_earned.to_f / @played)
+
+          @average_creep_kills_per_game = "%.02f" % (creep_stats.kills.to_f / @played)
+          @average_creep_denies_per_game = "%.02f" % (creep_stats.denies.to_f / @played)
+        end
+			end
+		end
+
+    # Consilidated clan info
+    class SimpleClan
+      attr_reader :id, :name, :tag, :rank, :icon
+
+      def initialize(data)
+        @id =       HonStats::API.get_data("clan_id", data).to_i
+        @name =     HonStats::API.get_data("name", data).to_s
+        @tag =      HonStats::API.get_data("tag", data).to_s
+        @rank =     HonStats::API.get_data("rank", data).to_s
+        @icon =     HonStats::API.get_data("file_name", data).to_s
+      end
+    end
+
+    # Consilidated creep stats
+		class Creep
+			attr_reader :kills, :damage, :xp, :gold, :denies, :denied_xp, :kills_per_minute,
+                  :xp_per_minute, :denies_per_minute, :denied_xp_per_minute
+
+			def initialize(data)
+				@kills =     HonStats::API.get_data("acc_teamcreepkills", data).to_i
+        @damage =    HonStats::API.get_data("acc_teamcreepdmg", data).to_i
+        @xp =        HonStats::API.get_data("acc_teamcreepexp", data).to_i
+        @gold =      HonStats::API.get_data("acc_teamcreepgold", data).to_i
+        @denies =    HonStats::API.get_data("acc_denies", data).to_i
+        @denied_xp = HonStats::API.get_data("acc_exp_denied", data).to_i
+
+        minutes_played = HonStats::API.get_data("acc_secs", data).to_i / 60
+        @kills_per_minute = "%.02f" % (@kills.to_f / minutes_played.to_f)
+        @xp_per_minute = "%.02f" % (@xp.to_f / minutes_played.to_f)
+        @denies_per_minute = "%.02f" % (@denies.to_f / minutes_played.to_f)
+        @denied_xp_per_minute = "%.02f" % (@denied_xp.to_f / minutes_played.to_f)
+			end
+		end
+
+    # Consilidated neutral creep stats
+		class Neutral
+			attr_reader :kills, :damage, :xp, :gold, :kills_per_minute, :xp_per_minute
+
+			def initialize(data)
+				@kills =  HonStats::API.get_data("acc_neutralcreepkills", data).to_i
+        @damage = HonStats::API.get_data("acc_neutralcreepdmg", data).to_i
+        @xp =     HonStats::API.get_data("acc_neutralcreepexp", data).to_i
+        @gold =   HonStats::API.get_data("acc_neutralcreepgold", data).to_i
+
+        minutes_played = HonStats::API.get_data("acc_secs", data).to_i / 60
+        @kills_per_minute = "%.02f" % (@kills.to_f / minutes_played.to_f)
+        @xp_per_minute = "%.02f" % (@xp.to_f / minutes_played.to_f)
+			end
+		end
+
+    # Consilidated hero stats
+		class Hero
+			attr_reader :kills, :damage, :xp, :gold, :assists, :deaths, :gold_lost, 
+                  :seconds_dead, :buybacks, :kills_per_minute, :xp_per_minute,
+                  :time_dead_percentage, :assists_per_minute, :kill_death_ratio
+
+			def initialize(data)
+				@kills =        HonStats::API.get_data("acc_herokills", data).to_i
+        @damage =       HonStats::API.get_data("acc_herodmg", data).to_i
+        @xp =           HonStats::API.get_data("acc_heroexp", data).to_i
+        @gold =         HonStats::API.get_data("acc_herokillsgold", data).to_i
+        @assists =      HonStats::API.get_data("acc_heroassists", data).to_i
+        @deaths =       HonStats::API.get_data("acc_deaths", data).to_i
+        @gold_lost =    HonStats::API.get_data("acc_goldlost2death", data).to_i
+        @seconds_dead = HonStats::API.get_data("acc_secs_dead", data).to_i
+        @buybacks =     HonStats::API.get_data("acc_buybacks", data).to_i
+
+        seconds_played = HonStats::API.get_data("acc_secs", data).to_i
+        minutes_played = seconds_played / 60
+        @kills_per_minute = "%.02f" % (@kills.to_f / minutes_played.to_f)
+        @assists_per_minute = "%.02f" % (@assists.to_f / minutes_played.to_f)
+        @xp_per_minute = "%.02f" % (@xp.to_f / minutes_played.to_f)
+        @time_dead_percentage = "%.02f" % ((@seconds_dead.to_f / seconds_played.to_f) * 100)
+        @kill_death_ratio = "%.02f" % (@kills.to_f / @deaths.to_f)
+			end
+		end
+
+    # Consilidated neutral creep stats
+		class Building
+			attr_reader :damage, :xp, :raized, :gold
+
+			def initialize(data)
+				@damage = HonStats::API.get_data("acc_bdmg", data).to_i
+        @xp =     HonStats::API.get_data("acc_bdmgexp", data).to_i
+        @raized = HonStats::API.get_data("acc_razed", data).to_i
+        @gold =   HonStats::API.get_data("acc_bgold", data).to_i
+			end
+		end
+
+    # Consilidated last match stats
+		class LastMatch
+			attr_reader :id, :date
+
+			def initialize(data)
+				@id =   HonStats::API.get_data("match_id", data).to_i
+        @date = Time.parse(HonStats::API.get_data("mdt", data).to_s)
+			end
+		end
+
+    class	SearchCharacter < Character
+		end
+  end
+end

data/lib/honstats/game.rb

@@ -0,0 +1,71 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+module HonStats
+  module Classes
+    class Game
+      attr_reader :server_id, :session, :name, :class, :private, :modes,
+                  :max_players, :tier, :official, :ip, :port, :players, :state,
+                  :last_update, :location
+
+      alias_method :to_i, :server_id
+      alias_method :to_s, :name
+
+      def initialize(data)
+        @server_id =    HonStats::API.get_data("server_id", data).to_i
+        @session =      HonStats::API.get_data("session", data).to_s
+        @name =         HonStats::API.get_data("mname", data).to_s
+        @class =        HonStats::API.get_data("class", data).to_i
+        @private =      HonStats::API.get_data("private", data).to_i
+        @max_players =  (HonStats::API.get_data("max_players", data).to_i * 2)
+        @tier =         HonStats::API.get_data("tier", data).to_i
+        @official =     HonStats::API.get_data("officl", data).to_i
+        @ip =           HonStats::API.get_data("ip", data).to_s
+        @port =         HonStats::API.get_data("port", data).to_i
+        @players =      HonStats::API.get_data("num_conn", data).to_i
+        @state =        HonStats::API.get_data("c_state", data).to_i
+        @last_update =  Time.parse(HonStats::API.get_data("last_upd", data).to_s)
+        @location =     HonStats::API.get_data("location", data).to_s
+        @modes =        Modes.new(data)
+      end
+
+    end
+
+    # Consilidated modes
+		class Modes
+			attr_reader :normal_mode, :single_draft, :random_draft, :death_match,
+                  :league, :no_repick, :no_agility, :item_drop, :no_respawn_timer,
+                  :no_swap, :no_intelligence, :alternate_picking, :no_strength,
+                  :no_powerups, :duplicate_hero, :all_pick, :all_random,
+                  :easy_mode, :rs, :no_leavers, :reverse_hero, :veto,
+                  :shuffle_players
+
+			def initialize(data)
+        @normal_mode =       HonStats::API.get_data("nm", data).to_i
+        @single_draft =      HonStats::API.get_data("sd", data).to_i
+        @random_draft =      HonStats::API.get_data("rd", data).to_i
+        @death_match =       HonStats::API.get_data("dm", data).to_i
+        @league =            HonStats::API.get_data("league", data).to_i
+        @no_repick =         HonStats::API.get_data("no_repick", data).to_i
+        @no_agility =        HonStats::API.get_data("no_agi", data).to_i
+        @item_drop =         HonStats::API.get_data("drp_itm", data).to_i
+        @no_respawn_timer =  HonStats::API.get_data("no_timer", data).to_i
+        @no_swapping =       HonStats::API.get_data("no_swap", data).to_i
+        @no_intelligence =   HonStats::API.get_data("no_int", data).to_i
+        @alternate_picking = HonStats::API.get_data("alt_pick", data).to_i
+        @no_strength =       HonStats::API.get_data("no_str", data).to_i
+        @no_powerups =       HonStats::API.get_data("no_pups", data).to_i
+        @duplicate_hero =    HonStats::API.get_data("dup_h", data).to_i
+        @all_pick =          HonStats::API.get_data("ap", data).to_i
+        @all_random =        HonStats::API.get_data("ar", data).to_i
+        @easy_mode =         HonStats::API.get_data("em", data).to_i
+        @rs =                HonStats::API.get_data("rs", data).to_i
+        @no_leavers =        HonStats::API.get_data("nl", data).to_i
+        @reverse_hero =      HonStats::API.get_data("rev_hs", data).to_i
+        @veto =              HonStats::API.get_data("veto", data).to_i
+        @shuffle_players =   HonStats::API.get_data("shuf", data).to_i
+			end
+		end
+
+  end
+end

data/lib/honstats/ignore.rb

@@ -0,0 +1,37 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+module HonStats
+  module Classes
+    module Ignorelist
+      class Ignorelist
+        attr_reader :id, :ignores
+        alias_method :to_i, :id
+
+        def initialize(data)
+          if data[0]
+            ignores = []
+            data.each do |ignore|
+              ignores << Ignore.new(ignore)
+            end
+            @ignores = ignores
+            @id =      HonStats::API.get_data("account_id", data[0]).to_i
+          end
+        end
+
+      end
+
+      class Ignore
+        attr_reader :account_id, :ignored_id, :nickname
+
+        def initialize(data)
+          @account_id =     HonStats::API.get_data("account_id", data).to_i
+          @ignored_id =     HonStats::API.get_data("ignored_id", data).to_i
+          @nickname =       HonStats::API.get_data("nickname", data).to_s
+#  				@reason =         HonStats::API.get_data("reason", data).to_s
+#	  			@ignored_at =     Time.parse(HonStats::API.get_data("ignore_date", data).to_s)
+        end
+      end
+    end
+  end
+end

data/lib/honstats/server.rb

@@ -0,0 +1,20 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+module HonStats
+  module Classes
+    class Server
+      attr_reader :id, :session, :ip, :port
+
+      alias_method :to_i, :id
+
+      def initialize(data)
+        @id =        HonStats::API.get_data("server_id", data).to_i
+        @session =   HonStats::API.get_data("session", data).to_s
+        @ip =        HonStats::API.get_data("ip", data).to_s
+        @port =      HonStats::API.get_data("port", data).to_s
+      end
+
+    end
+  end
+end

data/lib/honstats.rb

@@ -0,0 +1,241 @@
+#
+# honstats - Heroes of Newerth Statistics Ruby Library
+# Written by Lloyd Pick
+# http://gibhub.com/lloydpick
+# May not be used for commercial applications without prior concent
+#
+
+# usual requirements
+require 'rubygems'
+require 'activesupport'
+require 'net/http'
+require 'uri'
+require 'fileutils'
+
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'honstats/character.rb'
+require 'honstats/server.rb'
+require 'honstats/game.rb'
+require 'honstats/clan.rb'
+require 'honstats/ban.rb'
+require 'honstats/ignore.rb'
+
+module HonStats
+  class API
+    VERSION = '0.0.1'
+
+    @@stats_url_base = "masterserver.hon.s2games.com/"
+    @@requester_file = "client_requester.php"
+
+    @@search_types = {
+			:character => 'character'
+		}
+
+    cattr_accessor :stats_base_url, :requester_file
+    attr_accessor :character_name, :cookie
+
+    # Constructor
+		# Accepts an optional hash of parameters to create defaults for all API requests
+		# * options (Hash) - Hash used to set default values for all API requests
+    def initialize(options = {})
+      @character_name = options[:character_name]
+      @debug = options[:debug] || false
+    end
+
+    # As more API's are created, we might need a place to search for items/guilds/players etc
+    # but for now, it's just for players
+    def search(string, options = {})
+      
+			if (string.is_a?(Hash))
+				options = string
+			else
+				options.merge!(:search => string)
+			end
+
+      options = merge_defaults(options)
+
+			if options[:search].nil? || options[:search].empty?
+				raise "no search string"
+			end
+
+			if !@@search_types.has_value?(options[:type])
+				raise "invalid search type"
+			end
+
+      results = []
+
+      case options[:type]
+        when @@search_types[:character]
+          url = self.base_url + @@requester_file
+          character_names = Net::HTTP.post_form(URI.parse(url), {"f"=>"autocompleteNicks", "nickname"=>"#{options[:search]}"})
+          character_names = character_names.body.split('"')
+          character_names.each_index do |d|
+            if character_names[d].include?(";")
+              character_names.delete_at(d)
+            end
+          end
+          character_names.delete_at(0)
+
+          character_names.each do |character|
+            sheet = self.get_character(character)
+            if sheet.account.id > 0
+              results << self.get_character(character)
+            end
+          end
+      end
+
+      return results
+      
+    end
+
+
+    def search_characters(name, options = {})
+			if (name.is_a?(Hash))
+				options = name
+			else
+				options.merge!(:search => name)
+			end
+
+			options.merge!(:type => @@search_types[:character])
+			return search(options)
+		end
+
+
+    def get_character(name = @character_name, options = {})
+      if (name.is_a?(Hash))
+				options = name
+			else
+				options.merge!(:character_name => name)
+				options = {:character_name => @character_name}.merge(options) if (!@character_name.nil?)
+			end
+
+      options = merge_defaults(options)
+
+      if options[:character_name].nil? || options[:character_name] == ""
+				raise "characer name not specified"
+      end
+
+      if options[:character_name].is_a?(String)
+        url = self.base_url + @@requester_file
+        character_account_id = Net::HTTP.post_form(URI.parse(url), {"f"=>"nick2id", "nickname[0]"=>"#{options[:character_name]}"})
+        character_account_id = character_account_id.body
+      elsif options[:character_name].is_a?(Integer)
+        character_account_id = options[:character_name]
+      end
+      return HonStats::Classes::Character.new(character_account_id, self)
+    end
+
+    def get_servers(options = { :gametype => 90 })
+      options = merge_defaults(options)
+      options[:type] = HonStats::Classes::Server
+      return server_browser(options)
+    end
+
+    def get_games(options = { :gametype => 10 })
+      options = merge_defaults(options)
+      options[:type] = HonStats::Classes::Game
+      return server_browser(options)
+    end
+
+    def get_active_games(options = { :gametype => 32 })
+      options = merge_defaults(options)
+      options[:type] = HonStats::Classes::Game
+      return server_browser(options)
+    end
+
+    def server_browser(options = {})
+      options = merge_defaults(options)
+      if @cookie
+        url = self.base_url + @@requester_file
+        data = Net::HTTP.post_form(URI.parse(url), {"f"=>"server_list", "gametype"=>"#{options[:gametype]}", "cookie"=>@cookie})
+        data = data.body.split('s:9:"server_id";s:')
+        data.delete_at(0)
+        data.map! {|d| 's:9:"server_id";s:' + d }
+        output = []
+        data.each do |d|
+          output << options[:type].new(d)
+        end
+        output
+      else
+        raise "unable to access server browser data without an auth cookie, use login() first"
+      end
+    end
+
+    def get_clan(options = {})
+      options = merge_defaults(options)
+      url = self.base_url + @@requester_file
+      data = Net::HTTP.post_form(URI.parse(url), {"f"=>"clan_list", "clan_id"=>"#{options[:clan_id]}"})
+      data = data.body.split(';a:6:{s:10:"account_id";s:')
+      data.delete_at(0)
+      data.map! {|d| 's:10:"account_id";s:' + d }
+      return HonStats::Classes::Clan.new(data)
+    end
+
+    def get_banlist(options = {})
+      options = merge_defaults(options)
+      url = self.base_url + @@requester_file
+      data = Net::HTTP.post_form(URI.parse(url), {"f"=>"banned_list", "account_id[0]"=>"#{options[:account_id]}"})
+      data = data.body.split(';a:3:{s:10:"account_id";s:')
+      data.delete_at(0)
+      data.map! {|d| 's:10:"account_id";s:' + d }
+      return HonStats::Classes::Banlist::Banlist.new(data)
+    end
+
+    def get_ignorelist(options = {})
+      options = merge_defaults(options)
+      url = self.base_url + @@requester_file
+      data = Net::HTTP.post_form(URI.parse(url), {"f"=>"ignored_list", "account_id[0]"=>"#{options[:account_id]}"})
+      data = data.body.split(';a:3:{s:10:"account_id";s:')
+      data.delete_at(0)
+      data.map! {|d| 's:10:"account_id";s:' + d }
+      return HonStats::Classes::Ignorelist::Ignorelist.new(data)
+    end
+
+    def login(username, password)
+      url = self.base_url + @@requester_file
+      data = Net::HTTP.post_form(URI.parse(url), {"f"=>"auth", "login"=>"#{username}", "password"=>"#{password}"})
+
+      @cookie = HonStats::API.get_data("cookie", data.body).to_s
+    end
+
+    def base_url(options = {})
+			str = ""
+
+			if (options[:secure] == true)
+				str += 'https://'
+			else
+				str += 'http://'
+			end
+
+  		str += @@stats_url_base
+
+			return str
+		end
+
+    # Used to fetch the data from the messy JSON type string sent back from the
+    # server, might be a better/faster/cleaner way of doing this
+    def self.get_data(attribute, data)
+      data = data.split("\"#{attribute}\"")
+      if data[1]
+        data = data[1].split(";")
+        data = data[1].split("\"")
+        data[1]
+      end
+    end
+
+    protected
+
+		# Merge the defaults specified in the constructor with those supplied,
+		# overriding any defaults with those supplied
+		def merge_defaults(options = {})
+			defaults = {}
+			defaults[:debug] = @debug if @debug
+
+			# overwrite defaults with any given options
+			defaults.merge!(options)
+		end
+
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: lloydpick-honstats
+version: !ruby/object:Gem::Version 
+  version: 0.0.6
+platform: ruby
+authors: 
+- Lloyd Pick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-08 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: HonStats is a Ruby library for extracting player statistics and other information from the Heroes of Newerth master server.
+email: lloydpick@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/honstats.rb
+- lib/honstats
+- lib/honstats/character.rb
+- lib/honstats/game.rb
+- lib/honstats/server.rb
+- lib/honstats/ban.rb
+- lib/honstats/ignore.rb
+has_rdoc: false
+homepage: https://github.com/lloydpick/hon-stats
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: HonStats is a Ruby Gem for extracting player statistics and other information from the Heroes of Newerth master server.
+test_files: []
+