bnet 0.0.1

data/lib/bnet/diablo3/skill.rb

@@ -0,0 +1,19 @@
+class Bnet::Diablo3::Skill < Bnet::BnetResource
+
+  attr_accessor :name, :rune
+
+
+  # Ags :
+  #      {
+  #        "skill" => { name: "", ... },
+  #        "rune"  => { name: "", ... }
+  #      }
+  #
+  # Returns:
+  #
+  # #<Bnet::Diablo3::Skill:0x007fd111396360 @name: "", @rune=>
+  def self.from_api(response)
+    new(name: response['skill']['name'], rune: response['rune']['name'])
+  end
+
+end

data/lib/bnet/starcraft2.rb

@@ -0,0 +1,7 @@
+module Bnet
+  class Starcraft2 < Bnet::API
+    def url
+      super + "sc2/"
+    end
+  end
+end

data/lib/bnet/starcraft2/profile.rb

@@ -0,0 +1,94 @@
+# TODO: Associations for career, current_season
+class Bnet::Starcraft2::Profile < Bnet::BnetResource
+
+  attr_accessor :profile_id, :realm, :display_name, :clan_name, :clan_tag,
+    :achievement_points, :swarm_level, :terran_level, :zerg_level,
+    :protoss_level, :acievement_points
+
+  PARAMS_MAPPING = {
+      "id" => :profile_id,
+      "realm" =>  :realm,
+      "displayName" => :display_name,
+      "clanName" => :clan_name,
+      "clanTag" => :clan_tag,
+      "career" => :career
+    }
+
+  def initialize args
+    args.each do |k,v|
+      instance_variable_set("@#{k}", v) unless v.nil?
+    end
+  end
+
+  # Query Battlenet API for the SC2 profile recordand create an instance of an
+  # SC2 Profile.
+  #
+  # Hash Params:
+  #   Required
+  #     :realm      - (required but defaults to '1')
+  #     :profile_id - ID (Honestly i do not know why Blizzard still needs this if
+  #                   localized Battletag is unique enough)
+  #     :name       - Just the name string in the Battle tag.
+  #   Optional
+  #     :locale     - (defaults to 'en_US')
+  #     :api_key    - the api key
+  #
+  # Example: If US account 'Playerone#1309' the profile can be accessible via
+  # web from 'http://us.battle.net/sc2/en/profile/2143215/1/PlayerOne/'
+  #
+  #   find(region: 'us', profile_id: 2143215, name: 'PlayerOne')
+  #
+  # Returns a Profile object with the following attributes
+  #
+  #      :profile_id, :realm, :display_name, :clan_name, :clan_tag,
+  #      :achievement_points, :swarm_level, :terran_level, :zerg_level,
+  #      :protoss_level, :acievement_points
+  def self.find args
+    region     = args.delete(:region)
+    profile_id = args.delete(:profile_id)
+    name       = args.delete(:name)
+    realm      = args.delete(:realm) || '1'
+    locale     = args.delete(:locale) || 'en_US'
+    api_key        = args.delete(:api_key) || Bnet.configuration.api_key
+
+    base_api = Bnet::Starcraft2.new(region: region)
+    call_url = base_api.url + "profile/#{profile_id}/#{realm}/#{name}/?locale=#{locale}&apikey=#{api_key}"
+
+    begin
+      data = open(call_url)
+      raw_response = JSON.parse(data.read)
+
+      if Bnet::API.valid_call?(data.status, raw_response)
+        bnet_object = from_api(raw_response)
+      else
+        bnet_object = nil
+      end
+
+    rescue OpenURI::HTTPError => e
+      bnet_object = nil
+    end
+
+    return bnet_object
+
+  end
+
+  def career
+    @career ||= []
+  end
+
+  def self.from_api(response)
+    bnet_resource = super(response)
+    if bnet_resource && response["achievements"]
+      bnet_resource.achievement_points = response["achievements"]["points"]["totalPoints"]
+    end
+
+    if bnet_resource && response["swarmLevels"]
+      bnet_resource.swarm_level   = response["swarmLevels"]["level"]
+      bnet_resource.terran_level  = response["swarmLevels"]["terran"]["level"]
+      bnet_resource.protoss_level = response["swarmLevels"]["protoss"]["level"]
+      bnet_resource.zerg_level    = response["swarmLevels"]["zerg"]["level"]
+    end
+
+    bnet_resource
+  end
+end

