backpack_tf 0.8.1 → 0.8.4

data/lib/backpack_tf/client.rb

@@ -34,19 +34,19 @@ module BackpackTF
   
     def self.build_url_via action, query_options = {}
       case action
-      when :get_prices, :prices
+      when :get_prices, :prices, :price
         version = 4
         interface_url = "/#{Price.interface}/v#{version}/?"
-      when :get_currencies, :currencies
+      when :get_currencies, :currencies, :currency
         version = 1
         interface_url = "/#{Currency.interface}/v#{version}/?"
-      when :get_special_items, :special_items
+      when :get_special_items, :special_items, :special_item, :specialitem
         version = 1
         interface_url = "/#{SpecialItem.interface}/v#{version}/?"
-      when :get_users, :users
+      when :get_users, :users, :user
         version = 3
         interface_url = "/#{User.interface}/v#{version}/?"
-      when :get_user_listings, :user_listing, :user_listings
+      when :get_user_listings, :user_listings, :user_listing, :userlisting
         version = 1
         interface_url = "/#{UserListing.interface}/v#{version}/?"
       else

data/lib/backpack_tf/item.rb

@@ -19,11 +19,17 @@ module BackpackTF
         attr = JSON.parse(attr) 
       end
 
-      @defindex   = attr['defindex'][0]
-      @prices     = gen_prices_hash(attr)
+      @defindex   = process_defindex(attr['defindex'])
+      @prices     = generate_prices_hash(attr)
     end
 
-    def gen_prices_hash input_hash
+    def process_defindex arr
+      return nil if arr.length == 0
+      return arr[0] if arr.length == 1
+      arr
+    end
+
+    def generate_prices_hash input_hash
 
       raise TypeError, 'expecting a Hash object' unless input_hash.class == Hash
       unless input_hash.has_key? 'prices'
@@ -34,6 +40,7 @@ module BackpackTF
       prices = input_hash['prices']
 
       prices.inject({}) do |hash, (key, val)|
+
         quality = BackpackTF::ItemPrice.qualities[key.to_i]
         new_key = [quality.to_s]
 
@@ -43,31 +50,34 @@ module BackpackTF
         craftability = prices[key][tradability].keys.first
         new_key << craftability
 
-        new_key = new_key.join('_')
+        new_key = new_key.join(ItemPrice::KEYNAME_DELIMITER)
 
         prefix = prices[key][tradability][craftability]
 
-        if prefix.class == Array
-          item_prices = prefix.first
+        if (prefix.length <= 1)
+          item_prices = prefix[0]
+          # patch for oddly-structured items, ie: Aqua Summer 2013 Cooler
+          item_prices = prefix.values.first if item_prices.nil?
+
           item_price_obj = ItemPrice.new(new_key, item_prices)
           hash[new_key] = item_price_obj
-        elsif prefix.class == Hash
-          if prefix.keys.length <= 1
-            item_prices = prefix.values[0]
-            item_price_obj = ItemPrice.new(new_key, item_prices)
-            hash[new_key] = item_price_obj
-          else
-            prefix.keys.each do |prefix_key|
-              temp_key = "#{new_key}_Effect ##{prefix_key.to_i}"
-              item_prices = prefix[prefix_key]
-              item_price_obj = ItemPrice.new(temp_key, item_prices, prefix_key)
-              hash[new_key] = item_price_obj
-            end
+        elsif key == '5' # item with 'Unusual' quality
+          prefix.keys.each do |prefix_key|
+            item_prices = prefix[prefix_key]
+            item_price_obj = ItemPrice.new(new_key, item_prices, prefix_key)
+            hash[item_price_obj.effect] = item_price_obj
+          end
+        else # a Crate
+          prefix.keys.each do |prefix_key|
+            temp_key = "#{new_key}_##{prefix_key.to_i}"
+            item_prices = prefix[prefix_key]
+            item_price_obj = ItemPrice.new(temp_key, item_prices, prefix_key)
+            hash[temp_key] = item_price_obj
           end
         end
