backpack_tf 0.2.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5b3f89b16c6ef3907403d7a9caab7457e740bd02
-  data.tar.gz: e41e8dbf4ba4bc3db93a40197cac519e22d3b106
+  metadata.gz: c0bb160d7663670acc3d14ca49f79e5fc97f8387
+  data.tar.gz: d928ca0ec022d0e73cebb5bd174dac654621623e
 SHA512:
-  metadata.gz: 29b1583190c592fcba721473e9800d1b9ed2d7b80a2d841917469513ef9db6e73a66ae3ac6c1e044718024f6e04f2192b1440d6da26234075c3a4deff332566e
-  data.tar.gz: 83f26e2dafd51d449cf205d6244a0575afe9e882a017dec8b8e86b88fb7ab30257c2d40d2ed6d983995c00fc63683ba7409eec4b0ea20f4a10527c966822cb39
+  metadata.gz: 5e10182770c9739e8ff40067e3da906923be2b2684a664e8e8d56fe9885e5dd1dda9c22b83fe95e22ee31bae202944e38a9ac81c9aa0b6beb6ba234c1ce9273e
+  data.tar.gz: e0f8b763197c2f372385f090d4d9caa2d61688da1c37efeab0ae2ce37e5cffe1cc14d0a78d6b5ec23cb6918eae3cc4b39b44f35b48655ceedd47997ff2e1af1d

data/.gitignore

@@ -1,6 +1,7 @@
 *.sw*
 *dump.rdb
 
+.ruby-version
 *.gem
 Gemfile.lock
 

data/backpack_tf.gemspec

@@ -1,16 +1,19 @@
+require_relative './lib/backpack_tf/version.rb'
+
 Gem::Specification.new do |s|
   s.name          = 'backpack_tf'
-  s.version       = '0.2.1'
-  s.date          = '2015-05-01'
+  s.date          = '2015-05-07'
   s.summary       = 'a wrapper for the backpack.tf API'
   s.author        = 'Rafael Espinoza'
   s.email         = 'rafael@rafaelespinoza.com'
   s.homepage      = 'https://github.com/NerdDiffer/backpack_tf'
   s.license       = 'MIT'
-  s.description   = s.summary
+  s.description   = 'API client, accessor methods for backpack.tf'
 
   s.require_paths = ['lib']
   s.files         = `git ls-files`.split("\n")
+  s.version       = BackpackTF::VERSION
+  s.required_ruby_version = '>=1.9.3'
 
   s.add_runtime_dependency 'httparty',    '~>0.13',   '>=0.13.3'
 

data/lib/backpack_tf/client.rb

@@ -34,21 +34,24 @@ module BackpackTF
   
     def self.build_url_via action, query_options = {}
       case action
-      when :get_prices
+      when :get_prices, :prices
         version = 4
         interface_url = "/#{Prices.interface}/v#{version}/?"
-      when :get_currencies
+      when :get_currencies, :currencies
         version = 1
         interface_url = "/#{Currencies.interface}/v#{version}/?"
-      when :get_special_items
-        version = 1
-        interface_url = "/IGetSpecialItems/v#{version}/?"
-      when :get_users
-        version = 3
-        interface_url = "/IGetUsers/v#{version}/?"
-      when :get_user_listings
-        version = 1
-        interface_url = "/IGetUserListings/v#{version}/?"
+      when :get_special_items, :special_items
+        raise RuntimeError, "Unfortunately, this interface is not yet supported."
+        #version = 1
+        #interface_url = "/IGetSpecialItems/v#{version}/?"
+      when :get_users, :users
+        raise RuntimeError, "Unfortunately, this interface is not yet supported."
+        #version = 3
+        #interface_url = "/IGetUsers/v#{version}/?"
+      when :get_user_listings, :user_listings
+        raise RuntimeError, "Unfortunately, this interface is not yet supported."
+        #version = 1
+        #interface_url = "/IGetUserListings/v#{version}/?"
       else
         raise ArgumentError, 'pass in valid action as a Symbol object'
       end