data/lib/bnet/version.rb

@@ -0,0 +1,3 @@
+module Bnet
+  VERSION = "0.0.1"
+end

data/lib/bnet/wow.rb

@@ -0,0 +1,7 @@
+module Bnet
+  class WOW < Bnet::API
+    def url
+      super + "wow/"
+    end
+  end
+end

data/lib/bnet/wow/character.rb

@@ -0,0 +1,78 @@
+class Bnet::WOW::Character < Bnet::BnetResource
+
+  attr_accessor :name, :realm, :battlegroup, :class, :race, :gender, :level,
+    :achievement_points, :total_honorable_kills, :calc_class
+
+  # Query Battlenet API for the character profile
+  #
+  # Hash Params:
+  #   Required
+  #     :region          - (e.g. 'us', 'ea')
+  #     :name            - String name of the toon
+  #     :realm           - String name of the server the character is on (String)
+  #   Optional
+  #     :locale          - String locale (defaults to 'en_US')
+  #     :api_key         - String api key
+  #
+  # Example : IF a character named 'AlexeiStukov' is on 'DragonMaw' 'US' server
+  #
+  #   Bnet::WOW::Character.find(region: 'us', name: 'AlexeiStukov', realm: 'Dragonmaw')
+  #
+  # Returns a Character with the following attributes
+  #
+  #   :name, :realm, :battlegroup, :class, :race, :gender, :level,
+  #   :achievement_points, :total_honorable_kills, :calc_class
+  def self.find args
+    region     = args.delete(:region)
+    realm      = args.delete(:realm)
+    name       = args.delete(:name)
+    locale     = args.delete(:locale) || 'en_US'
+    api_key    = args.delete(:api_key) || Bnet.configuration.api_key
+
+    base_api = Bnet::WOW.new(region: region)
+    call_url = base_api.url + "character/#{realm}/#{name}?locale=#{locale}&apikey=#{api_key}"
+
+    begin
+      data = open(call_url)
+      raw_response = JSON.parse(data.read)
+
+      if data.status == ['200', 'OK'] && raw_response["code"] != 'NOTFOUND'
+        bnet_object = from_api(raw_response)
+      else
+        bnet_object = nil
+      end
+
+    rescue OpenURI::HTTPError => e
+      bnet_object = nil
+    end
+
+    return bnet_object
+  end
+
+  def gender
+    case @gender
+    when 0
+      'Female'
+    when 1
+      'Male'
+    end
+  end
+
+  private
+
+  def self.params_mapping
+    {
+      "name" => :name,
+      "realm" => :realm,
+      "battlegroup" => :battlegroup,
+      "class" => :class,
+      "race" => :race,
+      "gender" => :gender,
+      "level" => :level,
+      "achievement_points" => :achievement_points,
+      "calc_class" => :calc_class,
+      "total_honorable_kills" => :total_honorable_kills
+    }
+  end
+
+end

data/lib/bnet/wow/data.rb

@@ -0,0 +1,5 @@
+module Bnet::WOW::Data
+  autoload :Base,         'bnet/wow/data/base'
+  autoload :Battlegroup, 'bnet/wow/data/battlegroup'
+  autoload :CharacterRace, 'bnet/wow/data/character_race'
+end

data/lib/bnet/wow/data/base.rb

