wowr 0.1.0

data/lib/wowr.rb

@@ -0,0 +1,350 @@
+# Wowr - Ruby library for the World of Warcraft Armory
+# http://wowr.rubyforge.org/
+
+# written by Ben Humphreys
+# http://benhumphreys.co.uk/
+
+begin
+	require 'lib/hpricot-0.6/hpricot'
+rescue LoadError
+	require 'rubygems'
+	require 'hpricot'
+end
+require 'net/http'
+require 'cgi'
+
+# TODO: what does this do?
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'lib/exceptions'
+require 'lib/extensions'
+require 'lib/classes'
+
+module Wowr
+	class API
+
+		@@armory_url = 'http://www.wowarmory.com/'
+		@@eu_armory_url = 'http://eu.wowarmory.com/'
+		
+		@@character_sheet_url = 'character-sheet.xml'
+		@@character_talents_url = 'character-talents.xml'
+		@@character_skills_url = 'character-skills.xml'
+		@@character_reputation_url = 'character-reputation.xml'
+		
+		@@guild_info_url = 'guild-info.xml'
+		
+		@@search_url = 'search.xml'
+		
+		@@item_info_url = 'item-info.xml'
+		@@item_tooltip_url = 'item-tooltip.xml'
+		
+		@@icon_url = 'http://wowbench.com/images/icons/32x32/'
+		
+		@@arena_team_url = 'team-info.xml'
+		
+		@@max_connection_tries = 10
+
+		# Part of the rails plugin stuff?
+		# @@profession_icons = {
+		# 	:alchemy => "Trade_Alchemy.png",
+		# 	:blacksmithing => "Trade_BlackSmithing.png",
+		# 	:engineering => "Trade_Engineering.png",
+		# 	:enchanting => "Trade_Engraving.png",
+		# 	:jewelcrafting => "INV_Hammer_21.png",
+		# 	:herbalism => "Trade_Herbalism.png",
+		# 	:leatherworking => "Trade_LeatherWorking.png",
+		# 	:mining => "Trade_Mining.png",
+		# 	:tailoring => "Trade_Tailoring.png",
+		# 	:skinning => "INV_Weapon_ShortBlade_01.png"
+		# }
+		
+		@@classes = {
+			1 => 'Warrior',
+			2 => 'Paladin',
+			3 => 'Hunter',
+			4 => 'Rogue',
+			5 => 'Priest',
+			#6 => 'Gold Farmer', # there is no class 6
+			7 => 'Shaman',
+			8 => 'Mage',
+			9 => 'Warlock',
+			#10 => 'Purveyor of Baked Goods', # there is no class 10
+			11 => 'Druid'
+			# 12 => 'Death Knight'?
+		}
+		
+		@@genders = {
+			0 => 'Male',
+			1 => 'Female'
+		}
+		
+		@@races = {
+			1 => 'Human',
+			1 => 'Orc',
+			3 => 'Dwarf',
+			4 => 'Night Elf',
+			5 => 'Undead',
+			6 => 'Tauren',
+			7 => 'Gnome',
+			8 => 'Troll',
+			#9 => 'Pandaren', # there is no race 9
+			10 => 'Blood Elf',
+			11 => 'Draenei'
+		}
+
+		@@search_types = {
+			#:all => 'all',	# TODO: All is too complex at the moment, API doesn't return all results in one query
+			:item => 'items',
+			:character => 'characters',
+			:guild => 'guilds',
+			:arena_team => 'arenateams'
+		}
+		
+		@@arena_team_sizes = [2, 3, 5]
+
+		# TODO: Refactor, rethink and remove locale from all requests by passing unused options on to get_xml
+		
+		attr_accessor :character_name, :guild_name, :realm, :locale
+		
+		# You can set up the API with an optional default guild and realm
+		# These will be used in all your API requests unless you specify otherwise
+		# For item requests, the locale will not matter in results, but may affect the speed of replies
+		# TODO: are these nil declarations pointless?
+		def initialize(options = {:character_name => nil, :guild_name => nil, :realm => nil, :locale => :us})
+			@character_name = options[:character_name]
+			@guild_name			= options[:guild_name]
+			@realm					= options[:realm]
+			@locale					= options[:locale] #|| :us
+		end
+		
+		
+		# General-purpose search
+		def search(options = {:search => nil, :type => nil})
+			if @@search_types.include? options[:type]
+				raise Wowr::Exceptions::InvalidSearchType.new
+			end
+			
+			puts options.to_yaml
+			
+			if options[:search].nil?
+				raise Wowr::Exceptions::NoSearchString.new
+			end
+			
+			xml = get_xml(@@search_url, options)
+			
+			puts xml
+									
+			results = []
+			
+			if (xml%'armorySearch'%'searchResults')
+				case options[:type]
+				
+					# TODO: Filter stuff
+					when @@search_types[:item]
+						(xml%'armorySearch'%'searchResults'%'items'/:item).each do |item|
+							results << Wowr::Classes::SearchItem.new(item)
+						end
+					
+					when @@search_types[:character]
+						(xml%'armorySearch'%'searchResults'%'characters'/:character).each do |char|
+							results << Wowr::Classes::Character.new(char)
+						end
+					
+					when @@search_types[:guild]
+						(xml%'armorySearch'%'searchResults'%'guilds'/:guild).each do |guild|
+							results << Wowr::Classes::Guild.new(guild)
+						end
+					
+					when @@search_types[:arena_team]
+						(xml%'armorySearch'%'searchResults'%'arenaTeams'/:arenaTeam).each do |team|
+							results << Wowr::Classes::ArenaTeam.new(team)
+						end
+				end
+			end
+			
+			return results
+		end
+		
+		
+		
+		# Characters
+		# Note searches go across all realms by default
+		def search_characters(options = {:name => @character_name})
+			options.merge!(:type => @@search_types[:character])
+			return search(options)
+		end
+		
+		def get_character_sheet(options = {:character_name => @character_name, :realm => @realm})
+			xml = get_xml(@@character_sheet_url, options)
+			return Wowr::Classes::CharacterSheet.new(xml)
+		end
+		
+		def get_character_list(min_level, klass)
+			
+		end
+		
+		# ??
+		def get_character_skills(options = {:character_name => @character_name, :realm => @realm})
+			compute_hash(options.merge(:url => @@character_skills_url)) || 
+				process_query(Wowr::Classes::Skill, @character_skills_url, false)			
+		end
+		
+		
+		# Guilds
+		def search_guilds(options = {:search => @guild_name, :locale => @locale})
+			options.merge!(:type => @@search_types[:guild])
+			return search(options)
+		end
+		
+		def get_guild(options = {:guild_name => @guild_name, :realm => @realm})
+			xml = get_xml(@@guild_info_url, options)
+			return Wowr::Classes::Guild.new(xml)
+		end
+		
+		
+		
+		# Items
+		def search_items(options = {:search => nil})
+			options.merge!(:type => @@search_types[:item])
+			return search(options)
+		end
+		
+		# TODO: Is not finding the item an exception or just return nil?
+		def get_item(options = {:item_id => nil, :locale => @locale})
+			
+			#return Wowr::Classes::ItemTooltip.new(xml%'itemTooltip')
+		end
+		
+		def get_item_info(options = {:item_id => nil, :locale => @locale})
+			xml = get_xml(@@item_info_url, options)
+			if (xml%'itemInfo'%'item')
+				return Wowr::Classes::ItemInfo.new(xml%'itemInfo'%'item')
+			else
+				return nil
+			end
+		end
+		
+		def get_item_tooltip(options = {:item_id => nil})
+			xml = get_xml(@@item_tooltip_url, options)
+			
+			# tooltip returns empty document when not found
+			if xml.nil?
+				return nil
+				#raise Wowr::Exceptions::ItemNotFound.new("Item not found with id: #{options[:item_id]}")
+			end
+			return Wowr::Classes::ItemTooltip.new(xml%'itemTooltip')
+		end
+		
+		
+		
+		# Arena Teams
+		def search_arena_teams(options = {})
+			options.merge!(:type => @@search_types[:arena_team])
+			return search(options)
+		end
+		
+		def get_arena_team(options = {:team_name => :nil, :team_size => nil, :realm => @realm})
+			if !@@arena_team_sizes.include?(options[:team_size])
+				raise Wowr::Exceptions::InvalidArenaTeamSize.new("Arena teams size must be: #{@@arena_team_sizes.inspect}")
+			end
+			
+			xml = get_xml(@@arena_team_url, options)
+			return Wowr::Classes::ArenaTeam.new(xml%'arenaTeam')
+		end
+		
+		# this is more of a rails-plugin thing
+		# def icon(icon_url)
+		# 	@@icon_url + icon_url
+		# end
+		
+		
+		protected
+		def base_url(locale = @locale)
+			if locale == :eu
+				@@eu_armory_url
+			else
+				@@armory_url
+			end
+		end
+		
+		# TODO: pretty damn hacky
+		def get_xml(url, opts = {})
+			
+			# better way of doing this?
+			reqs = {
+				:character_name => 'n',
+				:realm => 'r',
+				:search => 'searchQuery',
+				:type => 'searchType',
+				:guild_name => 'n',
+				:item_id => 'i',
+				:team_size => 'ts',
+				:team_name => 't'
+			}
+			
+			params = []
+			opts.each do |key, value|
+				if reqs[key]
+					params << "#{reqs[key]}=#{u(value)}"
+				end
+			end
+			
+			if params.size > 0
+				query = '?' + params.join('&')
+			end
+			
+			locale = opts[:locale] || @locale
+			
+			base = self.base_url(locale)
+			uri = URI.parse(base + url)
+			full_query = base + url + query
+			#puts full_query
+			req = Net::HTTP::Get.new(full_query)
+			req["user-agent"] = "Mozilla/5.0 Gecko/20070219 Firefox/2.0.0.2"
+			res = Net::HTTP.new(uri.host, uri.port).start {|http| http.request(req) }
+			
+			tries = 0
+			response = case res
+			when Net::HTTPSuccess, Net::HTTPRedirection
+				res.body
+			else
+				tries += 1
+				if tries > @@max_connection_tries
+					raise Wowr::Exceptions::NetworkTimeout.new('Timed out')
+				else
+					retry
+				end
+			end
+			
+			#puts response
+			
+			doc = Hpricot.XML(response)
+			begin
+				errors = doc.search("*[@errCode]")
+				#errors.to_yaml
+				if errors.size > 0
+					errors.each do |error|
+						raise Wowr::Exceptions::raise_me(error[:errCode])
+					end
+				else
+					return (doc%'page')
+				end
+			rescue Exception => e 
+				$stderr.puts "Fatal error ((#{e.to_s})): Couldn't search the XML document."
+				$stderr.puts doc
+				exit 1
+			end
+			
+		end
+		
+		# TODO: URL encoding of query strings
+		def u(str)
+			if str.instance_of?(String)
+				return CGI.escape(str)
+			else
+				return str
+			end
+			#stripslashes(str)
+		end
+	end
+end