@@ -75,15 +78,32 @@ module BackpackTF
       @db = nil 
     end
   
+    def fetch interface, query_options = {}
+      get_data(interface, query_options)['response']
+    end
+
+    def update class_to_update, data_to_update
+      send_update_to_master_hash(class_to_update, data_to_update)
+      refresh_class_hash(class_to_update)
+    end
+  
+    private
+  
+    def send_update_to_master_hash class_to_update, data_to_update
+      Response.responses( { class_to_update.to_sym => data_to_update } )
+    end
+
+    def refresh_class_hash class_to_update
+      class_to_update.response
+    end
+
     def get_data action, query_options = {}
       handle_timeouts do
         url = self.class.build_url_via(action, query_options)
-        self.class.get(url)#['response']
+        self.class.get(url)
       end
     end
-  
-    private
-  
+
     # HTTParty raises an errors after time limit defined by ::default_timeout
     # * if it cannot connect to server, then it raises Net::OpenTimeout
     # * if it cannot read response from server, then it raises Net::ReadTimeout
@@ -95,7 +115,6 @@ module BackpackTF
         {}
       end
     end
-  
 
   end
 

data/lib/backpack_tf/currencies.rb

@@ -2,18 +2,25 @@ module BackpackTF
 
   # ruby representations of a JSON response to
   # `IGetCurrencies`['response']
-  class Currencies
+  class Currencies < Response
 
     ###########################
     #     Class Methods
     ###########################
 
-    include BackpackTF::Response
+    INTERFACE = :IGetCurrencies
+    @interface = INTERFACE
+    @response = nil
+    @@currencies = nil
 
-    @interface = :IGetCurrencies
+    def self.response
+      @response = superclass.responses[to_sym]
+    end
 
     def self.currencies
-      @@currencies = hash_keys_to_sym(@response[:currencies])
+      return @response if @response.nil?
+      @@currencies = response[:currencies]
+      hash_keys_to_sym(@@currencies)
     end
 
     ###########################

data/lib/backpack_tf/finder.rb

@@ -0,0 +1,87 @@
+module BackpackTF
+  module Finder
+
+    def self.included(other)
+      other.extend(ClassMethods)
+      super
+    end
+
+    module ClassMethods
+      # returns JSON data for the item
+      # does not return data for items with a special particle effect
+      def get_item_price quality, item_name
+        item = find_item_by_name(item_name)
+        ind = @@qualities.find_index(quality)
+
+        prefix = item['prices'][ind.to_s]['Tradable']
+        if prefix.nil?
+          raise(ArgumentError, "The item, #{quality} #{item_name}, is not Tradable")
+        end
+        prefix = prefix['Craftable']
+        if prefix.nil?
+          raise(ArgumentError, "The item, #{quality} #{item_name}, is not Craftable")
+        end
+
+        # oddly, there are cases (such as the "Lugermorph"), where the 
+        # type of the object at this point in the JSON data (saved to the `prefix` variable) 
+        # is a Hash object rather than an Array object.
+        # That makes the PriceIndex key a String, "0", rather than a Fixnum, 0.
+        if prefix[0].nil?
+          prefix[0.to_s] 
+        else
+          prefix[0]
+        end
+      end
+
+      def defindex_to_item_name defindex
+        items = get_items_hash
+        keys = items.keys#.shuffle
+
+        i = 0
+        while i < keys.length
+          current_defindex = items[keys[i]]['defindex']
+          if(current_defindex[0] == defindex)
+            return keys[i]
+          end
+          i += 1
+        end
+        raise KeyError, "item with a defindex of #{defindex} was not found"
+      end
+
+      def get_name_of_random_item
+        items = get_items_hash
+        items.keys.sample
+      end
+
+      # returns JSON representation of pricing for the item
+      def find_item_by_name item_name
+        items = get_items_hash
+        if items[item_name].nil?
+          raise KeyError, "item with the name #{item_name} was not found"
+        else
+          items[item_name]
+        end
+      end
+
+      # @param [String] item_name, the item name (according to item_name of item's schema)
+      # @param [Symbol] type, checking to see if item is of this type
+      # @return [Boolean] `true` if the item is the type
+      def is_item_of_type? item_name, type = :weapon
+        item = find_item_by_name(item_name)
+        defindex = item['defindex'][0]
+        tf2_item = Trade.tf2_item_schema.items[defindex]
+
+        case type
+        when :cosmetic
+          tf2_item[:item_class] == 'tf_wearable'
+        else
+          tf2_item[:item_slot] == 'primary' ||
+            tf2_item[:item_slot] == 'secondary' ||
+            tf2_item[:item_slot] == 'melee'
+        end
+      end
+
+    end
+
+  end
+end