@@ -0,0 +1,54 @@
+class Bnet::WOW::Data::Base < Bnet::BnetResource
+  # Query Battlenet API for the the data based on the subclass's scope
+  #
+  # Hash Params:
+  #   :region          - (e.g. 'us', 'ea')
+  #   :name            - String name of the toon
+  #   :realm           - String name of the server the character is on (String)
+  #   :locale          - String locale (defaults to 'en_US')
+  #   :api_key         - String api key
+  #
+  # Example : If a character named 'AlexeiStukov' is on 'DragonMaw' 'US' server
+  def self.find_all(args)
+    region = args.delete(:region)
+    api_key    = args.delete(:api_key) || Bnet::configuration.api_key
+    locale     = args.delete(:locale) || 'en_US'
+
+    base_api = Bnet::WOW.new(region: region)
+    call_url = base_api.url + 'data/' + scopes[:url] + "?locale=#{locale}&apikey=#{api_key}"
+
+    begin
+      data = open(call_url)
+      raw_response = JSON.parse(data.read)
+
+      if Bnet::API.valid_call?(data.status, raw_response)
+        collection = collection_from_api(raw_response)
+      else
+        collection = []
+      end
+
+
+    rescue OpenURI::HTTPError => e
+      collection = []
+    end
+
+    return collection
+  end
+
+  private
+
+  def self.collection_from_api(response_collection)
+    response_collection[scopes[:collection_root]].collect do |attrs|
+      from_api(attrs)
+    end
+  end
+
+  def self.url(collection_scope)
+    "#{Bnet::WOW.url}/data/#{collection_scope}"
+  end
+
+  def self.scopes
+    self::SCOPES
+  end
+
+end

data/lib/bnet/wow/data/battlegroup.rb

@@ -0,0 +1,18 @@
+class Bnet::WOW::Data::Battlegroup < Bnet::WOW::Data::Base
+  attr :name, :slug
+
+  SCOPES = {
+    url: 'battlegroups/',
+    collection_root: 'battlegroups'
+  }
+
+  PARAMS_MAPPING = { "name" => :name, "slug" => :slug }
+
+  private
+
+  def self.scopes
+    self::SCOPES
+  end
+
+end
+

data/lib/bnet/wow/data/character_race.rb

@@ -0,0 +1,15 @@
+class Bnet::WOW::Data::CharacterRace < Bnet::WOW::Data::Base
+
+  attr :race_id, :mask, :side, :name
+
+  SCOPES = {
+    url: 'character/races',
+    collection_root: 'races'
+  }
+
+  PARAMS_MAPPING = {
+    "id" => :race_id, "mask" => :mask,
+    "side" => :side, "name" => :name
+  }
+
+end

data/spec/bnet/account_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Bnet::Account do
+
+end

data/spec/bnet/api_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Bnet::API do
+  let(:instance) do
+    described_class.new(region: "eu")
+  end
+
+  describe "initialization" do
+    it "can be initialized" do
+      expect(instance).to be_a_kind_of(described_class)
+      expect(instance.region).to eq("eu")
+    end
+  end
+
+  describe "#url" do
+    it "returns the base url by region" do
+      expect(instance.url).to eq("https://eu.api.battle.net/")
+    end
+  end
+end