data/lib/wowr/classes.rb

@@ -0,0 +1,1299 @@
+# TODO: Item sources - Vendors
+# sourceType.vendor
+# sourceType.questReward
+# sourceType.createdBySpell
+
+# TODO: Split up classes depending on subject?
+# Character, Item, Guild, ArenaTeam
+
+
+# Wowr was written by Ben Humphreys!
+# http://wowr.benhumphreys.co.uk/
+module Wowr
+	module Classes
+		
+		# Composed of an ItemInfo and
+		# Needs to be consolidated with ItemInfo and other stuff
+		# to be a parent class that they extend?
+		class Item
+			attr_reader :id, :name, :icon
+			alias_method :item_id, :id
+
+			def initialize(elem)
+				@id 			= elem[:id].to_i
+				@name 		= elem[:name]
+				@icon 		= elem[:icon]
+			end
+		end
+		
+		
+		# Short character info, used in guild lists etc.
+		class Character
+			attr_reader :name, :level, :url, :rank,
+									:klass, :klass_id,
+									:gender, :gender_id,
+									:race, :race_id,
+									:guild, :guild_id,
+									:battle_group, :last_login,
+									:relevance, :search_rank,
+									
+									:season_games_played, :season_games_won, :team_rank # From ArenaTeam info
+			
+			def initialize(elem)
+				@name	 			= elem[:name]
+				@level 			= elem[:level].to_i
+				@url 				= elem[:url] || elem[:charUrl]
+				@rank 			= elem[:rank].to_i
+				
+				@klass 			= elem[:class]
+				@klass_id		= elem[:classId].to_i
+				
+				@gender 		= elem[:gender]
+				@gender_id 	= elem[:genderId].to_i
+				
+				@race 			= elem[:race]
+				@race_id 		= elem[:raceId].to_i
+				
+				@guild			= elem[:guild] == "" ? nil : elem[:guild]
+				@guild_id		= elem[:guildId].to_i == 0 ? nil : elem[:guildId].to_i
+				
+				@battle_group 		= elem[:battleGroup]
+				@battle_group_id 	= elem[:battleGroupId].to_i
+				
+				@relevance 		= elem[:relevance].to_i
+				@search_rank 	= elem[:searchRank].to_i
+				
+				@last_login 	= elem[:lastLoginDate] == "" ? nil : elem[:lastLoginDate]
+				
+				# From ArenaTeam info, can be blank on normal requests
+				@season_games_played 	= elem[:seasonGamesPlayed].to_i
+				@season_games_won 		= elem[:seasonGamesWon].to_i
+				@team_rank 						= elem[:teamRank].to_i
+				#@char_url 						= elem[:charUrl]	# TODO: Merge with URL?
+			end
+		end
+		
+		
+		
+		# Full character details
+		# uses characterInfo element
+		class CharacterSheet
+			
+			# character_info
+			attr_reader :name, :level, :char_url, :title,
+									:gender, :gender_id,
+									:race, :race_id,
+			 						:klass, :klass_id,
+			 						:faction, :faction_id,
+			 						:guild_name, :guild_url,
+			 						:realm,
+			 						:battle_group,
+									:last_modified
+			
+			# character_tab
+			attr_reader :health, :second_bar,
+									:strength, :agility, :stamina, :intellect, :spirit
+			alias_method :str, :strength
+			alias_method :agi, :agility
+			alias_method :sta, :stamina
+			alias_method :int, :intellect
+			alias_method :spi, :spirit
+			
+			attr_reader :melee, :ranged, :spell,
+									:defenses, :resistances,
+									:talent_spec, :pvp,
+									:professions,
+									:items,
+									:buffs, :debuffs
+			
+			# It's made up of two parts
+			# Don't care about battlegroups yet
+			# I don't think I can call stuff from the constructor?
+			def initialize(elem)
+				character_info(elem%'character')
+				character_tab(elem%'characterTab')
+			end
+			
+			
+			def character_info(elem)
+				# basic info
+				@name	 			= elem[:name]
+				@level 			= elem[:level].to_i
+				@char_url 	= elem[:url]
+				@rank 			= elem[:rank].to_i
+				@title			= elem[:title]
+				
+				@klass 			= elem[:class]
+				@klass_id		= elem[:classId].to_i
+
+				@gender 		= elem[:gender]
+				@gender_id 	= elem[:genderId].to_i
+
+				@race 			= elem[:race]
+				@race_id 		= elem[:raceId].to_i
+				
+				@faction 		= elem[:faction]
+				@faction_id = elem[:factionId].to_i
+				
+				@guild			= elem[:guild]
+				@guild_url	= elem[:guildUrl]
+				
+				@realm			= elem[:realm]
+				
+				@battle_group = elem[:battleGroup]
+				
+				@last_modified = elem[:lastModified]#.to_time
+			end
+			
+			def character_tab(elem)
+				@health 		= (elem%'characterBars'%'health')[:effective].to_i
+				@second_bar = SecondBar.new(elem%'characterBars'%'secondBar')
+				
+				# base stats
+				# % is alias for Hpricot's 'at' method, assume only 1 baseStats/strength element
+				@strength 	= Strength.new(elem%'baseStats'%'strength')
+				@agility 		= Agility.new(elem%'baseStats'%'agility')
+				@stamina 		= Stamina.new(elem%'baseStats'%'stamina')
+				@intellect 	= Intellect.new(elem%'baseStats'%'intellect')
+				@spirit 		= Spirit.new(elem%'baseStats'%'spirit')
+				
+				# damage stuff
+				@melee 		= Melee.new(elem%'melee')
+				@ranged 	= Ranged.new(elem%'ranged')
+				@spell 		= Spell.new(elem.at(' > spell'))	# TODO: hacky?
+				@defenses = Defenses.new(elem%'defenses')
+				
+				
+				#resistances
+				#TODO: This keying is wrong
+				@resistances = []
+				(elem/:resistances).each do |resistance|
+					#@resistances[:arcane] = ArcaneResistance.new(elem[:resistances][:arcane])
+					#@resistances[resistance] = Resistance.new(resistance)
+				end
+				
+				
+				@talent_spec = TalentSpec.new(elem%'talentSpec')
+				
+				@pvp = Pvp.new(elem%'pvp')
+				
+				
+				
+				# professions
+				@professions = []
+				(elem%'professions'/:skill).each do |skill|
+					@professions << Profession.new(skill)
+				end
+				
+				# items
+				@items = []
+				(elem%'items'/:item).each do |item|
+					@items << EquippedItem.new(item)
+				end
+				
+				# buffs
+				@buffs = []
+				(elem%'buffs'/:spell).each do |buff|
+					@buffs << Buff.new(buff)
+				end
+				
+				# debuffs
+				@debuffs = []
+				(elem%'debuffs'/:spell).each do |debuff|
+					@debuffs << Buff.new(debuff)
+				end
+			end
+		end
+		
+		
+		
+		# Note differences in values depending on class
+		class SecondBar
+			attr_reader :effective, :casting, :not_casting, :type
+			
+			def initialize(elem)
+				@effective 		= elem[:effective].to_i
+				@casting 			= elem[:casting].to_i == -1 ? nil : elem[:casting].to_i
+				@not_casting 	= elem[:notCasting].to_i == -1 ? nil : elem[:notCasting].to_i
+				@type 				= elem[:type]
+			end
+		end
+		
+		
+		
+		class BaseStat	# abstract?
+			attr_reader :base, :effective
+		end
+		
+		class Strength < BaseStat
+			attr_reader :attack, :block
+			def initialize(elem)
+				@base				= elem['base'].to_i
+				@effective 	= elem['effective'].to_i
+				@attack 		= elem['attack'].to_i
+				@block 			= elem['block'].to_i == -1 ? nil : elem['block'].to_i
+			end
+		end
+		
+		class Agility < BaseStat
+			attr_reader :armor, :attack, :crit_hit_percent
+			def initialize(elem)
+				@base	 		 				= elem[:base].to_i
+				@effective 				= elem[:effective].to_i
+				@armor 		 				= elem[:armor].to_i
+				@attack 					= elem[:attack].to_i == -1 ? nil : elem[:attack].to_i
+				@crit_hit_percent = elem[:critHitPercent].to_f
+			end
+		end
+		
+		class Stamina < BaseStat
+			attr_reader :health, :pet_bonus
+			def initialize(elem)
+				@base 			= elem[:base].to_i
+				@effective 	= elem[:effective].to_i
+				@health 		= elem[:health].to_i
+				@pet_bonus 	= elem[:petBonus].to_i == -1 ? nil : elem[:petBonus].to_i
+			end
+		end
+		
+		class Intellect < BaseStat
+			attr_reader :mana, :crit_hit_percent, :pet_bonus
+			def initialize(elem)
+				@base	 						= elem[:base].to_i
+				@effective 				= elem[:effective].to_i
+				@mana 						= elem[:mana].to_i
+				@crit_hit_percent = elem[:critHitPercent].to_f
+				@pet_bonus 				= elem[:petBonus].to_i == -1 ? nil : elem[:petBonus].to_i
+			end
+		end
+		
+		class Spirit < BaseStat
+			attr_reader :health_regen, :mana_regen
+			def initialize(elem)
+				@base	 				= elem[:base].to_i
+				@effective 		= elem[:effective].to_i
+				@health_regen = elem[:healthRegen].to_i
+				@mana_regen 	= elem[:manaRegen].to_i
+			end
+		end
+		
+		class Armor < BaseStat
+			attr_reader :percent, :pet_bonus
+			def initialize(elem)
+				@base 			= elem[:base].to_i
+				@effective 	= elem[:effective].to_i
+				@percent 		= elem[:percent].to_f
+				@pet_bonus 	= elem[:petBonus].to_i == -1 ? nil : elem[:petBonus].to_i
+			end
+		end
+		
+		
+		
+		
+		
+		class Melee
+			attr_reader :main_hand_skill, :off_hand_skill,
+									:main_hand_damage, :off_hand_damage,
+									:main_hand_speed, :off_hand_speed,
+									:speed, :hit_rating, :crit_chance
+
+			def initialize(elem)
+				# TODO: Do these not exist anymore?
+				@main_hand_skill 	= WeaponSkill.new(elem%'mainHandWeaponSkill') if (elem%'mainHandWeaponSkill')
+				@off_hand_skill 	= WeaponSkill.new(elem%'offHandWeaponSkill') if (elem%'offHandWeaponSkill')
+				
+				@main_hand_damage = WeaponDamage.new(elem%'mainHandDamage')
+				@off_hand_damage 	= WeaponDamage.new(elem%'offHandDamage')
+				
+				@main_hand_speed 	= WeaponSpeed.new(elem%'mainHandSpeed')
+				@off_hand_speed 	= WeaponSpeed.new(elem%'offHandSpeed')
+				
+				@power 						= WeaponPower.new(elem%'power')
+				@hit_rating 			= WeaponHitRating.new(elem%'hitRating')
+				@crit_chance 			= WeaponCritChance.new(elem%'critChance')
+			end
+		end
+
+		class Ranged
+			attr_reader :weapon_skill, :damage, :speed, :power,
+									:hit_rating, :crit_chance
+
+			def initialize(elem)
+				@weapon_skill = WeaponSkill.new(elem%'weaponSkill')
+				@damage 			= WeaponDamage.new(elem%'damage')
+				@speed 				= WeaponSpeed.new(elem%'speed')
+				@power 				= WeaponPower.new(elem%'power')
+				@hit_rating 	= WeaponHitRating.new(elem%'hitRating')
+				@crit_chance 	= WeaponCritChance.new(elem%'critChance')
+			end
+		end
+			
+		class WeaponSkill
+			attr_reader :rating, :value
+			
+			def initialize(elem)
+				@value 	= elem[:value].to_i == -1 ? nil : elem[:value].to_i
+				@rating = elem[:rating].to_i
+			end
+		end
+		
+		class WeaponDamage
+			attr_reader :dps, :max, :min, :percent, :speed
+			
+			def initialize(elem)
+				@dps 			= elem[:dps].to_f
+				@max 			= elem[:max].to_i
+				@min 			= elem[:min].to_i
+				@percent 	= elem[:percent].to_f
+				@speed 	= elem[:speed].to_f
+			end
+		end
+		
+		class WeaponSpeed
+			attr_reader :haste_percent, :haste_rating, :value
+			
+			def initialize(elem)
+				@haste_percent 	= elem[:hastePercent].to_f
+				@haste_rating 	= elem[:hasteRating].to_f
+				@value 				= elem[:value].to_f
+			end
+		end
+		
+		class WeaponPower
+			attr_reader :base, :effective, :increased_dps, :pet_attack, :pet_spell
+			
+			def initialize(elem)
+				@base 					= elem[:base].to_i
+				@haste_rating 	= elem[:effective].to_i
+				@increased_dps 	= elem[:increasedDps].to_f
+				@pet_attack 		= (elem[:petAttack].to_f == -1 ? nil : elem[:petAttack].to_f)
+				@pet_spell 			= (elem[:petSpell].to_f == -1 ? nil : elem[:petSpell].to_f)					
+			end
+		end
+		
+		class WeaponHitRating
+			attr_reader :increased_hit_percent, :value
+			
+			def initialize(elem)
+				@increased_hit_percent 	= elem[:increasedHitPercent].to_f
+				@value 									= elem[:value].to_f
+			end
+		end
+		
+		class WeaponCritChance
+			attr_reader :percent, :plus_percent, :rating
+			
+			def initialize(elem)
+				@percent 			= elem[:percent].to_f
+				@plus_percent = elem[:plusPercent].to_f
+				@rating 			= elem[:rating].to_i
+			end
+		end
+		
+		
+		
+		# Decided to do funky stuff to the XML to make it more useful.
+		# instead of having two seperate lists of bonusDamage and critChance
+		# merged it into one set of objects for each thing
+		class Spell
+			attr_reader :arcane, :fire, :frost, :holy, :nature, :shadow,
+									:hit_rating, :bonus_healing, :penetration, :mana_regen
+			
+			def initialize(elem)
+				@arcane = SpellDamage.new(elem%'bonusDamage'%'arcane', elem%'critChance'%'arcane')
+				@fire   = SpellDamage.new(elem%'bonusDamage'%'fire', elem%'critChance'%'fire')
+				@frost  = SpellDamage.new(elem%'bonusDamage'%'frost', elem%'critChance'%'frost')
+				@holy   = SpellDamage.new(elem%'bonusDamage'%'holy', elem%'critChance'%'holy')
+				@nature = SpellDamage.new(elem%'bonusDamage'%'nature', elem%'critChance'%'nature')
+				@shadow = SpellDamage.new(elem%'bonusDamage'%'shadow', elem%'critChance'%'shadow')
+
+				@bonus_healing 	= (elem%'bonusHealing')[:value].to_i # is this right??
+				@penetration 		= (elem%'penetration')[:value].to_i
+				@hit_rating 		= WeaponHitRating.new(elem%'hitRating')
+				@mana_regen 		= ManaRegen.new(elem%'manaRegen')
+				
+				# elements = %w[arcane fire frost holy nature shadow]
+				# elements.each do |element|
+				# 	# TODO: is this a good idea?
+				# 	#instance_variable_set("@#{element}", foo) #??
+				# 	#eval("@#{element} = SpellDamage.new(elem[:bonusDamage][element][:value], elem[:critChance][element][:percent]).to_f)")
+				# 	# eval("@#{element} = SpellDamage.new((elem%'bonusDamage'%element)[:value].to_i,
+				# 	# 																						(elem%'critChance'%element)[:percent].to_f)")
+				# end
+			end
+		end
+		
+		class SpellDamage
+			attr_reader :value, :crit_chance_percent
+			alias_method :percent, :crit_chance_percent
+			
+			def initialize(bonusDamage_elem, critChance_elem)
+				@value 		= bonusDamage_elem[:value].to_i
+				@crit_chance_percent	= critChance_elem[:percent].to_f
+			end
+		end
+		
+		class ManaRegen
+			attr_reader :casting, :not_casting
+			
+			def initialize(elem)
+				@casting 			= elem[:casting].to_f
+				@not_casting 	= elem[:notCasting].to_f
+			end
+		end
+		
+		class PetBonus
+			attr_reader :attack, :damage, :from_Type
+			
+			def initialize(elem)
+				@attack 		= elem[:attack].to_i == -1 ? nil : elem[:attack].to_i
+				@damage 		= elem[:damage].to_i == -1 ? nil : elem[:damage].to_i
+				@from_type 	= elem[:fromType] if elem[:fromType]
+			end
+		end
+		
+		
+		
+		class Defenses
+			attr_reader :armor, :defense, :dodge, :parry, :block, :resilience
+			
+			def initialize(elem)
+				@armor 			= Armor.new(elem%'armor')
+				@defense 		= Defense.new(elem%'defense')
+				@dodge 			= DodgeParryBlock.new(elem%'dodge')
+				@parry 			= DodgeParryBlock.new(elem%'parry')
+				@block 			= DodgeParryBlock.new(elem%'block')
+				@resilience = Resilience.new(elem%'resilience')
+			end
+		end
+		
+		class Armor
+			attr_reader :base, :effective, :percent, :pet_bonus
+			
+			def initialize(elem)
+				@base 			= elem[:base].to_i
+				@effective 	= elem[:effective].to_i
+				@percent 		= elem[:percent].to_f
+				@pet_bonus 	= elem[:petBonus].to_i == -1 ? nil : elem[:petBonus].to_i
+			end
+		end
+		
+		class Defense
+			attr_reader :value, :increase_percent, :decrease_percent, :plus_defense, :rating
+			
+			def initialize(elem)
+				@value 						= elem[:value].to_i
+				@increase_percent = elem[:increasePercent].to_f
+				@decrease_percent = elem[:decreasePercent].to_f
+				@plus_defense 		= elem[:plusDefense].to_i
+				@rating 					= elem[:rating].to_i
+			end
+		end
+		
+		class DodgeParryBlock
+			attr_reader :percent, :increase_percent, :rating
+			
+			def initialize(elem)
+				@percent 					= elem[:percent].to_f
+				@increase_percent = elem[:increasePercent].to_f
+				@rating 					= elem[:rating].to_i
+			end
+		end
+		
+		class Resilience			
+			attr_reader :damage_percent, :hit_percent, :value
+			
+			def initialize(elem)
+				@damage_percent = elem[:damagePercent].to_f
+				@hit_percent 		= elem[:hitPercent].to_f
+				@value 					= elem[:value].to_f
+			end
+		end
+		
+		
+		
+		class Resistance
+			attr_reader :value, :pet_bonus
+			
+			def initialize(elem)
+				@value 			= elem[:value].to_i
+				@pet_bonus 	= elem[:petBonus].to_i == -1 ? nil : elem[:petBonus].to_i
+			end
+		end
+		
+		
+		# TODO: Array starting at 1?  Not sure if this is such a hot idea
+		class TalentSpec
+			attr_reader :trees
+
+			def initialize(elem)
+				@trees = []
+				@trees[1] = elem[:treeOne].to_i
+				@trees[2] = elem[:treeTwo].to_i
+				@trees[3] = elem[:treeThree].to_i
+			end
+		end
+		
+				
+		# Player-versus-player data
+		class Pvp
+			attr_reader :lifetime_honorable_kills, :arena_currency
+			
+			def initialize(elem)
+				@lifetime_honorable_kills = (elem%'lifetimehonorablekills')[:value].to_i
+				@arena_currency 					= (elem%'arenacurrency')[:value].to_i
+			end
+		end
+		
+		
+		# A buff 
+		class Buff
+			attr_reader :name, :effect, :icon
+			
+			def initialize(elem)
+				@name 	= elem[:name]
+				@effect = elem[:effect]
+				@icon 	= elem[:icon]
+			end
+		end
+		
+		
+		# A player's profession, players can only have 2 max
+		class Profession
+			attr_reader :key, :name, :max, :value
+			
+			def initialize(elem)
+				@key		= elem[:key]
+				@name		= elem[:name]
+				@value	= elem[:value].to_i
+				@max		= elem[:max].to_i
+			end
+		end
+		
+		
+		# An item equipped to a player
+		class EquippedItem < Item
+			attr_reader :durability, :max_durability, #:id, :item_id, :icon,
+									:gems, :permanent_enchant,
+									:random_properties_id, :seed, :slot
+			
+			def initialize(elem)
+				super(elem)
+				#@id										= elem[:id].to_i
+				#@icon									= elem[:icon]
+				@durability						= elem[:durability].to_i
+				@max_durability				= elem[:maxDurability].to_i
+				@gems = []
+				@gems[0]							= elem[:gem0Id].to_i == 0 ? nil : elem[:gem0Id].to_i
+				@gems[1]							= elem[:gem1Id].to_i == 0 ? nil : elem[:gem1Id].to_i
+				@gems[2]							= elem[:gem2Id].to_i == 0 ? nil : elem[:gem2Id].to_i
+				@permanent_enchant		= elem[:permanentEnchant].to_i
+				@random_properties_id = elem[:randomPropertiesId] == 0 ? nil : elem[:randomPropertiesId].to_i
+				@seed									= elem[:seed].to_i # not sure if seed is so big it's overloading
+				@slot									= elem[:slot].to_i
+			end
+		end
+
+
+
+		# class Damage
+		#		:type, :min, :max, :speed, :dps
+		# end
+		# 
+		# class ItemSource
+		#		:area_id
+		#		:area_name
+		#		:creature_id
+		#		:creature_name
+		#		:difficulty
+		#		:drop_rate
+		#		:value
+		# end
+		
+		# A player guild containing members
+		# note not all of these will be filled out, depending on how the data is found
+		
+		class Guild
+			attr_reader :name, :url, :realm, :realm_url, :battle_group,
+									:roster_url, :stats_url, :stats_url_escape,
+									:faction, :faction_id,
+									:members, :member_count
+
+			def initialize(elem)
+				if (elem%'guildKey')
+					guild = (elem%'guildKey')
+				else
+					guild = elem
+				end
+				
+				@name = guild[:name]
+				@name_url = guild[:nameUrl]
+				@url = guild[:url]
+				@realm = guild[:realm]
+				@realm_url = guild[:realmUrl]
+				@battle_group = guild[:battleGroup]
+				@faction = guild[:faction]
+				@faction_id = guild[:factionId]
+				
+				# some shortened versions
+				if (elem%'guildInfo')
+					@member_count = (elem%'guildInfo'%'guild'%'members')[:memberCount].to_i || nil
+				
+					@members = []
+					(elem%'guildInfo'%'guild'%'members'/:character).each do |char|
+						members << Character.new(char)
+					end
+				end
+			end
+		end
+		
+		
+		# class Guild
+		# 	attr_reader :name, :realm, :battle_group,
+		# 							:roster_url, :stats_url, :stats_url_escape,
+		# 							:members, :member_count
+		# 	
+		# 	def initialize(elem)
+		# 		@name = elem[:name]
+		# 		@realm = elem[:realm]
+		# 		@battle_group = elem[:battleGroup]
+		# 		@roster_url = elem[:rosterUrl]
+		# 		@stats_url = elem[:statsUrl]
+		# 		@stats_url_escape = elem[:statsUrlEscape]
+		# 		@member_count = (elem%'members')[:memberCount].to_i
+		# 		
+		# 		@members = []
+		# 		(elem%'members'/:character).each do |char|
+		# 			members << Character.new(char)
+		# 		end
+		# 	end
+		# end
+		
+		
+		
+		
+		
+		# General skill category
+		# eg Weapon Skills, Languages
+		class SkillCategory
+			attr_reader :key, :name, :skills
+			
+			def initialize(elem)
+				@key 	= elem[:key]
+				@name = elem[:name]
+				
+				@skills = []
+				(elem/:skill).each do |skill|
+					@skills << Skill.new(skill)
+				end
+			end
+		end
+		
+		# 
+		# eg Daggers, Riding, Fishing 
+		class Skill
+			attr_reader :key, :name, :value, :max
+			
+			def initialize(elem)
+				@key 		= elem[:key]
+				@name 	= elem[:name]
+				@value 	= elem[:value]
+				@max 		= elem[:max]
+			end
+		end
+		
+		
+		
+		
+		# Larger group of factions
+		# eg Alliance, Shattrath City, Steamwheedle Cartel
+		# character-reputation.xml
+		class FactionCategory
+			attr_reader :key, :name, :factions
+			
+			def initialize(elem)
+				@key 	= elem[:key]
+				@name = elem[:name]
+				
+				@factions = []
+				(elem/:faction).each do |faction|
+					@factions << Faction.new(faction)
+				end
+			end
+		end
+		
+		# Smaller NPC faction that is part of a FactionCategory
+		# eg Darnassus, Argent Dawn
+		class Faction
+			attr_reader :key, :name, :reputation
+			
+			def initialize(elem)
+				@key 				= elem[:key]
+				@name 			= elem[:name]
+				@reputation = elem[:reputation].to_i
+			end
+		end
+		
+		
+		
+		
+		# Provides detailed item information
+		# Reflects information found within item-tooltip.xml
+		class ItemTooltip < Item
+			attr_reader :desc, :overall_quality_id, :bonding, :max_count, #:id, :name, :icon, 
+									:class_id, :bonuses, :item_source,
+									:bonuses, :resistances,
+									:required_level,
+									:allowable_classes,
+									:armor, :durability,
+									:sockets, :socket_match_enchant,
+									:gem_properties
+			alias_method :description, :desc
+
+			def initialize(elem)
+				@id									= (elem%'id').html.to_i
+				@name								= (elem%'name').html
+				@icon								= (elem%'icon').html
+				@desc								= (elem%'desc').html if (elem%'desc')
+				@overall_quality_id	= (elem%'overallQualityId').html.to_i
+				@bonding						= (elem%'bonding').html.to_i
+				@stackable					= (elem%'stackable').html.to_i if (elem%'stackable')
+				@max_count					= (elem%'maxCount').html.to_i if (elem%'maxCount')
+				@class_id						= (elem%'classId').html.to_i
+				@required_level			= (elem%'requiredLevel').html.to_i if (elem%'requiredLevel')
+				
+				@equipData					= ItemEquipData.new(elem%'equipData')
+				
+				# TODO: This appears to be a plain string at the moment
+				#<gemProperties>+26 Healing +9 Spell Damage and 2% Reduced Threat</gemProperties>
+				@gem_properties			= (elem%'gemProperties').html if (elem%'gemProperties')
+				
+				# not all items have damage data
+				@damage							= ItemDamageData.new(elem%'damageData') if !(elem%'damageData').html.empty?
+
+				
+				# TODO: Test socket data with a variety of items
+				# TODO: replace with socket Class?
+				if (elem%'socketData')
+					@sockets = []
+					(elem%'socketData'/:socket).each do |socket|
+						@sockets << socket[:color]
+					end
+					
+					@socket_match_enchant = (elem%'socketData'%'socketMatchEnchant')
+				end
+				
+				
+				# When there is no data, stats are not present in @bonuses
+				# TODO: When there is no stats at all, @bonuses shouldn't be set
+				@bonuses = {}
+				
+				bonus_stats = {
+					:strength => :bonusStrength,
+					:agility => :bonusAgility,
+					:stamina => :bonusStamina,
+					:intellect => :bonusIntellect,
+					:spirit => :bonusSpirit
+				}
+				bonus_stats.each do |stat, xml_elem|
+					@bonuses[stat] = test_stat(elem/xml_elem) if test_stat(elem/xml_elem)
+				end
+				
+				# Resistances
+				@resistances = {}
+				
+				resist_stats = {
+					:arcane => :arcaneResist,
+					:fire => :fireResist,
+					:frost => :frostResist,
+					:holy => :holyResist,
+					:nature => :natureResist,
+					:shadow => :shadowResist
+				}
+				resist_stats.each do |stat, xml_elem|
+					@resistances[stat] = test_stat(elem/xml_elem) if test_stat(elem/xml_elem)
+				end
+				
+				
+				#@bonuses[:strength]		= (elem/:bonusStrength).html.to_i   if (elem/:bonusStrength)
+				
+				if (elem%'allowableClasses')
+					@allowable_classes = []
+					(elem%'allowableClasses'/:class).each do |klass|
+						@allowable_classes << klass.html
+					end
+				end
+				
+				# NOTE not representing armor bonus
+				@armor			= (elem%'armor').html.to_i 						if (elem%'armor')
+				
+				# NOTE not representing max
+				@durability	= (elem%'durability')[:current].to_i	if (elem%'durability')
+				
+				if (elem%'spellData')
+					@spells = []
+					(elem%'spellData'/:spell).each do |spell|
+						@spells << ItemSpell.new(spell)
+					end
+				end
+				
+				@setData = ItemSetData.new(elem%'setData') if (elem%'setData')
+				
+				# @item_sources = []
+				# (elem/:itemSource).each do |source|
+				# 	@item_sources << ItemSource.new(source)
+				# end
+				@item_source = ItemSource.new(elem%'itemSource') if (elem%'itemSource')	 # TODO: More than once source?
+			end
+			
+			private
+			def test_stat(elem)
+				if elem
+					if !elem.html.empty?
+						return elem.html.to_i
+					end
+				end
+				return nil
+			end
+		end
+		
+		class ItemEquipData
+			attr_reader :inventory_type, :subclass_name, :container_slots
+
+			def initialize(elem)
+				@inventory_type = (elem%'inventoryType').html.to_i
+				@subclass_name = (elem%'subclassName').html if (elem%'subclassName')
+				@container_slots = (elem%'containerSlots').html.to_i if (elem%'containerSlots') # for baggies
+			end
+		end
+		
+		class ItemSetData
+			attr_reader :name, :items, :set_bonuses
+			
+			def initialize(elem)
+				@name = elem[:name]
+				
+				@items = []
+				(elem/:item).each do |item|
+					@items << item[:name]
+				end
+				
+				@set_bonuses = []
+				(elem/:setBonus).each do |bonus|
+					@set_bonuses << ItemSetBonus.new(bonus)
+				end
+			end
+		end
+		
+		class ItemSetBonus
+			attr_reader :threshold, :description
+			alias_method :desc, :description
+			
+			def initialize(elem)
+				@threshold = elem[:threshold].to_i
+				@description = elem[:desc]
+			end
+		end
+
+		class ItemSpell
+			attr_reader :trigger, :description
+			alias_method :desc, :description
+
+			def initialize(elem)
+				@trigger = (elem%'trigger').html.to_i
+				@description = (elem%'desc').html
+			end
+		end
+
+
+		class ItemDamageData
+			attr_reader :type, :min, :max, :speed, :dps
+
+			def initialize(elem)
+				@type 	= (elem%'damage'%'type').html.to_i
+				@min 		= (elem%'damage'%'min').html.to_i
+				@max 		= (elem%'damage'%'max').html.to_i
+				@speed 	= (elem%'speed').html.to_i
+				@dps 		= (elem%'dps').html.to_f
+			end
+		end
+
+		class ItemSource
+			attr_reader :value,
+									:area_id, :area_name,
+									:creature_id, :creature_name,
+									:difficulty, :drop_rate
+
+			def initialize(elem)
+				@value 					= elem[:value]
+				@area_id 				= elem[:areaId].to_i 			if elem[:areaId]
+				@area_name 			= elem[:areaName]					if elem[:areaName]
+				@creature_id 		= elem[:creatureId].to_i	if elem[:creatureId]
+				@creature_name 	= elem[:creatureName]			if elem[:creatureName]
+				@difficulty 		= elem[:difficulty]				if elem[:difficulty]
+				@drop_rate 			= elem[:dropRate].to_i		if elem[:dropRate]
+				@required_level	= elem[:reqLvl].to_i			if elem[:reqLvl]
+			end
+		end
+		
+		
+
+		# A really basic item type returned by searches
+		class SearchItem < Item
+			attr_reader :url, :rarity,
+									:source, :item_level, :relevance
+			alias_method :level, :item_level
+
+			def initialize(elem)
+				super(elem)
+				@rarity			= elem[:rarity].to_i
+				@url				= elem[:url]
+
+				@item_level	= elem.at("filter[@name='itemLevel']")[:value].to_i
+				@source			= elem.at("filter[@name='source']")[:value]
+				@relevance	= elem.at("filter[@name='relevance']")[:value].to_i
+			end
+		end
+		
+		
+		
+		
+		# uses item-info.xml
+		class ItemInfo < Item
+			attr_reader :icon, :id, :level, :name, :quality, :type,
+									:cost, :disenchants, :disenchant_skill_rank, :vendors,
+									:plans_for
+			
+			def initialize(elem)
+				@id 			= elem[:id].to_i
+				@level 		= elem[:level].to_i
+				@name 		= elem[:name]
+				@icon 		= elem[:icon]
+				@quality 	= elem[:quality].to_i
+				@type 		= elem[:type]
+			
+				# Cost can be in gold, or tokens
+				@cost = ItemCost.new(elem%'cost') if (elem%'cost')
+				
+				
+				
+				# is costs really an array?
+				#@costs 		= []
+				#(elem/:cost).each do |cost|
+				#	@costs << ItemCost.new(cost)
+				#end
+			
+				if (elem%'disenchantLoot')
+					@disenchant_skill_rank = (elem%'disenchantLoot')[:requiredSkillRank].to_i 
+			
+					@disenchant_items = []
+					(elem%'disenchantLoot'/:item).each do |item|
+						@disenchant_items << DisenchantItem.new(item)
+					end
+				end
+				
+				if (elem%'objectiveOfQuests')
+					@objective_of_quests = []
+					(elem%'objectiveOfQuests'/:quest).each do |quest|
+						@objective_of_quests << ItemQuest.new(quest)
+					end
+				end
+				
+				if (elem%'rewardFromQuests')
+					@reward_from_quests = []
+					(elem%'rewardFromQuests'/:quest).each do |quest|
+						@reward_from_quests << ItemQuest.new(quest)
+					end
+				end
+
+				if (elem%'vendors')
+					@vendors = []
+					(elem%'vendors'/:creature).each do |vendor|
+						@vendors << ItemVendor.new(vendor)
+					end
+				end
+				
+				if (elem%'dropCreatures')
+					@drop_creatures = []
+					(elem%'dropCreatures'/:creature).each do |creature|
+						@drop_creatures << ItemDropCreature.new(creature)
+					end
+				end
+				
+				if (elem%'plansFor')
+					@plans_for = []
+					(elem%'plansFor'/:spell).each do |plan|
+						@plans_for << ItemPlansFor.new(plan)
+					end
+				end
+				
+				if (elem%'createdBy')
+					@created_by = []
+					(elem%'createdBy'/:spell).each do |c|
+						@created_by << ItemCreatedBy.new(c)
+					end
+				end
+			end
+		end
+		
+    # <rewardFromQuests>
+    #   <quest name="Justice Dispensed" level="39" reqMinLevel="30" id="11206" area="Dustwallow Marsh" suggestedPartySize="0"></quest>
+    #   <quest name="Peace at Last" level="39" reqMinLevel="30" id="11152" area="Dustwallow Marsh" suggestedPartySize="0"></quest>
+    # </rewardFromQuests>
+		# TODO: Rename
+		class ItemQuest
+			attr_reader :name, :id, :level, :min_level, :area, :suggested_party_size
+			
+			def initialize(elem)
+				@name 			= elem[:name]
+				@id 				= elem[:id].to_i
+				@level 			= elem[:level].to_i
+				@min_level 	= elem[:min_level].to_i
+				@area 			= elem[:area]
+				@suggested_party_size = elem[:suggested_party_size].to_i
+			end
+		end
+		
+		
+		
+		# Creatures that drop the item
+		# <creature name="Giant Marsh Frog" minLevel="1" type="Critter" maxLevel="1" dropRate="6" id="23979" classification="0" area="Dustwallow Marsh"></creature>
+		# <creature name="Nalorakk" minLevel="73" title="Bear Avatar" url="fl[source]=dungeon&amp;fl[difficulty]=normal&amp;fl[boss]=23576" type="Humanoid" maxLevel="73" dropRate="2" id="23576" classification="3" areaUrl="fl[source]=dungeon&amp;fl[boss]=all&amp;fl[difficulty]=normal&amp;fl[dungeon]=3805" area="Zul'Aman"></creature>
+		class ItemDropCreature
+			attr_reader :name, :id, :type, :min_level, :max_level, :drop_rate, :classification, :area
+			
+			def initialize(elem)
+				@name 					= elem[:name]
+				@id 						= elem[:id].to_i
+				@min_level 			= elem[:minLevel].to_i
+				@max_level 			= elem[:maxLevel].to_i
+				@drop_rate 			= elem[:dropRate].to_i
+				@classification = elem[:classification].to_i
+				@area 					= elem[:area]
+				
+				# optional boss stuff
+				@title 		= elem[:title]		if elem[:title] # TODO: not nil when no property?
+				@url			= elem[:url]			if elem[:url]
+				@type			= elem[:type]			if elem[:type] # Humanoid etc.
+				@area_url = elem[:areaUrl]	if elem[:areaUrl]
+			end	
+		end
+		 
+		
+		# <cost sellPrice="280" buyPrice="5600"></cost>
+		# <cost>
+		# 	<token icon="spell_holy_championsbond" id="29434" count="60"></token>
+		# </cost>
+		class ItemCost
+			attr_reader :buy_price, :sell_price, :tokens
+			
+			def initialize(elem)
+				@buy_price 	= elem[:buyPrice].to_i	if elem[:buyPrice]
+				@sell_price	= elem[:sellPrice].to_i	if elem[:sellPrice]
+				
+				if (elem%'token')
+					@tokens = []
+					(elem/:token).each do |token|
+						@tokens << ItemCostToken.new(token)
+					end
+				end
+			end
+		end
+		
+		# <token icon="spell_holy_championsbond" id="29434" count="60"></token>
+		class ItemCostToken
+			attr_reader :id, :icon, :count
+			
+			def initialize(elem)
+				@id = elem[:id].to_i
+				@icon = elem[:icon]
+				@count = elem[:count].to_i
+			end
+		end
+		
+		# <item name="Void Crystal" minCount="1" maxCount="2" icon="inv_enchant_voidcrystal" type="Enchanting" level="70" dropRate="6" id="22450" quality="4"></item>
+		class DisenchantItem
+			attr_reader :name, :id, :icon, :level, :type, :drop_rate, :min_count, :max_count, :quality
+			
+			def initialize(elem)
+				@name 			= elem[:name]
+				@id 				= elem[:id].to_i
+				@icon 			= elem[:icon]
+				@level 			= elem[:level].to_i
+				@type 			= elem[:type]
+				@drop_rate 	= elem[:dropRate].to_i
+				@min_count 	= elem[:minCount].to_i
+				@max_count 	= elem[:maxCount].to_i
+				@quality 		= elem[:quality].to_i
+			end
+		end
+		
+		class ItemVendor
+			attr_reader :id, :name, :title, :type,
+									:area, :classification, :max_level, :min_level
+			
+			def initialize(elem)
+				@id 						= elem[:id].to_i
+				@name 					= elem[:name]
+				@title 					= elem[:title]
+				@type 					= elem[:type]
+				@area 					= elem[:area]
+				@classification = elem[:classification].to_i
+				@max_level 			= elem[:maxLevel].to_i
+				@min_level 			= elem[:minLevel].to_i
+			end
+		end
+		
+		
+
+		
+		# TODO rename
+		# There is some sort of opposite relationship between PlansFor and CreatedBy
+		class ItemCreation
+			attr_reader :name, :id, :icon,
+									:item, :reagents
+			
+			def initialize(elem)
+				@name = elem[:name]
+				@id = elem[:id].to_i
+				@icon = elem[:icon]
+				
+				# not all items have reagents, some are just spells
+				if (elem%'reagent')
+					@reagents = []
+					(elem/:reagent).each do |reagent|
+						@reagents << Reagent.new(reagent)
+					end
+				end
+			end
+		end
+		
+		
+		# <plansFor>
+		#   <spell name="Shadowprowler's Chestguard" icon="trade_leatherworking" id="42731">
+		#     <item name="Shadowprowler's Chestguard" icon="inv_chest_plate11" type="Leather" level="105" id="33204" quality="4"></item>
+		#     <reagent name="Heavy Knothide Leather" icon="inv_misc_leatherscrap_11" id="23793" count="10"></reagent>
+		#     <reagent name="Bolt of Soulcloth" icon="inv_fabric_soulcloth_bolt" id="21844" count="16"></reagent>
+		#     <reagent name="Primal Earth" icon="inv_elemental_primal_earth" id="22452" count="12"></reagent>
+		#     <reagent name="Primal Shadow" icon="inv_elemental_primal_shadow" id="22456" count="12"></reagent>
+		#     <reagent name="Primal Nether" icon="inv_elemental_primal_nether" id="23572" count="2"></reagent>
+		#   </spell>
+		# </plansFor>
+		class ItemPlansFor < ItemCreation
+			def initialize(elem)
+				super(elem)
+				# TODO: Multiple items?
+				@item = CreatedItem.new(elem%'item')  if (elem%'item')
+			end			
+		end
+		
+		# <createdBy>
+		# 	<spell name="Bracing Earthstorm Diamond" icon="temp" id="32867">
+		# 		<item requiredSkill="Jewelcrafting" name="Design: Bracing Earthstorm Diamond" icon="inv_scroll_03" type="Jewelcrafting" level="73" id="25903" requiredSkillRank="365" quality="1"></item>
+		# 		<reagent name="Earthstorm Diamond" icon="inv_misc_gem_diamond_04" id="25867" count="1"></reagent>
+		# 	</spell>
+		# </createdBy>
+		class ItemCreatedBy < ItemCreation
+			def initialize(elem)
+				super(elem)
+				# TODO: Multiple items?
+				@item = PlanItem.new(elem%'item') if (elem%'item')
+			end
+		end
+		
+		# TODO: Might be better to reuse an existing Item class?
+		# <item name="Shadowprowler's Chestguard" icon="inv_chest_plate11" type="Leather" level="105" id="33204" quality="4"></item>
+		class CreatedItem < Item
+			attr_reader :type, :level, :quality
+			
+			def initialize(elem)
+				super(elem)
+				@type = elem[:type]
+				@level = elem[:level].to_i
+				@quality = elem[:quality].to_i
+			end
+		end
+		
+		# TODO: Might be better to reuse an existing Item class?
+		# <item requiredSkill="Jewelcrafting" name="Design: Bracing Earthstorm Diamond" icon="inv_scroll_03" type="Jewelcrafting" level="73" id="25903" requiredSkillRank="365" quality="1"></item>
+		class PlanItem < Item
+			attr_reader :required_skill, :type, :required_skill_rank, :level, :quality
+			
+			def initialize(elem)
+				super(elem)
+				@type = elem[:type]
+				@level = elem[:level].to_i
+				@quality = elem[:quality].to_i
+				@required_skill = elem[:requiredSkill]
+				@required_skill_rank = elem[:requiredSkillRank].to_i
+			end
+		end
+			
+		class Reagent
+			attr_reader :id, :name, :icon, :count
+			
+			def initialize(elem)
+				@id = elem[:id].to_i
+				@name = elem[:name]
+				@icon = elem[:icon]
+				@count = elem[:count].to_i
+			end
+		end
+		
+		
+
+		# A group of individuals
+		# Note that search results don't contain the members
+		class ArenaTeam
+			attr_reader :name, :size, :battle_group, :faction, :faction_id, :realm, :realm_url, 
+									:games_played, :games_won, :ranking, :rating,
+									:season_games_played, :season_games_won, :last_season_ranking, 
+									:relevance, :url, :url_escape,
+									:characters,	# can be blank on search results
+									:emblem
+			
+			def initialize(elem)
+				@name					= elem[:name]
+				@size					= elem[:size].to_i
+				@battle_group	= elem[:battleGroup]
+				@faction			= elem[:faction]
+				@faction_id		= elem[:factionId].to_i
+				@realm				= elem[:realm]
+				@realm_url		= elem[:realmUrl]
+				
+				@games_played	= elem[:gamesPlayed].to_i
+				@games_won		= elem[:gamesWon].to_i
+				@ranking			= elem[:ranking].to_i
+				@rating				= elem[:rating].to_i
+				
+				@season_games_played	= elem[:seasonGamesPlayed].to_i
+				@season_games_won			= elem[:seasonGamesWon].to_i
+				@last_season_ranking	= elem[:lastSeasonRanking].to_i
+				
+				@relevance		= elem[:relevance].to_i
+				@url					= elem[:url]
+				
+				@emblem				= ArenaTeamEmblem.new(elem%'emblem')
+				
+				@members = []
+				(elem%'members'/:character).each do |character|
+					@members << Character.new(character)
+				end
+			end
+		end
+		
+		class ArenaTeamEmblem
+			attr_reader :background, :border_color, :border_style, :icon_colour, :icon_style
+			
+			def initialize(elem)
+				@background		= elem[:background]
+				@border_color = elem[:borderColor]
+				@border_style = elem[:borderStyle].to_i
+				@icon_color		= elem[:iconColor]
+				@icon_style		= elem[:iconStyle].to_i
+			end
+		end
+		
+				
+	end
+end