hots_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 85fa5449294a897c754bd86e1b20a40fa582be9b
+  data.tar.gz: 4a9d18c63be08574f5e655df491aab57faf55186
+SHA512:
+  metadata.gz: ec51284bc413a0d7e21be5869e09ae8af8e4f475cc14ec0a0f61cc0dded102975996f1c230f8398c6a08a2e3b831c4398a13af4f2d3f21d0a81dbb22f54911e9
+  data.tar.gz: 6630b7edadd30698a5e9d6026e46e6efff162a410619a42496d527a68fc8ff95ade71f688995b1896b7eb75dc60ec7145314ae966138aae19a1e9172965b0adf

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,12 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4
+  - 2.3
+  - 2.2
+  - ruby-head
+before_install: gem update bundler
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+script: bin/rspec

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'pry'
+gem 'pry-doc'
+gem 'rspec'
+gem 'rspec-collection_matchers'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Tobias Bühlmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,197 @@
+# HotsApi
+
+[![Build Status](https://travis-ci.org/tbuehlmann/hots_api.svg?branch=master)](https://travis-ci.org/tbuehlmann/hots_api)
+
+HotsApi is an API client for the Heroes of the Storm replay metadata API [hotsapi.net](http://hotsapi.net/). It consumes the API and lets you retrieve information about uploaded replays.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hots_api'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install hots_api
+
+## Finding Replays
+
+#### Finding a Single Replay
+
+```ruby
+replay = HotsApi.replays.find(59) # => #<HotsApi::Models::Replay>
+replay.id           # => 59
+replay.filename     # => '04e92942-7a46-f12c-24f6-65dcf4ea409f'
+replay.fingerprint  # => '04e92942-7a46-2cf1-24f6-65dcf4ea409f'
+replay.game_date    # => 2017-08-15 23:16:28 +0200
+replay.game_length  # => 872
+replay.game_map     # => 'Braxis Holdout'
+replay.game_type    # => 'HeroLeague'
+replay.game_version # => '2.27.1.56361'
+replay.players      # => [#<HotsApi::Models::Player>, …]
+
+player = replay.players[0] # => #<HotsApi::Models::Player>
+player.blizz_id   # => 215378
+player.battletag  # => 'Poma'
+player.hero       # => 'Chromie'
+player.hero_level # => 13
+player.team       # => 0
+player.winner     # => true
+```
+
+#### Finding Replays
+
+```ruby
+replays = HotsApi.replays.to_a # => [#<HotsApi::Models::Replay>, …]
+```
+
+#### Filtering Replays
+
+```ruby
+# by game date
+replays = HotsApi.replays.where(start_date: '2017-09-01 00:00').to_a
+replays = HotsApi.replays.where(end_date: '2017-09-01 00:00').to_a
+
+# by game type
+replays = HotsApi.replays.where(game_type: 'HeroLeague').to_a
+
+# by id
+replays = HotsApi.replays.where(min_id: 1000).to_a
+
+# by player
+replays = HotsApi.replays.where(player: 'Poma').to_a
+
+# by hero
+replays = HotsApi.replays.where(hero: 'Tassadar').to_a
+
+# conditions are chainable
+replays = HotsApi.replays.where(start_date: '2017-09-01 00:00', end_date: '2017-09-01 23:59').where(game_type: 'HeroLeague').to_a
+```
+
+#### Include Players
+
+Replays don't include its players per default. If you want to include players, use `with_players` (which is also chainable):
+
+```ruby
+replays = HotsApi.replays.with_players.to_a
+replays = HotsApi.replays.where(start_date: '2017-09-01 00:00').with_players.to_a
+```
+
+#### Pagination
+
+The API returns a maximum of 100 replays per request. If you want to retrieve all replays for a given query, use `find_each`:
+
+```ruby
+HotsApi.replays.where(start_date: '2017-09-01 00:00', end_date: '2017-09-01 23:59').find_each do |replay|
+  # …
+end
+
+# or
+
+replays = HotsApi.replays.where(start_date: '2017-09-01 00:00', end_date: '2017-09-01 23:59').find_each.to_a
+```
+
+Note that this might take some time, depending on the query's replay count.
+
+## Replay Utilities
+
+#### Uploading Replays
+
+```ruby
+uploaded_replay = HotsApi.replays.upload('/path/to/Garden of Terror.StormReplay') # => #<HotsApi::Models::UploadedReplay>
+uploaded_replay.id            # => 2431959
+uploaded_replay.filename      # => '1745472b-94a0-2b2d-3f14-8794717545fc'
+uploaded_replay.original_name # => 'Garden of Terror.StormReplay'
+uploaded_replay.status        # => 'duplicate'
+uploaded_replay.success       # => true
+uploaded_replay.url           # => 'http://hotsapi.s3-website-eu-west-1.amazonaws.com/1745472b-94a0-2b2d-3f14-8794717545fc.StormReplay'
+```
+
+You can also retrieve the replay for a given uploaded replay:
+
+```ruby
+uploaded_replay.replay # => #<HotsApi::Models::Replay>
+```
+
+#### Checking for Replay Existence
+
+Check whether a given replay was uploaded by its fingerprint:
+
+```ruby
+HotsApi.replays.fingerprint_uploaded?('04e92942-7a46-2cf1-24f6-65dcf4ea409f') # => true
+HotsApi.replays.fingerprint_uploaded?('non-existing-fingerprint') # => false
+```
+
+Check whether given replays were uploaded by its fingerprints:
+
+```ruby
+fingerprints = ['04e92942-7a46-2cf1-24f6-65dcf4ea409f', 'non-existing-fingerprint']
+HotsApi.replays.fingerprints_uploaded?(fingerprints) # => {'04e92942-7a46-2cf1-24f6-65dcf4ea409f' => true, 'non-existing-fingerprint' => false}
+```
+
+#### Triggering HotsLogs Uploads
+
+If there's a replay saved on HotsApi, you can trigger uploading it to HotsLogs by its fingerprint:
+
+```ruby
+fingerprint = '04e92942-7a46-2cf1-24f6-65dcf4ea409f'
+upload_triggered = HotsApi.replays.trigger_hotslogs_upload(fingerprint)
+
+if upload_triggered
+  puts 'Triggered HotsLogs upload'
+else
+  puts 'Replay for given fingerprint does not exist'
+end
+```
+
+The actual uploading to HotsLogs happens from the HotsApi server.
+
+#### Getting The Minimal Supported Build Version
+
+```ruby
+HotsApi.replays.minimum_supported_build # => 43905
+```
+
+## Finding Hero Translations
+
+```ruby
+hero_translations = HotsApi.hero_translations.to_a # => [#<HotsApi::Models::HeroTranslation>, …]
+
+hero_translation = hero_translations[0] # => #<HotsApi::Models::HeroTranslation>
+hero_translation.name     # => 'Abathur'
+hero_translation.versions # => ['abatur', 'абатур', '아바투르', '阿巴瑟', 'abathur']
+```
+
+## Finding Map Translations
+
+```ruby
+map_translations = HotsApi.map_translations.to_a # => [#<HotsApi::Models::MapTranslation>, …]
+
+map_translation = map_translations[0] # => #<HotsApi::Models::MapTranslation>
+map_translation.name     # => 'Battlefield of Eternity'
+map_translation.versions # => ["campo de batalha da eternidade", "campo de batalla de la eternidad", "永恆戰場", "永恒战场", "영원의 전쟁터", "campos de batalla de la eternidad", "schlachtfeld der ewigkeit", "champs de l’éternité", "вечная битва", "campi di battaglia eterni", "pole bitewne wieczności", "battlefield of eternity"]
+```
+
+## Rate Limiting
+
+The API probably uses some kind of leaky bucket algorithm for rate limiting. It allows for 300 requests in a short period of time and refills this pool of available requests every other second.
+
+When the client requests the API and hits the request rate limit, it will sleep for 0.5 seconds and try again after that. It will retry 9 times for a given query. If it hits the rate limit on its last try, it will raise a `HotsApi::Fetcher::ApiLimitReachedError`.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/tbuehlmann/hots_api).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'hots_api'
+
+require 'pry'
+Pry.start

data/bin/rspec

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+load Gem.bin_path('rspec-core', 'rspec')

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/hots_api.gemspec

@@ -0,0 +1,24 @@
+require_relative 'lib/hots_api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'hots_api'
+  spec.version       = HotsApi::VERSION
+  spec.authors       = ['Tobias Bühlmann']
+  spec.email         = ['tobias@xn--bhlmann-n2a.de']
+
+  spec.summary       = 'Client library for the hotsapi.net API'
+  spec.description   = 'hots_api is a client library for the Heroes of the Storm replay metadata API hotsapi.net.'
+  spec.homepage      = 'https://github.com/tbuehlmann/hots_api'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'virtus', '~> 1.0'
+  spec.add_dependency 'http', '~> 2.0'
+end

data/lib/hots_api.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'hots_api/fetcher'
+require_relative 'hots_api/version'
+
+require_relative 'hots_api/models/model'
+require_relative 'hots_api/models/hero_translation'
+require_relative 'hots_api/models/map_translation'
+require_relative 'hots_api/models/player'
+require_relative 'hots_api/models/replay'
+require_relative 'hots_api/models/uploaded_replay'
+
+require_relative 'hots_api/repositories/repository'
+require_relative 'hots_api/repositories/hero_translation_repository'
+require_relative 'hots_api/repositories/map_translation_repository'
+require_relative 'hots_api/repositories/replay_repository'
+
+module HotsApi
+  def self.fetcher
+    @fetcher ||= Fetcher.new
+  end
+
+  def self.get(path, params: {})
+    fetcher.get(path, params: params)
+  end
+
+  def self.post(path, body: nil, file: nil)
+    fetcher.post(path, body: body, file: file)
+  end
+
+  def self.replays
+    Repositories::ReplayRepository.new
+  end
+
+  def self.hero_translations
+    Repositories::HeroTranslationRepository.new
+  end
+
+  def self.map_translations
+    Repositories::MapTranslationRepository.new
+  end
+end

data/lib/hots_api/fetcher.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'http'
+
+module HotsApi
+  class Fetcher
+    ApiLimitReachedError = Class.new(StandardError)
+
+    attr_reader :last_response
+
+    def get(path, params: {})
+      with_retrying do
+        HTTP.get("http://hotsapi.net/api/v1/#{path}", params: params)
+      end
+    end
+
+    def post(path, body: nil, file: nil)
+      with_retrying do
+        HTTP.post("http://hotsapi.net/api/v1/#{path}", post_options_for(body: body, file: file))
+      end
+    end
+
+    private
+
+    def post_options_for(body:, file:)
+      {}.tap do |options|
+        options[:body] = body if body
+        options[:form] = {file: HTTP::FormData::File.new(file)} if file
+      end
+    end
+
+    def with_retrying(tries: 10)
+      tries.times do |try|
+        response = yield
+
+        if response.status.too_many_requests? && try < tries - 1
+          sleep 0.5
+        else
+          return @last_response = response
+        end
+      end
+
+      raise ApiLimitReachedError, "API limit reached, tried #{tries} times"
+    end
+  end
+end

data/lib/hots_api/models/hero_translation.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module HotsApi
+  module Models
+    class HeroTranslation < Model
+      attribute :name, String
+      attribute :versions, Array[String]
+    end
+  end
+end

data/lib/hots_api/models/map_translation.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module HotsApi
+  module Models
+    class MapTranslation < Model
+      attribute :name, String
+      attribute :versions, Array[String]
+    end
+  end
+end

data/lib/hots_api/models/model.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'virtus'
+
+module HotsApi
+  module Models
+    class Model
+      include Virtus.model
+    end
+  end
+end

data/lib/hots_api/models/player.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module HotsApi
+  module Models
+    class Player < Model
+      attribute :battletag, String
+      attribute :hero, String
+      attribute :hero_level, Integer
+      attribute :team, Integer
+      attribute :winner, Boolean
+      attribute :blizz_id, Integer
+    end
+  end
+end

data/lib/hots_api/models/replay.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module HotsApi
+  module Models
+    class Replay < Model
+      attribute :id, Integer
+      attribute :filename, String
+      attribute :size, Integer
+      attribute :game_type, String
+      attribute :game_date, Time
+      attribute :game_length, Integer
+      attribute :game_map, String
+      attribute :game_version, String
+      attribute :region, Integer
+      attribute :fingerprint, String
+      attribute :url, String
+      attribute :players, Array[Player]
+
+      def reload
+        tap do
+          self.attributes = HotsApi.replays.find(id).attributes
+        end
+      end
+    end
+  end
+end

data/lib/hots_api/models/uploaded_replay.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module HotsApi
+  module Models
+    class UploadedReplay < Model
+      attribute :id, Integer
+      attribute :success, Boolean
+      attribute :original_name, String
+      attribute :status, String
+      attribute :filename, String
+      attribute :url, String
+
+      def originalName=(name)
+        self.original_name = name
+      end
+
+      def replay
+        HotsApi.replays.find(id) if id
+      end
+    end
+  end
+end

data/lib/hots_api/repositories/hero_translation_repository.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module HotsApi
+  module Repositories
+    class HeroTranslationRepository < Repository
+      private
+
+      def path
+        'heroes/translations'
+      end
+
+      def model
+        Models::HeroTranslation
+      end
+    end
+  end
+end

data/lib/hots_api/repositories/map_translation_repository.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module HotsApi
+  module Repositories
+    class MapTranslationRepository < Repository
+      private
+
+      def path
+       'maps/translations'
+      end
+
+      def model
+        Models::MapTranslation
+      end
+    end
+  end
+end

data/lib/hots_api/repositories/replay_repository.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module HotsApi
+  module Repositories
+    class ReplayRepository < Repository
+      def upload(file)
+        response = HotsApi.post('replays', file: file)
+        Models::UploadedReplay.new(response.parse)
+      end
+
+      def trigger_hotslogs_upload(fingerprint)
+        HotsApi.get("replays/fingerprints/v3/#{fingerprint}", params: {uploadToHotslogs: 1}).parse['exists']
+      end
+
+      def fingerprint_uploaded?(fingerprint)
+        HotsApi.get("replays/fingerprints/v3/#{fingerprint}").parse['exists']
+      end
+
+      def fingerprints_uploaded?(fingerprints)
+        return {} if fingerprints.empty?
+
+        upload_statuses = HotsApi.post('replays/fingerprints', body: fingerprints.join("\n")).parse
+
+        {}.tap do |fingerprint_statuses|
+          upload_statuses['exists'].each do |fingerprint|
+            fingerprint_statuses[fingerprint] = true
+          end
+
+          upload_statuses['absent'].each do |fingerprint|
+            fingerprint_statuses[fingerprint] = false
+          end
+        end
+      end
+
+      def minimum_supported_build
+        HotsApi.get('replays/min-build').to_s.to_i
+      end
+
+      def with_players
+        spawn { where_values[:with_players] = 1 }
+      end
+
+      private
+
+      def start_date=(date)
+        where_values[:start_date] = date_string_for(date)
+      end
+
+      def end_date=(date)
+        where_values[:end_date] = date_string_for(date)
+      end
+
+      def game_type=(game_type)
+        where_values[:game_type] = game_type
+      end
+
+      def min_id=(id)
+        where_values[:min_id] = id
+      end
+
+      def player=(player)
+        where_values[:player] = player
+      end
+
+      def hero=(hero)
+        where_values[:hero] = hero
+      end
+
+      def date_string_for(date)
+        if date.respond_to?(:strftime)
+          date.strftime('%F %T')
+        else
+          date.to_s
+        end
+      end
+
+      def path
+        'replays'
+      end
+
+      def model
+        Models::Replay
+      end
+    end
+  end
+end

data/lib/hots_api/repositories/repository.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module HotsApi
+  module Repositories
+    class Repository
+      include Enumerable
+
+      def initialize_copy(_original)
+        @records = nil
+      end
+
+      def find(id)
+        response = HotsApi.get("#{path}/#{id}")
+
+        if response.status.ok?
+          model.new(response.parse)
+        end
+      end
+
+      def where(conditions = {})
+        spawn do
+          conditions.each do |attribute, value|
+            if respond_to?("#{attribute}=", true)
+              send("#{attribute}=", value)
+            else
+              raise "Unknown attribute: #{attribute}"
+            end
+          end
+        end
+      end
+
+      def next_page
+        if records.any?
+          where(min_id: records.last.id + 1)
+        end
+      end
+
+      def each(&block)
+        records.each(&block)
+      end
+
+      def find_each(&block)
+        find_each_enum.each(&block)
+      end
+
+      def last(n = nil)
+        n ? records.last(n) : records.last
+      end
+
+      def spawn(&block)
+        clone.tap do |repository|
+          repository.instance_exec(&block)
+        end
+      end
+
+      private
+
+      def find_each_enum
+        Enumerator.new do |yielder|
+          page = self
+
+          while page && page.any?
+            page.each { |model| yielder << model }
+            page = page.next_page
+          end
+        end
+      end
+
+      def where_values
+        @where_values ||= {}
+      end
+
+      def records
+        @records ||= fetch_records
+      end
+
+      def fetch_records
+        response = HotsApi.get(path, params: where_values)
+
+        response.parse.map do |attributes|
+          model.new(attributes)
+        end
+      end
+
+      def path
+        raise NotImplementedError
+      end
+
+      def model
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/hots_api/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HotsApi
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: hots_api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tobias Bühlmann
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: hots_api is a client library for the Heroes of the Storm replay metadata
+  API hotsapi.net.
+email:
+- tobias@xn--bhlmann-n2a.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- bin/console
+- bin/rspec
+- bin/setup
+- hots_api.gemspec
+- lib/hots_api.rb
+- lib/hots_api/fetcher.rb
+- lib/hots_api/models/hero_translation.rb
+- lib/hots_api/models/map_translation.rb
+- lib/hots_api/models/model.rb
+- lib/hots_api/models/player.rb
+- lib/hots_api/models/replay.rb
+- lib/hots_api/models/uploaded_replay.rb
+- lib/hots_api/repositories/hero_translation_repository.rb
+- lib/hots_api/repositories/map_translation_repository.rb
+- lib/hots_api/repositories/replay_repository.rb
+- lib/hots_api/repositories/repository.rb
+- lib/hots_api/version.rb
+homepage: https://github.com/tbuehlmann/hots_api
+licenses:
+- MIT
+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.6.13
+signing_key: 
+specification_version: 4
+summary: Client library for the hotsapi.net API
+test_files: []