poe-watch-api 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8bcf552167fc4cc9a0b3945ebd661e7830f3d39da65ba739a34b9dcc62f953d3
+  data.tar.gz: 0fb40c82867df71538b03e187bc09fa4b62f43007edf39d022b601c25279f434
+SHA512:
+  metadata.gz: 4c6624a5ffc9c2ea4a5ab717121e4fdc20d48bcb40d4ba5eb42996f70c314b3b331a71ac1df9b9f88d34c5a67e0dceda0d543cc36c0148003b0f2f3bc2a6e03c
+  data.tar.gz: fae8e08f03d03d1f0e2859e9d1963144df65fe5108b1ba3e0c6715328717974669dece5baa8882862d04be74a132abc6e6e1c62064d62a97eae411b1e0587cc7

data/LICENSE

@@ -0,0 +1,13 @@
+  DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE 
+                    Version 2, December 2004 
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net> 
+
+ Everyone is permitted to copy and distribute verbatim or modified 
+ copies of this license document, and changing it is allowed as long 
+ as the name is changed. 
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE 
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.

data/README.md

@@ -0,0 +1,310 @@
+# Poe Watch Ruby API
+
+A Ruby wrapper around the [poe.watch API](https://poe.watch/api). It implements the same DSL you are used to when using `ActiveRecord` but doesn't require Rails at all.
+
+Inspired by [klayveR's poe-watch-api JS wrapper](https://github.com/klayveR/poe-watch-api).
+
+## Table of content 
+
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Dependencies](#dependencies)
+- [Usage](#usage)
+  * [Items](#items)
+    + [Get all item data](#get-all-item-data)
+    + [Get multiple specific items](#get-multiple-specific-items)
+    + [Find one specific item](#find-one-specific-item)
+    + [Item properties](#item-properties)
+  * [Item price data](#item-price-data)
+    + [Price data properties](#price-data-properties)
+  * [Leagues](#leagues)
+    + [Get all league data](#get-all-league-data)
+    + [Get multiple specific leagues](#get-multiple-specific-leagues)
+    + [Find one specific league](#find-one-specific-league)
+    + [League properties](#league-properties)
+  * [Categories](#categories)
+    + [Get all categories data](#get-all-categories-data)
+    + [Get multiple specific categories](#get-multiple-specific-categories)
+    + [Find one specific category](#find-one-specific-category)
+    + [Category properties](#category-properties)
+  + [API Cache](#api-cache)
+- [Shortcomings](#shortcomings)
+- [Contribution](#contribution)
+- [License](#license)
+
+
+## Requirements
+
+- Redis: 4.0+
+- Ruby 2.3+
+
+## Installation
+
+```
+gem install poe-watch-api
+```
+
+or add it to your `Gemfile`
+
+```
+gem 'poe-watch-api'
+```
+
+## Dependencies
+
+This library has a dependency over `redis`. For it to work you need to have redis installed on your machine (and your server, in production, if using Heroku, you can use an addon like `rediscloud`).
+We use `redis` because we need to cache the data from Poe Watch to avoid refetching all the items data to often (there are almost 30k items in PoE which is quite a lot). 
+
+There are two ways of making this gem work with redis: 
+
+- Set a global `$redis` variable.
+Example:
+```ruby
+$redis = Redis.new
+
+# In production for instance if you were to use rediscloud on heroku :
+url = ENV["REDISCLOUD_URL"] # or whatever is the URL of your redis
+
+if url
+  $redis = Redis.new(:url => url)
+end
+```
+
+- Provide your own instance of redis through `PoeWatch::Api.redis = Redis.new(YOUR_PARAMS)`
+Example: 
+```ruby
+PoeWatch::Api.redis = Redis.new
+
+# In production for instance, if you were to use rediscloud on heroku:
+url = ENV["REDISCLOUD_URL"] # or whatever is the URL of your redis
+
+if url
+  PoeWatch::Api.redis = Redis.new(:url => url)
+end
+```
+
+The total footprint of the data from PoeWatch API in redis is a bit less than **2 megabytes**. You can check the exact memory footprint in your redis by calling `PoeWatch::Api.memory_footprint`, the data will be displayed in kilobytes.
+The default time to live (TTL) of the cache is 45 minutes.
+
+## Usage
+
+Here is a simple usage example:
+```
+# See the dependencies section
+PoeWatch::Api.redis = Redis.new
+
+# Non mandatory
+PoeWatch::Api.refresh!(3600) # cache for 1 hour
+
+PoeWatch::Item.find({ name: "Circle of Nostalgia }).price_for_league('Metamorph')
+```
+
+### Items
+
+#### Get all item data
+
+```ruby
+PoeWatch::Item.all # => array of PoeWatch::Item objects
+PoeWatch::Item.count  # => total number of items
+```
+
+#### Get multiple specific items 
+```ruby
+items = PoeWatch::Item.where(name: /circle/i) # Returns all items with a name containing "circle"
+
+items.first.id # => 223
+items.first.name # => "Hubris Circlet"
+```
+
+#### Find one specific item
+```ruby
+item = PoeWatch::Item.find(name: "Circle of Nostalgia") # Returns the item "Circle of Nostalgia"
+item = PoeWatch::Item.find(name: /circle/i) # Returns the first item with a name containing "circle"
+
+items.id # => 223
+items.name # => "Hubris Circlet"
+```
+
+#### Item properties
+
+All properties have an accessor you can use, e.g: `item.id`, `item.name`, `item.hardcore`. 
+All boolean properties have an additionnal question mark accessor, e.g:  `item.hardcore?`.
+
+Items only have relevant properties (e.g: map tiers only on maps, stack_size only on currencies, etc...)
+
+| Name        | Type      | Description  |
+| ----------- | --------- | ------------ |
+| id          | `Integer` | poe.watch ID |
+| name        | `String`  | name |
+| type        | `String`  | base type |
+| category    | `String`  | item category |
+| group       | `String`  | item category group |
+| frame       | `Integer` | frame type (item rarity) |
+| map_series  | `Integer` | 5 for Synthesis, 1 for Awakening, etc |
+| map_tier    | `Integer` | map tier |
+| gem_level   | `Integer` | gem level |
+| gem_quality | `Integer` | gem quality |
+| gem_is_corrupted | `Boolean` | is the gem corrupted |
+| link_count  | `Integer` | links count |
+| base_item_level | `Integer` | item level |
+| variation   | `String`  | variations of the same item (e.g: Vessel of Vinktar) |
+| enchant_min |	`Integer` | enchantment's minimum has numeric value
+| enchant_max |	`Integer` | enchantment's maximum has numeric value
+| relic       | `Integer` | whether the item is a relic or not. `true` always sets `properties.frame` to `9` |
+| icon        | `String`  | icon URL |
+| influences  | `Array`   | shaper / elder / conqueror influences |
+| stack_size  | `Integer` | default stack size of item type |
+
+
+### Item price data
+
+```ruby
+item = PoeWatch::Item.find(name: "Circle of Nostalgia")
+
+# Returns price data for all leagues
+item.prices
+
+# Returns price data for all leagues matching the name
+item.price_for_leagues("Metamorph") # => all metamorph leagues (HC / SC) price data
+
+# Returns price data for a specific league
+item.price_for_leagues("Metamorph") # => Price data for "Metamorph"
+item.price_for_leagues(/metamorph/i) # => Price data for the first metamorph league found
+```
+
+#### Price data properties
+
+| Name        | Type      | Description  |
+| ----------- | --------- | ------------ |
+| id          | `Integer` | league ID |
+| name        | `String`  | league name |
+| display     | `String`  | league display name |
+| current     | `Integer` | nb of items currently on sale |
+| daily       | `Integer` | nb of items found per 24h |
+| accepted    | `Integer` | nb of items accepted for price calculation |
+| exalted     | `Float`   | mean price in exalted |
+| max         | `Float`   | max accepted average price |
+| min         | `Float`   | min accepted average price |
+| mean        | `Float`   | mean average price |
+| median      | `Float`   | median average price |
+| mode        | `Float`   | mode average price |
+| active      | `Boolean` | is league still active |
+| start       | `String`  | league end date |
+| end         | `String`  | league end date |
+
+### Leagues
+
+#### Get all league data
+
+```ruby
+PoeWatch::League.all # => array of PoeWatch::League objects
+PoeWatch::League.count  # => total number of leagues
+```
+
+#### Get multiple specific leagues 
+```ruby
+leagues = PoeWatch::League.where(hardcore: false) # Returns all non hardcore leagues
+leagues = PoeWatch::League.where(name: /metamorph/i) # You can use regular expressions or strings for your queries
+
+leagues.first.name # => "Hardcore Metamorph"
+leagues.first.hardcore? # => true
+leagues.first.start? # => "2019-12-13T20:00:00Z"
+```
+
+#### Find one specific league
+```ruby
+league = PoeWatch::League.find(name: "Metamorph") # Return the non hardcore "Metamorph" league
+league = PoeWatch::League.find(name: /metamorph/i) # Will return the first Metamorph league found
+
+league.name # => "Metamorph"
+league.hardcore? # => false
+league.start? # => "2019-12-13T20:00:00Z"
+```
+
+#### League properties
+
+All properties have an accessor you can use, e.g: `league.id`, `league.name`, `league.hardcore`. 
+All boolean properties have an additionnal question mark accessor, e.g:  `league.hardcore?`.
+
+| Name     | Type | Description    |
+| -------- | --- | ---------------- |
+|id        | `Integer` | poe.watch ID |
+|name      | `String`  | name |
+|display   | `String`  | display name |
+|hardcore  | `Boolean`    | is hardcore |
+|active    | `Boolean`    | is active |
+|start     | `String`  | start date |
+|end       | `String`  | end date |
+|challenge | `Boolean`    | is a challenge league |
+|event     | `Boolean`    | is an event league |
+|upcoming  | `Boolean`    | is upcoming |
+
+### Categories
+
+#### Get all categories data
+
+```ruby
+PoeWatch::Categories.all # => array of PoeWatch::Category objects
+PoeWatch::Categories.count  # => total number of categories
+```
+
+#### Get multiple specific categories 
+```ruby
+categories = PoeWatch::Category.where(name: /accessory/i) # You can use regular expressions or strings for your queries
+
+categories.first.display # => "Accessories"
+```
+
+#### Find one specific category
+```ruby
+category = PoeWatch::Category.find(name: /accessory/i) # You can use regular expressions or strings for your queries
+
+category.display # => "Accessories"
+category.groups # => [#<OpenStruct id=1, name="amulet", display="Amulets">, ...]
+category.groups.first.name # => "amulet"
+```
+
+#### Category properties
+
+All properties have an accessor you can use, e.g: `category.name`, `category.groups`. 
+
+| Name     | Type | Description    |
+| -------- | --- | ---------------- |
+|id        | `Integer` | poe.watch ID |
+|name      | `String`  | name |
+|display   | `String`  | display name |
+|groups    | `Array<OpenStruct>`    | an array of item types that belongs to this category. Stored as OpenStructs so you can access them with the `.` syntax. A group has 3 attributes: `id`, `name` and `display` |
+
+### API Cache
+
+```ruby
+# Fetch all the data from poe.watch API and cache it for the next 45 minutes.
+# You don't actually need to call this. It is automatically called when using `::find`, `::where`, `::all` or `::count`, and won't do anything if the cache already contains data. 
+# Although beware that if you don't call it first, the first call to find/where/all/count every 45 minutes will take longer (around 2-4 seconds, there are quite a lot of items to fetch).
+PoeWatch::Api.refresh! 
+# You can also specify a cache TTL different than 45 minutes
+PoeWatch::Api.refresh!(3600) # 1 hour cache
+
+# If you need to force clear the cache, you can use 
+PoeWatch::Api.clear!
+
+# You can check if the cache has expired with 
+PoeWatch::Api.has_expired?
+# Or do the opposite with 
+PoeWatch::Api.ready?
+```
+
+## Shortcomings
+
+- Doing a find or where on an item will always take some time (1-2 seconds) because it has to traverse all ~30k objects from PoE to find your matches. This could probably be optimised but I haven't had the time to get around to do it. 
+- No rate limiter set for the moment so when fetching a bunch of item prices you could hit the rate limiter of `poe.watch`. I'll add one at some point in the future if is needed or requested.
+
+## Contribution
+
+The code is well documented, using [tomdoc](http://tomdoc.org/), is you wish to contribute, raise an issue or fork this project and create a pull request :).
+
+Most of the codebase is in `lib/api`, `lib/base` and `lib/item`.
+
+## License
+
+Licensed under WTFPL.

data/lib/api.rb

@@ -0,0 +1,175 @@
+# TODO: Check item fields
+# @base_is_elder=false,
+# @base_is_shaper=true,
+# @base_item_level=86,
+# @enchant_max=25,
+# @enchant_min=25,
+# corrupted field
+
+require 'redis'
+require 'uri'
+require 'net/http'
+
+# Public: Wrapper around the Poe Watch API. 
+# Uses redis to store items, leagues and categories data
+#
+# Examples
+#
+#   PoeWatch::Api.refresh! # => fetches the latest data from the API
+#
+#   PoeWatch::Item.all # => All items
+#   PoeWatch::Item.find({ name: 'Mirror of Kalandra' }).getPriceDataByLeague('Metamorph')
+#
+#   PoeWatch::League.find({ name: 'Metamorph' })
+#
+module PoeWatch
+  class Api
+    class Error < StandardError; end
+  
+    BULK_APIS = {
+      item_data: "https://api.poe.watch/itemdata",
+      categories: "https://api.poe.watch/categories",
+      leagues: "https://api.poe.watch/leagues",
+    }
+
+    ITEM_API = "https://api.poe.watch/item"
+
+    DEFAULT_EXPIRY = 45 * 60 # 45 minutes
+    
+    @updating = false
+    @redis = $redis 
+
+    class << self  
+      # Returns the redis instance, defaults to the global $redis
+      def redis
+        raise PoeWatch::Api::Error.new("You need to configure redis by either setting the global $redis variable or calling PoeWatchApi.redis = Redis.new(...)") unless (@redis || $redis)
+        @redis || $redis
+      end
+
+      # Sets the redis instance
+      def redis=(redis)
+        @redis = redis
+      end
+      
+      # Public: Count the number of items
+      #
+      # expiry - The time to live (TTL) for the redis cache, defaults to 45 minutes.
+      #
+      # Examples
+      #
+      #  PoeWatch::Api.refresh!
+      #  PoeWatch::Api.refresh!(3600) # => 1 hour cache
+      # 
+      # Returns an Integer.
+      def refresh!(expiry = DEFAULT_EXPIRY)
+        # If we are not already updating and the cache is empty
+        if !@updating && !ready?
+          #puts "Updating..."
+          @updating = true
+
+          # Fetch each API
+          BULK_APIS.each do |name, api_url|
+            raw_response = request(api_url)
+            redis.set(redis_key(name), raw_response) 
+            redis.expire(redis_key(name), expiry)
+          end
+          @updating = false    
+          true
+        else
+          return raise PoeWatch::Api::Error.new("An update is already in progress") if @updating
+          # puts "Already up to date"
+        end
+      end
+
+      # Internal: Does a get request
+      #
+      # api - api url
+      # params - a hash of params
+      # parse - if the data should be parsed as JSON or returned as String. Defaults to false.
+      #
+      # Examples
+      #
+      #  PoeWatch::Api.request(BULK_APIS[:leagues])
+      # 
+      # Returns a String or a Hash.
+      def request(api, params = {}, parse = false) 
+        uri = URI.parse(api)
+
+        if (params.any?)
+          uri.query = URI.encode_www_form(params)
+        end
+        
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request["Content-Type"] = "application/json"
+
+        http = Net::HTTP.new(uri.hostname, uri.port)
+        http.use_ssl = true
+        
+        response = http.request(request)
+        
+        raise PoeWatch::Api::Error.new("Couldn't connect to poe.watch") unless response.is_a?(Net::HTTPSuccess)
+
+        parse ? JSON.parse(response.body) : response.body
+      end
+
+      # Returns all items
+      def items
+        @items ||= get_data(:item_data)
+        @items || []
+      end
+
+      # Returns all categories
+      def categories
+        @categories ||= get_data(:categories)
+        @categories || []
+      end
+
+      # Returns all leagues
+      def leagues
+        @leagues ||= get_data(:leagues)
+        @leagues || []
+      end
+      
+      # Get data from redis and parse it to JSON
+      def get_data(type)
+        data = redis.get(redis_key(type))
+        data ? JSON.parse(data) : nil
+      end
+
+      # Clear the redis cache
+      def clear!
+        BULK_APIS.keys
+        .each { |key| redis.del(redis_key(key)) }
+      end
+      
+      # Is the cache filled?
+      def ready?
+        !has_expired?
+      end
+
+      # Check if any of the redis stored data is missing
+      def has_expired?
+        BULK_APIS.keys
+          .map { |key| redis.exists(redis_key(key)) }
+          .reject { |k| !k }
+          .empty?
+      end
+
+      # Returns the redis cache key, e.g: poe_watch_itemdata, etc...
+      def redis_key(type)
+        "poe_watch_#{type}"
+      end
+
+      # Returns the redis memory footprint for each api data (leagues, itemdata and categories) in kilobytes.
+      def memory_footprint
+        BULK_APIS.keys.map do |key| 
+          size = nil
+          if redis.exists(redis_key(key))
+            size = redis.debug("object", redis_key(key)).match(/serializedlength:(\d+)/)[1].to_i / 1024.0
+          end
+          [key, size]
+        end.to_h.compact
+      end
+    end
+  end
+end

data/lib/base.rb

@@ -0,0 +1,172 @@
+require_relative './utils'
+
+# Public: Base class for all Poe Watch items.
+# This is pretty much active record for PoeWatch.
+# It automatically fetches the necessary data and defines getters, setters as well as question mark methods for boolean values.
+# It also defines `::find(params)`, `::where(params)` and `::all` class methods.
+# 
+# Examples
+#
+#   class PoeWatch::Item < PoeWatch::Base
+#   end
+#
+module PoeWatch
+  class Base
+    INFLECTOR = {
+      category: 'categories',
+      item: 'items',
+      league: 'leagues'
+    }
+
+    class << self 
+      # Defines an instance variable that'll be memoized and used to store Poe Watch data
+      def __data 
+        if not defined? @__data
+          @__data = []
+        end
+        @__data
+      end
+
+      # Setter for instance variable
+      def __data=(value)
+        @__data = value
+      end
+
+      # Public: Gets the object type
+      #
+      # Examples
+      #
+      #  PoeWatch::League.type # => :league
+      # 
+      # Returns a Symbol.
+      def type
+        self.name.split('::').last.downcase.to_sym
+      end
+      
+      # Public: Gets all data as instance of the class
+      #
+      # Examples
+      #
+      #  PoeWatch::League.all # => array of PoeWatch::League items
+      # 
+      # Returns an Array of class instances.
+      def all
+        PoeWatch::Api.refresh!
+        
+        return __data if __data.any?
+        
+        # If data isn't already loaded
+        # puts "Loading #{type} data..."
+        json_data = PoeWatch::Api.send(INFLECTOR[type])
+        if json_data.any?
+          __data = json_data.map { |raw_data| self.new(raw_data) }
+        else
+          []
+        end
+      end
+
+      # Public: Count the number of items
+      #
+      # Examples
+      #
+      #  PoeWatch::League.count # => 30
+      # 
+      # Returns an Integer.
+      def count
+        PoeWatch::Api.refresh!
+        
+        return __data if __data.any?
+        
+        # If data isn't already loaded
+        # puts "Loading #{type} data..."
+        json_data = PoeWatch::Api.send(INFLECTOR[type])
+        if json_data.any?
+          __data = json_data.length
+        else
+          0
+        end
+      end
+
+      # Public: Gets items filtered by a query
+      # You can pass regular expressions for string parameters. It will do a match.
+      #
+      # params - A hash of parameters. Eg: { hardcore: true }
+      #
+      # Examples
+      #
+      #  PoeWatch::League.where({ hardcore: true }) # => array of PoeWatch::League items
+      #  PoeWatch::League.where({ name: /metamorph/i, hardcore: true }) # => array of PoeWatch::League items
+      # 
+      # Returns an Array of class instances.
+      def where(params)
+        PoeWatch::Api.refresh!
+        self.all.select do |element| 
+          params.map do |k, v| 
+          if v.is_a? Regexp
+            !!element.send(k).match(v)
+          else
+            element.send(k) == v 
+          end
+          end.all?(TrueClass)
+        end
+      end
+
+      # Public: Gets a specific item
+      # You can pass regular expressions for string parameters. It will do a match.
+      #
+      # params - A hash of parameters. Eg: { name: /Metamorph/, hardcore: true }
+      #
+      # Examples
+      #
+      #  PoeWatch::League.find({ name: "Metamorph", hardcore: true }) # =>PoeWatch::League item
+      # 
+      # Returns an instance of the class.
+      def find(params)
+        PoeWatch::Api.refresh!
+        self.all.find do |element| 
+          params.map do |k, v| 
+          if v.is_a? Regexp
+            !!element.send(k).match(v)
+          else
+            element.send(k) == v 
+          end
+          end.all?(TrueClass)
+        end
+      end
+    end
+
+    # Public: Initialize a Poe Watch item.
+    # It will automatically create instance variables, setters, getters for instance variables,
+    # and question mark methods for variables with boolean values.
+    # It is to note that any hash or array of hashes will be transformed into an OpenStruct.
+    #
+    # raw_data - An array of hash
+    #
+    # Returns an instance of the class.
+    def initialize(raw_data) 
+      raw_data.each do |k, v|
+        key = snakify(k)
+        if v.is_a?(Hash)
+          value = OpenStruct.new(v) 
+        elsif v.is_a?(Array) && v.first.is_a?(Hash)
+          value = v.map { |arr_val| OpenStruct.new(arr_val) }
+        else
+          value = v
+        end
+
+        instance_variable_set("@#{key}", value)
+
+        define_singleton_method key do
+          instance_variable_get("@#{key}")
+        end
+
+        # If it is a boolean we also create a `key?` method`
+        if [TrueClass, FalseClass].include?(value.class)
+          define_singleton_method "#{key}?" do
+            instance_variable_get("@#{key}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/category.rb

@@ -0,0 +1,6 @@
+require_relative './base'
+
+module PoeWatch
+  class Category < PoeWatch::Base 
+  end
+end

data/lib/item.rb

@@ -0,0 +1,19 @@
+require_relative './base'
+require_relative './price_data'
+
+module PoeWatch
+  class Item < PoeWatch::Base 
+    def prices
+      @prices ||= PoeWatch::Api.request(PoeWatch::Api::ITEM_API, { id: self.id }, true)["leagues"].map { |league_data| PoeWatch::PriceData.new(league_data) }
+    end
+
+    def price_for_leagues(name_or_regexp)
+      regexp = name_or_regexp.is_a?(String) ? Regexp.new(name_or_regexp, 'i') : name_or_regexp
+      prices.select { |data| data.name.match(regexp) }
+    end
+
+    def price_for_league(name_or_regexp)
+      prices.find { |data| name_or_regexp.is_a?(String) ? data.name.downcase == name_or_regexp.downcase : data.name.match(name_or_regexp) }
+    end
+  end
+end

data/lib/league.rb

@@ -0,0 +1,6 @@
+require_relative './base'
+
+module PoeWatch
+  class League < PoeWatch::Base 
+  end
+end

data/lib/poe_watch.rb

@@ -0,0 +1,5 @@
+require_relative './api'
+require_relative './item'
+require_relative './league'
+require_relative './category'
+

data/lib/price_data.rb

@@ -0,0 +1,4 @@
+require_relative './base'
+
+class PoeWatch::PriceData < PoeWatch::Base
+end

data/lib/utils.rb

@@ -0,0 +1,7 @@
+def snakify(string)
+  string.gsub(/::/, '/').
+  gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+  gsub(/([a-z\d])([A-Z])/,'\1_\2').
+  tr("-", "_").
+  downcase
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module PoeWatch
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: poe-watch-api
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- GabrielDehan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+description: Ruby Poe Watch API wrapper.
+email: dehan.gabriel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/api.rb
+- lib/base.rb
+- lib/category.rb
+- lib/item.rb
+- lib/league.rb
+- lib/poe_watch.rb
+- lib/price_data.rb
+- lib/utils.rb
+- lib/version.rb
+homepage: https://github.com/gabriel-dehan/poe-watch-api
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Ruby Poe Watch API wrapper.
+test_files: []