-
         hash
       end
+
     end
 
   end

data/lib/backpack_tf/item_price.rb

@@ -2,13 +2,14 @@ module BackpackTF
 
   class ItemPrice
 
+    KEYNAME_DELIMITER = '_'
+    PARTICLE_EFFECTS_KEY = 'attribute_controlled_attached_particles'
+    PARTICLE_EFFECTS_FILE = "./lib/backpack_tf/assets/#{PARTICLE_EFFECTS_KEY}.json"
+
     ###########################
     #      Class Methods
     ###########################
 
-    @@required_keys = ['currency', 'value', 'last_update', 'difference']
-    def self.required_keys; @@required_keys; end
-
     # mapping official API quality integers to quality names
     # https://wiki.teamfortress.com/wiki/WebAPI/GetSchema#Result_Data
     @@qualities = [
@@ -29,11 +30,51 @@ module BackpackTF
       :"Collector's"
     ]
 
-    def self.qualities; @@qualities; end
-
     @@tradabilities = [:Tradable, :'Non-Tradable']
     @@craftabilities = [:Craftable, :'Non-Craftable']
-    
+    @@required_keys = ['currency', 'value', 'last_update', 'difference']
+
+    def self.qualities; @@qualities; end
+    def self.required_keys; @@required_keys; end
+
+    def self.quality_name_to_index q
+      @@qualities.index(q.to_sym) unless q.nil?
+    end
+
+    def self.hash_particle_effects
+
+      file = File.open(PARTICLE_EFFECTS_FILE).read
+      effects_arr = JSON.parse(file)[PARTICLE_EFFECTS_KEY]
+
+      effects_arr.inject({}) do |hash, pe|
+        id = pe['id']
+        name = pe['name']
+        hash[id] = name
+        hash
+      end
+
+    end
+
+    @@particle_effects = self.hash_particle_effects
+    def self.particle_effects; @@particle_effects; end
+
+    def self.ins_sp str
+      str = str.split('')
+      new_str = ''
+      str.each_with_index do |c, i|
+        if i == 0
+          new_str += c
+        else
+          unless c == c.upcase && str[i-1] == str[i-1].upcase
+            new_str += c
+          else
+            new_str += (' ' + c)
+          end
+        end
+      end
+      new_str
+    end
+
     ###########################
     #     Instance Methods
     ###########################
@@ -56,24 +97,24 @@ module BackpackTF
     attr_reader :value_raw
     # @return [Float] The item's value in the lowest currency without rounding. Reques raw to be enabled and set to 2
     attr_reader :value_high_raw
-    # @return [Fixnum]  A timestamp of when the price was last updated
+    # @return [Fixnum] A timestamp of when the price was last updated
     attr_reader :last_update
-    # @return [Fixnum]  A relative difference between the former price and the current price. If 0, assume new price.
+    # @return [Fixnum] A relative difference between the former price and the current price. If 0, assume new price.
     attr_reader :difference
+    # @return [String] Result of @@particle_effects[@priceindex]
+    attr_reader :effect
 
     def initialize key, attr, priceindex = nil
       attr = JSON.parse(attr) unless attr.class == Hash
-      unless self.class.required_keys.all? {|k| attr.keys.member? k }
-        raise KeyError, "The passed-in hash is required to have at least these 4 keys: #{self.class.required_keys.join(', ')}"
-      end
 
-      key_split = key.split('_')
+      key = key.split(KEYNAME_DELIMITER)
+      key = process_key(key)
 
-      @priceindex     = priceindex
+      validate_attributes(attr)
 
-      @quality        = key_split[0].to_sym
-      @tradability    = key_split[1].to_sym
-      @craftability   = key_split[2].to_sym
+      @quality        = key[0]
+      @tradability    = key[1]
+      @craftability   = key[2]
       @currency       = attr['currency'].to_sym
       @value          = attr['value']
       @value_high     = attr['value_high']