data/lib/backpack_tf/item.rb

@@ -2,6 +2,35 @@ module BackpackTF
 
   class Item
 
+    include BackpackTF::Finder
+
+    ###########################
+    #     Class Methods
+    ###########################
+
+    #def self.generate_price_keys item_hash
+    #  raise TypeError unless item_hash.class == Hash
+    #  prices = item_hash['prices']
+
+    #  prices.each_pair.inject([]) do |gen_keys, (key, val)|
+    #    quality = BackpackTF::ItemPrice.qualities[key.to_i]
+    #    new_key = [quality.to_s]
+
+    #    tradability = val.keys.first
+    #    new_key << tradability
+
+    #    craftability = prices[key][tradability].keys.first
+    #    new_key << craftability
+
+    #    gen_keys << new_key.join('_')
+    #  end
+
+    #end
+
+    ###########################
+    #     Instance Methods
+    ###########################
+
     # @return [String] the name of item
     attr_reader :item_name
     # @return [Fixnum] the index on which you can link this item to Team Fortress 2's Item Schema
@@ -10,9 +39,61 @@ module BackpackTF
     attr_reader :prices
 
     def initialize item_name, attr
-      @item_name = item_name
-      @defindex = attr['defindex'][0]
-      @prices = nil
+      @item_name  = item_name
+
+      unless attr.class == Hash
+        attr = JSON.parse(attr) 
+      end
+
+      @defindex   = attr['defindex'][0]
+      @prices     = gen_prices_hash(attr)
+    end
+
+    def gen_prices_hash input_hash
+
+      raise TypeError, 'expecting a Hash object' unless input_hash.class == Hash
+      unless input_hash.has_key? 'prices'
+        msg = "input_hash must be at the one level above the point where 'prices' is a key in the JSON hash"
+        raise KeyError, msg
+      end
+
+      prices = input_hash['prices']
+
+      prices.inject({}) do |hash, (key, val)|
+        quality = BackpackTF::ItemPrice.qualities[key.to_i]
+        new_key = [quality.to_s]
+
+        tradability = val.keys.first
+        new_key << tradability
+
+        craftability = prices[key][tradability].keys.first
+        new_key << craftability
+
+        new_key = new_key.join('_')
+
+        prefix = prices[key][tradability][craftability]
+
+        if prefix.class == Array
+          item_prices = prefix.first
+          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
+          end
+        end
+
+        hash
+      end
     end
 
   end

data/lib/backpack_tf/item_price.rb

@@ -2,62 +2,81 @@ module BackpackTF
 
   class ItemPrice
 
-    attr_reader :quality, :tradability, :craftability, :priceindex,
-      :currency, :value, :value_high, :value_raw, :value_high_raw,
-      :last_update, :difference
+    include BackpackTF::Finder
 