data/spec/bnet/diablo3/career_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Bnet::Diablo3::Career do
+
+  describe ".from_api" do
+    let(:attrs){
+      {
+        "heroes" => [], "lastheroplayed" => 'val', "lastupdated" => 'val',
+        "kills" => 'val', "timeplayed" => 'val', "fallenheroes" => 'val',
+        "paragonlevel" => 'val', "paragonlevelhardcore" => 'val',
+        "battletag" => 'val', "progression" => 'val'
+      }
+    }
+    subject{ described_class.from_api(attrs)}
+    it "is initialized" do
+      expect(subject).to be_a_kind_of(described_class)
+    end
+  end
+
+  describe ".find(battle_tag: 'PlayerOne#1309', region: 'us')" do
+    subject(:career) { described_class.find(args) }
+
+    context "Playertag for the server exists" ,vcr: { cassette_name: 'find_diablo_career_player_one '} do
+      let(:args) do
+        { battle_tag: 'PlayerOne#1309', region: 'us' }
+      end
+      it { is_expected.to_not be_nil }
+
+      it "sets account attributes that are of the json response" do
+        expect(career.battle_tag).to eq('PlayerOne#1309')
+        expect(career.region).to eq('us')
+      end
+
+      it "assigns autoloads the heroes" do
+        expect(career.heroes).to_not be_empty
+
+        career.heroes.each do |hero|
+          expect(hero).to be_a_kind_of(Bnet::Diablo3::Hero)
+          expect(hero.battle_tag).to eq('PlayerOne#1309')
+          expect(hero.region).to eq(career.region)
+          expect(hero.career).to be(career)
+          expect(hero.passive_skills).to_not be_empty
+          expect(hero.active_skills).to_not be_empty
+        end
+
+      end
+    end
+
+    context "Playertag for the server does not exist", vcr: { cassette_name: 'find_diablo_career_doesnt_exist'} do
+      let(:args) do
+        { battle_tag: 'DoesntExist-42', region: 'us' }
+      end
+      it { is_expected.to be_nil }
+    end
+  end
+
+end

data/spec/bnet/diablo3/hero_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Bnet::Diablo3::Hero do
+
+  describe ".find(battle_tag: 'PlayerOne-1309', region: 'us', hero_id: 1304986)" do
+    subject {described_class.find(args)}
+
+    context "Given the correct battle tag and hero id", vcr: {cassette_name: 'diablo_hero_found'} do
+      let(:args) do
+        {
+          battle_tag: 'PlayerOne-1309',
+          region: 'us',
+          hero_id: 1304986
+        }
+      end
+
+      it "Instantiates a hero " do
+        is_expected.to be_a_kind_of(described_class)
+        expect(subject.name).to eq('PlayerOne')
+        expect(subject.hero_class).to eq('wizard')
+      end
+
+      it "assigns skills" do
+        expect(subject.active_skills.map(&:name)).
+          to match_array([ "Magic Missile", "Arcane Orb",
+                           "Hydra", "Familiar", "Magic Weapon",
+                           "Teleport" ])
+
+        expect(subject.active_skills.map(&:rune)).
+          to match_array([ "Seeker", "Frozen Orb", "Frost Hydra", "Sparkflint",
+                           "Force Weapon", "Fracture"])
+
+        expect(subject.passive_skills.map(&:name)).
+          to match_array([ "Elemental Exposure", "Prodigy", "Astral Presence",
+                           "Cold Blooded" ])
+      end
+
+    end
+
+    context "Given the hero does not exist on that tag/realm", vcr: {cassette_name: 'diablo_hero_notf_found'} do
+      let(:args) do
+        {
+          battle_tag: 'DOESNTEXIST-666',
+          region: 'us',
+          hero_id: 666
+        }
+      end
+
+      it { is_expected.to be_nil }
+    end
+
+  end
+
+  describe ".from_api" do
+
+    context "Given the right parameters" do
+      let(:api_args) do
+        { "paragonLevel" => 0, "seasonal" => false, "name" => "PlayerOne",
+          "id" => 1304986, "level" => 70, "hardcore" => false, "gender" => 0,
+          "dead" => false, "class" => "wizard", "last-updated" => 1397322512
+        }
+      end
+
+      subject { described_class.from_api(api_args) }
+
+      it "can be initialized" do
+        is_expected.to_not be_nil
+      end
+
+    end
+  end
+
+
+  describe "#reload" do
+    context "Hero since last update was level 69", vcr: {cassette_name: 'diablo_hero_reload'} do
+      let(:hero) do
+        described_class.new(battle_tag: 'PlayerOne#1309',region: 'us', hero_id: 1304986, level: 69)
+      end
+      it "Fetches  update from the API and update the object" do
+        expect{hero.reload}.to change{hero.level}.from(69).to(70)
+      end
+    end
+  end
+
+  describe '#career' do
+    it "returns a career object"
+  end
+
+end