@@ -81,6 +122,49 @@ module BackpackTF
       @value_high_raw = attr['value_high_raw']
       @last_update    = attr['last_update']
       @difference     = attr['difference']
+      @priceindex     = priceindex
+      @effect         = self.class.particle_effects[priceindex.to_i]
+    end
+
+    private
+    # requires the key to an Array with length of 3 or more
+    # converts each element to a Symbol object
+    # The 3 bits of info are subject to a NameError if any one of them is invalid
+    # @return [Array] an Array of Symbol objects
+    # @raises NameError, ArgumentError
+    def process_key key
+
+      unless key.length >= 3
+        raise ArgumentError, "This key must have a length of 3 or greater"
+      end
+
+      key.map! { |bit| bit.to_sym }
+
+      unless @@qualities.include? key[0]
+        raise NameError, 'Must include a valid Quality'
+      end
+      unless @@tradabilities.include? key[1]
+        raise NameError, 'Must include a valid Tradability'
+      end
+      unless @@craftabilities.include? key[2]
+        raise NameError, 'Must include a valid Craftability'
+      end
+
+      key
+    end
+
+    def validate_attributes attributes
+
+      raise TypeError unless attributes.class == Hash
+
+      unless @@required_keys.all? { |k| attributes.keys.member? k }
+        msg = "The passed-in hash is required to have at least these 4 keys: "
+        msg += "#{self.class.required_keys.join(', ')}"
+        raise KeyError, msg
+      end
+
+      attributes
+
     end
 
   end

data/lib/backpack_tf/response.rb

@@ -32,6 +32,9 @@ module BackpackTF
       @responses
     end
 
+    def self.response
+    end
+
     # checks the data type of the keys of a Hash object
     # if the key is a String, then changes it to a Symbol
     # otherwise, leaves it as is

data/lib/backpack_tf/version.rb

@@ -1,3 +1,3 @@
 module BackpackTF
-  VERSION = "0.8.1"
+  VERSION = "0.8.4"
 end

data/spec/backpack_tf/client_spec.rb

@@ -100,6 +100,13 @@ module BackpackTF
         expect(Currency.currencies).to be_nil
       end
 
+      after :each do
+        Response.responses(:reset => :confirm)
+        expect(Response.responses).to be_empty
+        expect(Currency.response).to be_nil
+        expect(Currency.currencies).to be_nil
+      end
+
       let(:fetched_currencies) {
         bp.fetch(:currencies, {:compress => 1, :appid => 440})
       }

data/spec/backpack_tf/currency_spec.rb

@@ -16,70 +16,57 @@ module BackpackTF
       Response.hash_keys_to_sym(fixture)
     }
 
-    it 'responds to these methods' do
-      expect(described_class).to respond_to :responses, :response, :currencies, :interface, :hash_keys_to_sym
-    end
-
-    it 'has these default attributes' do
+    it 'class has these default attributes' do
       expect(described_class.interface).to eq :IGetCurrencies
     end
 
-    describe '::responses' do
-
-      before :each do
-        stub_http_response_with('currencies.json')
-        opts = { :app_id => 440, :compress => 1 }
-        fetched_currencies = bp.fetch(:currencies, opts)
-        Response.responses(described_class.to_sym => fetched_currencies)
-      end
-
-      context 'access from Response class' do
-        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 Currency class' do
-        it 'can access response information via the class method, ::response' do
-          expect(described_class.response).to eq json_obj
-        end
-      end
-
-      it 'is the same as calling Currency.response' do
-        expect(Response.responses[:'BackpackTF::Currency']).to eq Currency.response
+    describe '::response' do
+      before :all do
+        expect(described_class.response).to be_nil
       end
-    end
 
-    describe '::response' do
       before :each do
         stub_http_response_with('currencies.json')