-    def initialize
+    # @return [String] the quality of the item being priced, converted to String
+    attr_reader :quality
+    # @return [Symbol] either :Tradable or :'Non-Tradable'
+    attr_reader :tradability
+    # @return [Symbol] either :Craftable or :'Non-Craftable'
+    attr_reader :craftability
+    # @return [NilClass or Fixnum] Primarily used to signify crate series or unusual effect. Otherwise, this is 0
+    attr_reader :priceindex
+    # @return [Symbol] The currency that the item's price is based on
+    attr_reader :currency
+    # @return [Float] The value of the item in said currency
+    attr_reader :value
+    # @return [Float] The item's upper value measured in said currency. only set if the item has a price range
+    attr_reader :value_high
+    # @return [Float] The item's value in the lowest currency without rounding. If raw is set to 2, this is the lower value if a high value exists. Otherwise, this is the average between the high and low value. Requires raw to be enabled. 
+    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
+    attr_reader :last_update
+    # @return [Fixnum]  A relative difference between the former price and the current price. If 0, assume new price.
+    attr_reader :difference
+
+    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('_')
+
+      @priceindex     = priceindex
+
+      @quality        = key_split[0].to_sym
+      @tradability    = key_split[1].to_sym
+      @craftability   = key_split[2].to_sym
+      @currency       = attr['currency'].to_sym
+      @value          = attr['value']
+      @value_high     = attr['value_high']
+      @value_raw      = attr['value_raw']
+      @value_high_raw = attr['value_high_raw']
+      @last_update    = attr['last_update']
+      @difference     = attr['difference']
     end
 
