backpack_tf 0.5.0 → 0.8.0

data/lib/backpack_tf/version.rb

@@ -1,3 +1,3 @@
 module BackpackTF
-  VERSION = "0.5.0"
+  VERSION = "0.8.0"
 end

data/lib/backpack_tf.rb

@@ -8,9 +8,11 @@ end
 # IMPORTANT! require the Response module before any other class or module
 require 'backpack_tf/version'
 require 'backpack_tf/response'
-require 'backpack_tf/finder'
 require 'backpack_tf/client'
-require 'backpack_tf/currencies'
+require 'backpack_tf/currency'
 require 'backpack_tf/item'
 require 'backpack_tf/item_price'
-require 'backpack_tf/prices'
+require 'backpack_tf/price'
+require 'backpack_tf/special_item'
+require 'backpack_tf/user'
+require 'backpack_tf/user_listing'

data/readme.md

@@ -1,13 +1,16 @@
 #backpack_tf
 Backpack.tf is a website for the in-game economies of Team Fortress 2 and Dota 2. This gem is a wrapper for the backpack.tf [API](http://backpack.tf/api). The goal is to capture the results and turn them into Ruby objects for use in your application.
 
-It is in the very early stages of development. See the [TODO](TODO.md) list if you are interested in contributing.
+It is in the early stages of development. See the [TODO](TODO.md) list if you are interested in contributing.
 
 ###Installation
-Install it as a gem:  
+#####install any dependencies
+`bundle install`
+
+######Install it as a gem:  
 `gem install backpack_tf`  
 
-Or add it to your project's Gemfile:  
+######Or add it to your project's Gemfile:  
 `gem 'backpack_tf'`
 
 ###Usage
@@ -17,40 +20,77 @@ Or add it to your project's Gemfile:
 * Load the gem into your project:  
   `require 'backpack_tf'`
 
+###Examples
+
+``` ruby
+##### create a new Client object  
+bp = BackpackTF::Client.new
+
+##### fetch some data
+fetched_prices = bp.fetch(:prices, { :compress => 1 })
+fetched_currencies = bp.fetch(:currencies, { :compress => 1 })
+fetched_special_items = bp.fetch(:special_items, { :compress => 1})
+fetched_users = bp.fetch(:users, { :steamids => [64_bit_steam_id_of_one_user, 64_bit_steam_id_of_another_user] })
+fetched_listings = bp.fetch(:user_listings, { :steamid => 64_bit_steam_id_of_one_user })
+
+##### update a class with the data
+# *note*: you should send a message from your Client object to the class before
+# using any of those class' methods.
+# This does not apply to the `Item` class and the `ItemPrice` class.
+# Those are updated through the `Price` class.
+
+bp.update(BackpackTF::Price, fetched_prices)
+bp.update(BackpackTF::Currency, fetched_currencies)
+bp.update(BackpackTF::SpecialItem, fetched_special_items)
+bp.update(BackpackTF::User, fetched_users)
+bp.update(BackpackTF::UserListing, fetched_listings)
+
+##### look at prices of a random item
+random_key = BackpackTF::Price.items.sample
+BackpackTF::Price.items[random_key]
+
+```
+
 ##Interfaces
 
 ####IGetPrices
 * Get pricing data for all priced items
 * [official doc](http://backpack.tf/api/prices)
 
-API responses from this interfaces are captured in the `Prices` class. The `Prices` class is not meant to be instantiated. One of the class attributes is `@@items`, a Hash object. Information on any particular item, ie: 'Kritzkrieg', is captured in an instance of the `Item` class. Furthermore, there may be several prices for the same item, ie: a Kritzkrieg with the Unique quality has a different price than a Kritzkrieg with a Vintage quality.  Each price is an instance of the `ItemPrice` class, and is stored in the `@prices` hash of that item.
+API responses from this interface are captured in the `Price` class. The `Price` class is not meant to be instantiated. One of the class attributes is `@@items`, a Hash object. Information on any particular item, ie: 'Eviction Notice', is captured in an instance of the `Item` class. Furthermore, there may be several prices for the same item, ie: an Eviction Notice with the Unique quality has a different price than a Eviction Notice with a Strange quality.  Each price is an instance of the `ItemPrice` class, and is stored in the `@prices` hash of that item.
 
 ######a visual
-* `Prices` class
+* `Price` class
   * `@@items` hash of `Price` class.
     * `Item` object (ie: 'Beast From Below')
     * `Item` object (ie: 'Taunt: Rock, Paper Scissors')
-    * `Item` object (ie: 'Kritzkrieg')
+    * `Item` object (ie: 'Eviction Notice')
       * `@prices` hash of an `Item` object
-        * `ItemPrices` object (ie: price for Unique Kritzkrieg)
-        * `ItemPrices` object (ie: price for Collector's Kritzkrieg)
-        * `ItemPrices` object (ie: price for Vintage Kritzkrieg)
+        * `ItemPrice` object (ie: price for Unique Eviction Notice)
+        * `ItemPrice` object (ie: price for Collector's Eviction Notice)
+        * `ItemPrice` object (ie: price for Strange Eviction Notice)
 
 ####IGetCurrencies
 * Get internal currency data for a given game
 * [official doc](http://backpack.tf/api/currencies)
 
-API responses from this interface are captured in the `Currencies` class. Similar the `Prices` class, it has a set of class methods, and attributes to describe the API response. Unlike, the `Prices` class, this one can be instantiated. There are currently 4 currencies available through the API. Each one is an instance of `Currencies` and is held in the `@@currencies` hash of the `Currencies` class.
+API responses from this interface are captured in the `Currency` class. Similar the `Price` class, it has a set of class methods, and attributes to describe the API response. Unlike, the `Price` class, this one can be instantiated. There are currently 4 currencies available through the API. Each one is an instance of `Currency` and is held in the `@@currencies` hash of the `Currency` class.
 
-####IGetSpecialItems *(not yet implemented)*
+####IGetSpecialItems
 * Get internal backpack.tf item placeholders for a given game.
 * [official doc](http://backpack.tf/api/special)
 
-####IGetUsers *(not yet implemented)*
+This is for items that only exist on backpack.tf. They are not real game items, but you will see them returned in a call to `IGetPrices`. The class for this interface is `SpecialItem`.
+
+####IGetUsers
 * Get profile info for a list of 64-bit Steam IDs.
 * Does not require an API key
 * [official doc](http://backpack.tf/api/users)
 
-####IGetUserListings *(not yet implemented)*
+Get some basic information for a list of backpack.tf users. It's basically the info that you'd see on their profile page. The response for this interface is captured in the `User` class. You can request several users at once by sending them in an array.
+
+####IGetUserListings
   * Get classified listings for a given user
   * [official doc](http://backpack.tf/api/classifieds)
+
+Request all classified listings for one user. You must pass in the 64-bit `steamid`. The response is captured in the `UserListing` class.

data/spec/backpack_tf/client_spec.rb

@@ -67,28 +67,28 @@ module BackpackTF
       #context "USING rspec/mock, updating another another class' class variable" do
       #  before :each do
       #    MockResponse = class_double(Response)
-      #    MockCurrencies = class_double(Currencies)
+      #    MockCurrency = class_double(Currency)
 
       #    allow(MockResponse).to receive(:responses) { 
-      #      { MockCurrencies => fetched_currencies }
+      #      { MockCurrency => fetched_currencies }
       #    }
-      #    expect(MockResponse.responses.keys).to eq [MockCurrencies]
+      #    expect(MockResponse.responses.keys).to eq [MockCurrency]
 
-      #    allow(MockCurrencies).to receive(:response) {
-      #      Response.hash_keys_to_sym(MockResponse.responses[MockCurrencies])
+      #    allow(MockCurrency).to receive(:response) {
+      #      Response.hash_keys_to_sym(MockResponse.responses[MockCurrency])
       #    }
-      #    expect(MockCurrencies.response.keys).to eq [:success, :currencies, :name, :url, :current_time]
+      #    expect(MockCurrency.response.keys).to eq [:success, :currencies, :name, :url, :current_time]
 
-      #    allow(MockCurrencies).to receive(:currencies)
-      #    #expect(MockCurrencies.response).to be_nil
+      #    allow(MockCurrency).to receive(:currencies)
+      #    #expect(MockCurrency.response).to be_nil
       #  end
 
       #  it 'the client passes its fetched data to Response.response class method' do
       #  end
       #  it 'the client can pass fetched data to another class so the class can update one of its own class variables' do
-      #    MockResponse.responses(MockCurrencies => fetched_currencies)
-      #    MockCurrencies.response
-      #    expect(MockCurrencies.currencies).not_to be_nil
+      #    MockResponse.responses(MockCurrency => fetched_currencies)
+      #    MockCurrency.response
+      #    expect(MockCurrency.currencies).not_to be_nil
       #  end
       #end
 
@@ -96,27 +96,27 @@ module BackpackTF
         stub_http_response_with('currencies.json')
         Response.responses(:reset => :confirm)
         expect(Response.responses).to be_empty
-        expect(Currencies.response).to be_nil
-        expect(Currencies.currencies).to be_nil
+        expect(Currency.response).to be_nil
+        expect(Currency.currencies).to be_nil
       end
 
       let(:fetched_currencies) {
         bp.fetch(:currencies, {:compress => 1, :appid => 440})
       }
 
-      context 'results on the Currencies.response method' do
+      context 'results on the Currency.response method' do
         it 'returns this Hash object' do
-          bp.update(Currencies, fetched_currencies)
+          bp.update(Currency, fetched_currencies)
           processed_json = Response.hash_keys_to_sym(fetched_currencies)
-          expect(Currencies.response).to eq processed_json
+          expect(Currency.response).to eq processed_json
         end
       end
 
-      context 'results on the Currencies.currencies method' do
+      context 'results on the Currency.currencies method' do
         it 'returns this Hash object' do
-          bp.update(Currencies, fetched_currencies)
+          bp.update(Currency, fetched_currencies)
           processed_json = Response.hash_keys_to_sym(fetched_currencies['currencies'])
-          expect(Currencies.currencies).to eq processed_json
+          expect(Currency.currencies).to eq processed_json
         end
       end
 

data/spec/backpack_tf/{currencies_spec.rb → currency_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module BackpackTF
-  describe 'Currencies' do
+  describe Currency do
     let(:bp) { Client.new }
 
     let(:json_obj) {
@@ -17,11 +17,11 @@ module BackpackTF
     }
 
     it 'responds to these methods' do
-      expect(Currencies).to respond_to :responses, :response, :currencies, :interface, :hash_keys_to_sym
+      expect(described_class).to respond_to :responses, :response, :currencies, :interface, :hash_keys_to_sym
     end
 
     it 'has these default attributes' do
-      expect(Currencies.interface).to eq :IGetCurrencies
+      expect(described_class.interface).to eq :IGetCurrencies
     end
 
     describe '::responses' do
@@ -30,23 +30,23 @@ module BackpackTF
         stub_http_response_with('currencies.json')
         opts = { :app_id => 440, :compress => 1 }
         fetched_currencies = bp.fetch(:currencies, opts)
-        Response.responses(Currencies.to_sym => fetched_currencies)
+        Response.responses(described_class.to_sym => fetched_currencies)
       end
 
       context 'access from Response class' do
-        it 'Currencies can be accessed by calling the key, Currencies' do
-          expect(Response.responses[:'BackpackTF::Currencies']).to eq json_obj
+        it 'Currency can be accessed by calling the key, Currency' do
+          expect(Response.responses[:'BackpackTF::Currency']).to eq json_obj
         end
       end
 
-      context 'access from Currencies class' do
+      context 'access from Currency class' do
         it 'can access response information via the class method, ::response' do
-          expect(Currencies.response).to eq json_obj
+          expect(described_class.response).to eq json_obj
         end
       end
 
-      it 'is the same as calling Currencies.response' do
-        expect(Response.responses[:'BackpackTF::Currencies']).to eq Currencies.response
+      it 'is the same as calling Currency.response' do
+        expect(Response.responses[:'BackpackTF::Currency']).to eq Currency.response
       end
     end
 
@@ -55,18 +55,18 @@ module BackpackTF
         stub_http_response_with('currencies.json')
         opts = { :app_id => 440, :compress => 1 }
         fetched_currencies = bp.fetch(:currencies, opts)
-        Response.responses(':BackpackTF::Currencies' => fetched_currencies)
+        Response.responses(':BackpackTF::Currency' => fetched_currencies)
       end
       it 'the response attribute should have these keys' do
-        expect(Currencies.response.keys).to match_array [:success, :current_time, :currencies, :name, :url]
+        expect(described_class.response.keys).to match_array [:success, :current_time, :currencies, :name, :url]
       end
 
       it 'the keys of the response attribute should have these values' do
-        expect(Currencies.response[:success]).to eq 1
-        expect(Currencies.response[:message]).to eq nil
-        expect(Currencies.response[:current_time]).to eq 1430784460
-        expect(Currencies.response[:name]).to eq 'Team Fortress 2'
-        expect(Currencies.response[:url]).to eq 'http://backpack.tf'
+        expect(described_class.response[:success]).to eq 1
+        expect(described_class.response[:message]).to eq nil
+        expect(described_class.response[:current_time]).to eq 1430784460
+        expect(described_class.response[:name]).to eq 'Team Fortress 2'
+        expect(described_class.response[:url]).to eq 'http://backpack.tf'
       end
 
     end
@@ -79,26 +79,26 @@ module BackpackTF
         stub_http_response_with('currencies.json')
         opts = { :app_id => 440, :compress => 1 }
         fetched_currencies = bp.fetch(:currencies, opts)
-        Response.responses(:'BackpackTF::Currencies' => fetched_currencies)
+        Response.responses(:'BackpackTF::Currency' => fetched_currencies)
       end
 
       it 'returns the fixture and sets to @@currencies variable' do
-        expect(Currencies.currencies).not_to be_nil
+        expect(described_class.currencies).not_to be_nil
       end
 
       it '@@currencies attribute should be a Hash object' do
-        expect(Currencies.currencies).to be_instance_of Hash
+        expect(described_class.currencies).to be_instance_of Hash
       end
 
       it '@@currencies should have these keys' do
         expected_keys = [:metal, :keys, :earbuds, :hat]
-        expect(Currencies.currencies.keys).to match_array expected_keys
+        expect(described_class.currencies.keys).to match_array expected_keys
       end
     end
 
-    describe 'instance of Currencies' do
+    describe 'instance of Currency' do
 
-      let (:metal) { Currencies.new(:metal, Currencies.currencies[:metal]) }
+      let (:metal) { described_class.new(:metal, Currency.currencies[:metal]) }
 
       it 'should respond to these methods' do
         expect(metal).to respond_to(:quality, :priceindex, :single, :plural, :round, :craftable, :tradable, :defindex, :blanket)

data/spec/backpack_tf/price_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+module BackpackTF
+  describe Price do
+
+    let(:bp) { Client.new }
+
+    let(:json_obj) {
+      fixture = file_fixture('prices.json')
+      fixture = JSON.parse(fixture)['response']
+      Response.hash_keys_to_sym(fixture)
+    }
+
+    it 'responds to these inherited class methods' do
+      expect(described_class).to respond_to :responses, :to_sym, :interface, :hash_keys_to_sym    
+    end
+
+    it 'has these default attributes' do
+      expect(described_class.interface).to eq :IGetPrices
+    end
+
+    it 'raises an error when trying to instantiate this class' do
+      expect{described_class.new}.to raise_error RuntimeError
+    end
+
+    describe '::responses' do
+      it "Responses class can access Price response by calling Price key" do
+        stub_http_response_with('prices.json')
+        fetched_prices = bp.fetch(:prices)
+        Response.responses(described_class.to_sym => fetched_prices)
+        expect(Response.responses[described_class.to_sym]).to eq json_obj
+      end
+    end
+
+    describe '::response' do
+      before :each do
+        stub_http_response_with('prices.json')
+        fetched_prices = bp.fetch(:prices)
+        Response.responses(described_class.to_sym => fetched_prices)
+      end
+
+      after :all do
+        Response.responses(:reset => :confirm)
+        expect(Response.responses).to be_empty
+        expect(described_class.response).to be_nil
+      end
+
+      it 'can access response information' do
+        expect(described_class.response).to eq json_obj
+      end
+      it "returns same info as the Response class calling Price key" do
+        expect(described_class.response).to eq Response.responses[described_class.to_sym]
+      end
+      it 'the response attribute should have these keys' do
+        expect(described_class.response.keys).to match_array [:success, :current_time, :raw_usd_value, :usd_currency, :usd_currency_index, :items]
+      end
+      it 'the keys of the response attribute should have these values' do
+        response = described_class.response
+        expect(response[:success]).to eq 1
+        expect(response[:message]).to eq nil
+        expect(response[:current_time]).to eq 1430785805
+        expect(response[:raw_usd_value]).to eq 0.115
+        expect(response[:usd_currency]).to eq 'metal'
+        expect(response[:usd_currency_index]).to eq 5002
+      end
+    end
+
+    describe '::generate_items' do
+    end
+
+    describe '::items' do
+      before :each do
+        stub_http_response_with('prices.json')
+        fetched_prices = bp.fetch(:prices)
+        bp.update(described_class, fetched_prices)
+      end
+
+      after :all do
+        Response.responses(:reset => :confirm)
+        expect(Response.responses).to be_empty
+      end
+
+      it 'returns the fixture and sets to @@items variable' do
+        expect(described_class.items).not_to be_nil
+      end
+
+      context '@@items attribute' do
+        it 'should be a Hash object' do
+          expect(described_class.items).to be_instance_of Hash
+        end
+        xit 'should have this many keys' do
+          expect(described_class.items.keys.length).to be 1661
+        end
+        it 'each key should be a String' do
+          expect(described_class.items.keys).to all be_a String
+        end
+        it 'each value should be an Item' do
+          expect(described_class.items.values).to all be_an Item
+        end
+      end
+
+      context 'using keys to generate Item objects' do
+        let(:random_key) { described_class.items.keys.sample }
+        let(:item) { described_class.items[random_key] }
+
+        it 'generates an Item object' do
+          expect(item).to be_instance_of Item
+        end
+        it 'the Item object responds to these methods' do
+          expect(item).to respond_to :item_name, :defindex, :prices
+        end
+        it 'uses the key to assign a value to the @item_name property of the Item' do
+          expect(random_key).to eq item.item_name
+        end
+        it 'passes itself to be stored in the @prices attribute of the Item object' do
+          expect(described_class.items[random_key].prices).to eq item.prices
+        end
+      end
+    end
+
+    describe '::find_item_by_name' do
+      let(:item) { described_class.items['Kritzkrieg'] }
+
+      before :each do
+        stub_http_response_with('prices.json')
+        fetched_prices = bp.fetch(:prices)
+
+        bp.update(described_class, fetched_prices)
+        expect(described_class.items.values).to all be_an Item
+      end
+
+      after :each do
+        Response.responses(:reset => :confirm)
+        expect(Response.responses).to be_empty
+      end
+
+      it 'returns Item object for the item matching the name' do
+        expect(described_class.find_item_by_name('Kritzkrieg')).to eq item
+      end
+      it 'can return picked attributes' do
+        expect(described_class.find_item_by_name('Kritzkrieg', :defindex)).to eq 35
+      end
+      it 'raises a KeyError if you ask for attribute it does not have' do
+        expect{described_class.find_item_by_name('Kritzkrieg', :foo)}.to raise_error KeyError
+      end
+    end
+
+    describe '::random_item' do
+      before :each do
+        stub_http_response_with('prices.json')
+        fetched_prices = bp.fetch(:prices)
+
+        bp.update(described_class, fetched_prices)
+        expect(described_class.items.values).to all be_an Item
+      end
+
+      after :each do
+        Response.responses(:reset => :confirm)
+        expect(Response.responses).to be_empty
+      end
+
+      it 'returns a name of an Item object' do
+        item = described_class.random_item
+        expect(described_class.items.keys.include? item).to be_truthy
+      end
+      context 'asking for prices property' do
+        let(:item_prices) { described_class.random_item :price }
+
+        it 'returns a Hash object where the keys are Strings' do
+          expect(item_prices.keys).to all be_a String
+        end
+        it 'returns a Hash object where values are ItemPrice objects' do
+          expect(item_prices.values).to all be_an ItemPrice
+        end
+      end
+    end
+
+    describe '::generate_price_keys' do
+    end
+
+  end
+end