-        opts = { :app_id => 440, :compress => 1 }
-        fetched_currencies = bp.fetch(:currencies, opts)
-        Response.responses(':BackpackTF::Currency' => fetched_currencies)
+        fetched_currencies = bp.fetch(:currencies)
+        bp.update(described_class, fetched_currencies)
       end
-      it 'the response attribute should have these keys' do
-        expect(described_class.response.keys).to match_array [:success, :current_time, :currencies, :name, :url]
+
+      after :all do
+        Response.responses(:reset => :confirm)
+        expect(Response.responses).to be_empty
+        expect(described_class.response).to be_nil
+        expect(described_class.currencies).to be_nil
       end
 
       it 'the keys of the response attribute should have these values' do
-        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'
+        response = described_class.response
+        expect(response[:success]).to eq 1
+        expect(response[:message]).to eq nil
+        expect(response[:current_time]).to eq 1430784460
+        expect(response[:name]).to eq 'Team Fortress 2'
+        expect(response[:url]).to eq 'http://backpack.tf'
       end
-
     end
 
     describe '::currencies' do
+      before :all do
+        expect(described_class.response).to be_nil
+        expect(described_class.currencies).to be_nil
+      end
+
       before :each do
         Response.responses(:reset => :confirm)
         expect(Response.responses).to be_empty
 
         stub_http_response_with('currencies.json')
-        opts = { :app_id => 440, :compress => 1 }
-        fetched_currencies = bp.fetch(:currencies, opts)
-        Response.responses(:'BackpackTF::Currency' => fetched_currencies)
+        fetched_currencies = bp.fetch(:currencies)
+        bp.update(described_class, fetched_currencies)
+      end
+
+      after :all do
+        Response.responses(:reset => :confirm)
+        expect(Response.responses).to be_empty
+        described_class.class_eval { @currencies = nil }
       end
 
       it 'returns the fixture and sets to @@currencies variable' do
@@ -96,26 +83,43 @@ module BackpackTF
       end
     end
 
-    describe 'instance of Currency' do
+    describe '#initialize' do
+
+      before :all do
+        expect(described_class.response).to be_nil
+        expect(described_class.currencies).to be_nil
+      end
 
-      let (:metal) { described_class.new(:metal, Currency.currencies[:metal]) }
+      before :each do
+        bp.update(described_class, json_obj)
+        expect(described_class.currencies).not_to be_nil
+      end
 
-      it 'should respond to these methods' do
-        expect(metal).to respond_to(:quality, :priceindex, :single, :plural, :round, :craftable, :tradable, :defindex, :blanket)
+      after :all do
+        Response.responses(:reset => :confirm)
+        expect(Response.responses).to be_empty
+        described_class.class_eval { @currencies = nil }
       end
 
-      it 'should have these values' do
-        expect(metal.quality).to eq 6
-        expect(metal.priceindex).to eq 0
-        expect(metal.single).to eq 'ref'
-        expect(metal.plural).to eq 'ref'
-        expect(metal.round).to eq 2
-        expect(metal.craftable).to eq :Craftable
-        expect(metal.tradable).to eq :Tradable
-        expect(metal.defindex).to eq 5002
-        expect(metal.blanket).to eq 0
+      subject {
+        described_class.new(:metal, described_class.currencies[:metal])
+      }
+
+      it 'instance should respond to these methods' do
+        expect(subject).to respond_to(:quality, :priceindex, :single, :plural, :round, :craftable, :tradable, :defindex, :blanket)
       end
 
+      it 'instance should have these values' do
+        expect(subject.quality).to eq 6
+        expect(subject.priceindex).to eq 0
+        expect(subject.single).to eq 'ref'
+        expect(subject.plural).to eq 'ref'
+        expect(subject.round).to eq 2
+        expect(subject.craftable).to eq :Craftable
+        expect(subject.tradable).to eq :Tradable
+        expect(subject.defindex).to eq 5002
+        expect(subject.blanket).to eq 0
+      end
     end
 
   end