+    @@required_keys = %w(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 = [
-      'Normal',
-      'Genuine',
+      :Normal,
+      :Genuine,
       nil,
-      'Vintage',
+      :Vintage,
       nil,
-      'Unusual',
-      'Unique',
-      'Community',
-      'Valve',
-      'Self-Made',
+      :Unusual,
+      :Unique,
+      :Community,
+      :Valve,
+      :"Self-Made",
       nil,
-      'Strange',
+      :Strange,
       nil,
-      'Haunted',
-      "Collector's"
+      :Haunted,
+      :"Collector's"
     ]
 
-    @@tradabilities = [:Tradable, :Untradable]
-    @@craftabilities = [:Craftable, :Uncraftable]
-    
-    # returns JSON data for the item
-    # does not return data for items with a special particle effect
-    def self.get_item_price quality, item_name
-      item = find_item_by_name(item_name)
-      ind = @@qualities.find_index(quality)
-
-      prefix = item['prices'][ind.to_s]['Tradable']
-      if prefix.nil?
-        raise(ArgumentError, "The item, #{quality} #{item_name}, is not Tradable")
-      end
-      prefix = prefix['Craftable']
-      if prefix.nil?
-        raise(ArgumentError, "The item, #{quality} #{item_name}, is not Craftable")
-      end
-
-      # oddly, there are cases (such as the "Lugermorph"), where the 
-      # type of the object at this point in the JSON data (saved to the `prefix` variable) 
-      # is a Hash object rather than an Array object.
-      # That makes the PriceIndex key a String, "0", rather than a Fixnum, 0.
-      if prefix[0].nil?
-        prefix[0.to_s] 
-      else
-        prefix[0]
-      end
-    end
+    def self.qualities; @@qualities; end
 
+    @@tradabilities = [:Tradable, :'Non-Tradable']
+    @@craftabilities = [:Craftable, :'Non-Craftable']
+    
   end
 
 end

data/lib/backpack_tf/prices.rb

@@ -2,66 +2,45 @@ module BackpackTF
 
   # ruby representations of a JSON response to
   # `IGetPrices`['response']
-  class Prices
+  class Prices < Response
 
-    include BackpackTF::Response
+    include BackpackTF::Finder
 
-    @interface = :IGetPrices
+    INTERFACE = :IGetPrices
+    @interface = INTERFACE
+    @response = nil
+    @@items = nil
 
-    def self.items
-      @@items = @response[:items]
-    end
-
-    def self.defindex_to_item_name defindex
-      items = get_items_hash
-      keys = items.keys#.shuffle
-
-      i = 0
-      while i < keys.length
-        current_defindex = items[keys[i]]['defindex']
-        if(current_defindex[0] == defindex)
-          return keys[i]
-        end
-        i += 1
-      end
-      raise KeyError, "item with a defindex of #{defindex} was not found"
+    def self.response
+      @response = superclass.responses[to_sym]
     end
 
-    def self.get_name_of_random_item
-      items = get_items_hash
-      items.keys.sample
-    end
-
-    # returns JSON representation of pricing for the item
-    def self.find_item_by_name item_name
-      items = get_items_hash
-      if items[item_name].nil?
-        raise KeyError, "item with the name #{item_name} was not found"
+    def self.items
+      if @@items.nil?
+        gen_items
       else
-        items[item_name]
+        @@items
       end
     end
 
-    # @param [String] item_name, the item name (according to item_name of item's schema)
-    # @param [Symbol] type, checking to see if item is of this type
-    # @return [Boolean] `true` if the item is the type
-    def self.is_item_of_type? item_name, type = :weapon
-      item = find_item_by_name(item_name)
-      defindex = item['defindex'][0]
-      tf2_item = Trade.tf2_item_schema.items[defindex]
+    def self.gen_items
+      @@items = @response[:items].inject({}) do |items, (name)|
+        defindex = @response[:items][name]['defindex'][0]
 
-      case type
-      when :cosmetic
-        tf2_item[:item_class] == 'tf_wearable'
-      else
-        tf2_item[:item_slot] == 'primary' ||
-          tf2_item[:item_slot] == 'secondary' ||
-          tf2_item[:item_slot] == 'melee'
+        if defindex.nil? || defindex < 0
+          items
+        else
+          items[name] = Item.new(name, @response[:items][name])
+          items
+        end
       end
     end
 
     def initialize
-      msg = "This class is meant to receive the JSON response from the #{self.class.interface} interface. It holds a Hash array of prices of items, but not is meant to be instantiated. See the Item class if you are interested in an item. However, information on items should be stored in the @items property of #{self.class}"
+      msg = "This class is meant to receive the JSON response from the #{self.class.interface} interface."
+      msg << "It holds a Hash array of prices of items, but not is meant to be instantiated."
+      msg << "See the Item class if you are interested in an item."
+      msg << "However, information on items should be stored in the @items property of #{self.class}."
       raise RuntimeError, msg
     end
 

data/lib/backpack_tf/response.rb

@@ -1,43 +1,48 @@
 module BackpackTF
-  module Response
+  class Response
 
-    def self.included(other)
-      puts "#{self} included in (#{other})"
-      other.extend(ClassMethods)
-      super
+    ############################
+    # CLASS METHODS
+    ############################
+
+    def self.interface; @interface; end
+
+    def self.to_sym
+      self.name.to_sym
     end
 
-    module ClassMethods
+    @responses = {}
 
-      @response = nil
-      def interface; @interface; end
+    def self.responses key_val = nil
+      unless key_val.nil?
+        key_val = { key_val => nil } unless key_val.class == Hash
+        key = key_val.keys.first
+        val = key_val.values.first
 
-      def response force_update = false
-        # if force is true, set value of @response to results of ::fetch
-        # otherwise, use a `nil guard` to return @response
-        #   if the value is already set, then it returns value of @response
-        #   if the value is not set, then it runs ::fetch
-        force_update ?
-          @response = fetch :
-          @response ||= fetch
-      end
+        if val.nil?
+          @responses[key]
+        elsif key == :reset && val == :confirm
+          @responses = {}
+        else
+          @responses[key] = hash_keys_to_sym(val)
+        end
 
-      def fetch client_stuff
-        @response = hash_keys_to_sym(client_stuff)
       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
-      def hash_keys_to_sym hash
-        hash.each_pair.inject({}) do |new_hash, (key, val)|
-          unless key.class == String
-            new_hash[key] = val
-          else
-            new_hash[key.to_sym] = val
-          end
-          new_hash
+      @responses
+    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
+    def self.hash_keys_to_sym hash
+      hash.each_pair.inject({}) do |new_hash, (key, val)|
+        unless key.class == String
+          new_hash[key] = val
+        else
+          new_hash[key.to_sym] = val
         end
+        new_hash
       end
     end
 

data/lib/backpack_tf/version.rb

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

data/lib/backpack_tf.rb

@@ -1,5 +1,4 @@
 require 'httparty'
-require 'byebug'
 
 # namespace for classes & modules inside of the wrapper for the BackpackTF API
 module BackpackTF
@@ -7,7 +6,9 @@ module BackpackTF
 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/item'