SWGOH-API 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08c450a93858d8f9ecad0bee9c8fb33c84b779d29aa5a750e535261b5e869fb5'
-  data.tar.gz: 4f86c4f8f9512351227f8e428dabf39992ca1ebdd449be3b9938ee8fdfc3ae60
+  metadata.gz: '0936d97bbc27257a609fa8780d870f1694439ef96c8ff9224fe93f74e8db77fc'
+  data.tar.gz: 7533b6ec009211503537a4d1c6ddc076546bb88e59840b3229c2570beaf35de9
 SHA512:
-  metadata.gz: f25e29323f14dab0e2fdb93fa67e8583d23a955f557622670c32242a1d148477cf7ada91420ae23148c8419183470f092eb776366fb7d442c959c0d1b2c85b7d
-  data.tar.gz: 5e766736283e5e0430b0dafeeb6ed6b2cd2f9f95ce0dc7d406d2b8c979a193cfbd3510c4d9aece83164ba76aea93bbce18dca3b8d73665e9fed45b73af887544
+  metadata.gz: aa3b5622c70b2e6935db81a7d946310f1364956c1620684bf6a32b3aa88b7d48a90af687203e6f12d949e5b5d35c2367edb1269ba66c04a44dee7434b537b46d
+  data.tar.gz: 8e6bf057f7b99a1705ae576bb092341ef0e60f27f8275fc032f11123e31f01badbb26cc286532209f920ae2aac13ed817ffb90e9a1152ffe3076ae746359724b

data/CHANGELOG.md

@@ -1,7 +1,11 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [1.0.0]
+## Added
+- Added param Hash to methods by [@jquass](https://github.com/jquass)
+- Added LOG helper class by [@jquass](https://github.com/jquass)
+- Added Requester class by [@jquass](https://github.com/jquass)
 
 ## [0.4.0] - 2020-10-16
 ## Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    SWGOH-API (0.4.0)
+    SWGOH-API (1.0.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -3,15 +3,17 @@ Ruby client wrapper for the API at https://api.swgoh.help .
 
 ### Installation
 
-Add this line to your application's Gemfile:
+Gemfile:
 
 ```ruby
-gem 'SWGOH-API'
+gem 'SWGOH-API', '~> 1.0.0'
 ```
 
-And then rake:
+Install:
 
-    $ bundle exec rake
+```ruby
+gem install SWGOH-API
+```
 
 ## Usage
 ```ruby
@@ -62,7 +64,7 @@ Run `rake test` to run the unit tests.
 These are the steps to create and tag a new version, push git commits and tags, and push the new gem version to [rubygems.org](https://rubygems.org).
 
 - Update the CHANGELOG and assign version number
-- Update the version number in `version.rb`
+- Update the version number in `version.rb`, and the README.md
 - Run `gem build SWGOH-API.gemspec` to build the new gem version
 - Run the release once to generate all files to commit `bundle exec rake release`  
 - Create a new version commit with all changes

data/lib/SWGOH/API/CLIENT/LOG/log.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+# A Logging utility class
+class LOG
+  # @param [Net::HTTPResponse] response
+  def error(response)
+    puts response.body if response.is_a?(Net::HTTPResponse)
+  end
+end

data/lib/SWGOH/API/CLIENT/client.rb

@@ -1,21 +1,15 @@
 # frozen_string_literal: true
 
 require 'SWGOH/API'
-require 'uri'
-require 'net/http'
-require 'json'
+require 'SWGOH/API/CLIENT/requester'
 
 # The CLIENT class makes requests to api.swgoh.api
 class CLIENT
-  attr_accessor :language, :enums, :structure, :project
-  attr_writer :access_token
+  attr_writer :access_token, :requester
 
   def initialize
-    @language = SWGOH::API::LANGUAGE::ENG_US
-    @enums = false
-    @structure = false
     @access_token = nil
-    @project = nil
+    @requester = REQUESTER.new
   end
 
   # @return [Boolean]
@@ -27,299 +21,279 @@ class CLIENT
   # @param [String] password
   # @return [String | nil]
   def authorize(username, password)
-    form = auth_request_form(username, password)
-    path = "https://#{SWGOH::API::PATH::BASE}/#{SWGOH::API::PATH::AUTH_SIGNIN}"
-    res = Net::HTTP.post_form(URI(path), form)
-    return log_error(res) unless res.is_a?(Net::HTTPSuccess)
-
-    @access_token = JSON.parse(res.body)['access_token']
+    response = @requester.auth_request(username, password)
+    @access_token = response['access_token'] unless response.nil?
   end
 
   # @param [Array] ally_codes
+  # @param [Hash] params
   # @return [JSON || nil]
-  def players(ally_codes)
-    ally_codes_request(SWGOH::API::PATH::PLAYER, ally_codes)
+  def players(ally_codes, params = {})
+    ally_codes_request(SWGOH::API::PATH::PLAYER, ally_codes, params)
   end
 
   # @param [Array] ally_codes
+  # @param [Hash] params
   # @return [JSON || nil]
-  def guilds(ally_codes)
-    ally_codes_request(SWGOH::API::PATH::GUILD, ally_codes)
+  def guilds(ally_codes, params = {})
+    ally_codes_request(SWGOH::API::PATH::GUILD, ally_codes, params)
   end
 
   # @param [Array] ally_codes
+  # @param [Hash] params
   # @return [JSON || nil]
-  def rosters(ally_codes)
-    ally_codes_request(SWGOH::API::PATH::ROSTER, ally_codes)
+  def rosters(ally_codes, params = {})
+    ally_codes_request(SWGOH::API::PATH::ROSTER, ally_codes, params)
   end
 
   # @param [Array] ally_codes
+  # @param [Hash] params
   # @return [JSON || nil]
-  def units(ally_codes)
-    ally_codes_request(SWGOH::API::PATH::UNITS, ally_codes)
+  def units(ally_codes, params = {})
+    ally_codes_request(SWGOH::API::PATH::UNITS, ally_codes, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def zetas
-    request(SWGOH::API::PATH::ZETAS)
+  def zetas(params = {})
+    request(SWGOH::API::PATH::ZETAS, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def squads
-    request(SWGOH::API::PATH::SQUADS)
+  def squads(params = {})
+    request(SWGOH::API::PATH::SQUADS, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def events
-    request(SWGOH::API::PATH::EVENTS)
+  def events(params = {})
+    request(SWGOH::API::PATH::EVENTS, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def battles
-    request(SWGOH::API::PATH::BATTLES)
+  def battles(params = {})
+    request(SWGOH::API::PATH::BATTLES, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def abilities
-    data_request(SWGOH::API::COLLECTION::ABILITY)
+  def abilities(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::ABILITY, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def battle_environments
-    data_request(SWGOH::API::COLLECTION::BATTLE_ENVIRONMENT)
+  def battle_environments(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::BATTLE_ENVIRONMENT, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def battle_targeting_rules
-    data_request(SWGOH::API::COLLECTION::BATTLE_TARGETING_RULE)
+  def battle_targeting_rules(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::BATTLE_TARGETING_RULE, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def categories
-    data_request(SWGOH::API::COLLECTION::CATEGORY)
+  def categories(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::CATEGORY, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def challenges
-    data_request(SWGOH::API::COLLECTION::CHALLENGE)
+  def challenges(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::CHALLENGE, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def challenge_styles
-    data_request(SWGOH::API::COLLECTION::CHALLENGE_STYLE)
+  def challenge_styles(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::CHALLENGE_STYLE, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def effects
-    data_request(SWGOH::API::COLLECTION::EFFECT)
+  def effects(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::EFFECT, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def environment_collections
-    data_request(SWGOH::API::COLLECTION::ENVIRONMENT_COLLECTION)
+  def environment_collections(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::ENVIRONMENT_COLLECTION, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def equipment
-    data_request(SWGOH::API::COLLECTION::EQUIPMENT)
+  def equipment(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::EQUIPMENT, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def event_samples
-    data_request(SWGOH::API::COLLECTION::EVENT_SAMPLING)
+  def event_samples(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::EVENT_SAMPLING, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def guild_exchange_items
-    data_request(SWGOH::API::COLLECTION::GUILD_EXCHANGE_ITEM)
+  def guild_exchange_items(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::GUILD_EXCHANGE_ITEM, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def guild_raids
-    data_request(SWGOH::API::COLLECTION::GUILD_RAID)
+  def guild_raids(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::GUILD_RAID, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def help_entries
-    data_request(SWGOH::API::COLLECTION::HELP_ENTRY)
+  def help_entries(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::HELP_ENTRY, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def materials
-    data_request(SWGOH::API::COLLECTION::MATERIAL)
+  def materials(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::MATERIAL, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def player_titles
-    data_request(SWGOH::API::COLLECTION::PLAYER_TITLE)
+  def player_titles(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::PLAYER_TITLE, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def power_up_bundles
-    data_request(SWGOH::API::COLLECTION::POWER_UP_BUNDLE)
+  def power_up_bundles(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::POWER_UP_BUNDLE, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def raid_configs
-    data_request(SWGOH::API::COLLECTION::RAID_CONFIG)
+  def raid_configs(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::RAID_CONFIG, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def recipes
-    data_request(SWGOH::API::COLLECTION::RECIPE)
+  def recipes(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::RECIPE, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def requirements
-    data_request(SWGOH::API::COLLECTION::REQUIREMENT)
+  def requirements(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::REQUIREMENT, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def skills
-    data_request(SWGOH::API::COLLECTION::SKILL)
+  def skills(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::SKILL, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def starter_guilds
-    data_request(SWGOH::API::COLLECTION::STARTER_GUILD)
+  def starter_guilds(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::STARTER_GUILD, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def stat_mods
-    data_request(SWGOH::API::COLLECTION::STAT_MOD)
+  def stat_mods(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::STAT_MOD, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def stat_mod_sets
-    data_request(SWGOH::API::COLLECTION::STAT_MOD_SET)
+  def stat_mod_sets(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::STAT_MOD_SET, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def stat_progressions
-    data_request(SWGOH::API::COLLECTION::STAT_PROGRESSION)
+  def stat_progressions(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::STAT_PROGRESSION, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def tables
-    data_request(SWGOH::API::COLLECTION::TABLE)
+  def tables(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::TABLE, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def targeting_sets
-    data_request(SWGOH::API::COLLECTION::TARGETING_SET)
+  def targeting_sets(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::TARGETING_SET, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def territory_battle_definitions
-    data_request(SWGOH::API::COLLECTION::TERRITORY_BATTLE_DEFINITION)
+  def territory_battle_definitions(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::TERRITORY_BATTLE_DEFINITION, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def territory_war_definitions
-    data_request(SWGOH::API::COLLECTION::TERRITORY_WAR_DEFINITION)
+  def territory_war_definitions(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::TERRITORY_WAR_DEFINITION, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def units_list
-    data_request(SWGOH::API::COLLECTION::UNIT)
+  def units_list(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::UNIT, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def unlock_announcement_defs
-    data_request(SWGOH::API::COLLECTION::UNLOCK_ANNOUNCEMENT_DEFINITION)
+  def unlock_announcement_defs(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::UNLOCK_ANNOUNCEMENT_DEFINITION, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def war_definitions
-    data_request(SWGOH::API::COLLECTION::WAR_DEFINITION)
+  def war_definitions(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::WAR_DEFINITION, params)
   end
 
+  # @param [Hash] params
   # @return [JSON || nil]
-  def xp_tables
-    data_request(SWGOH::API::COLLECTION::XP_TABLE)
+  def xp_tables(params = {})
+    data_collection_request(SWGOH::API::COLLECTION::XP_TABLE, params)
   end
 
   private
 
-  attr_reader :access_token
+  attr_reader :access_token, :requester
 
   # @param [PATH] path
+  # @param [Hash] params
   # @return [JSON || nil]
-  def request(path)
+  def request(path, params = {})
     return unless authorized?
 
-    uri = URI("https://#{SWGOH::API::PATH::BASE}/#{path}")
-    data = request_data
-    data[:project] = @project unless @project.nil?
-    response = Net::HTTP.post(uri, data.to_json, request_headers)
-    return log_error(response) unless response.is_a?(Net::HTTPSuccess)
-
-    JSON.parse(response.body)
+    @requester.request(@access_token, path, params)
   end
 
   # @param [PATH] path
   # @param [Array] ally_codes
+  # @param [Hash] params
   # @return [JSON || nil]
-  def ally_codes_request(path, ally_codes)
-    return unless authorized?
-
-    uri = URI("https://#{SWGOH::API::PATH::BASE}/#{path}")
-    data = request_data
-    data[:allyCodes] = ally_codes
-    data[:project] = @project unless @project.nil?
-    response = Net::HTTP.post(uri, data.to_json, request_headers)
-    return log_error(response) unless response.is_a?(Net::HTTPSuccess)
-
-    JSON.parse(response.body)
+  def ally_codes_request(path, ally_codes, params = {})
+    request(path, params.merge({ allyCodes: ally_codes }))
   end
 
   # @param [SWGOH::API::PATH::COLLECTION] collection
+  # @param [Hash] params
   # @return [JSON || nil]
-  def data_request(collection)
-    return unless authorized?
-
-    uri = URI("https://#{SWGOH::API::PATH::BASE}/#{SWGOH::API::PATH::DATA}")
-    data = request_data
-    data[:collection] = collection
-    data[:project] = @project unless @project.nil?
-    response = Net::HTTP.post(uri, data.to_json, request_headers)
-    return log_error(response) unless response.is_a?(Net::HTTPSuccess)
-
-    JSON.parse(response.body)
-  end
-
-  # @return [Hash]
-  def request_headers
-    {
-      Authorization: 'Bearer ' + @access_token,
-      'Content-Type': 'application/json;charset=utf-8'
-    }
-  end
-
-  # @param [String]  username
-  # @param [String] password
-  # @return [Hash]
-  def auth_request_form(username, password)
-    {
-      username: username,
-      password: password,
-      grant_type: 'password',
-      client_id: 123,
-      client_secret: 'abc'
-    }
-  end
-
-  # @return [Hash]
-  def request_data
-    {
-      language: language,
-      enums: enums,
-      structure: structure
-    }
-  end
-
-  def log_error(result)
-    puts result.inspect
-    puts result.body if result.is_a?(Net::HTTPResponse)
+  def data_collection_request(collection, params = {})
+    request(SWGOH::API::PATH::DATA, params.merge({ collection: collection }))
   end
 end

data/lib/SWGOH/API/CLIENT/requester.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'SWGOH/API'
+require 'SWGOH/API/CLIENT/LOG/log'
+require 'uri'
+
+# Makes requests for the client
+class REQUESTER
+  attr_accessor :log
+
+  def initialize
+    @log = LOG.new
+  end
+
+  # @param [String]  username
+  # @param [String] password
+  # @return [JSON || nil]
+  def auth_request(username, password)
+    response = Net::HTTP.post_form(uri(SWGOH::API::PATH::AUTH_SIGNIN), auth_request_form(username, password))
+    return @log.error(response) unless response.is_a?(Net::HTTPSuccess)
+
+    JSON.parse(response.body)
+  end
+
+  # @param [String] access_token
+  # @param [PATH] path
+  # @param [Hash] data
+  # @return [JSON || nil]
+  def request(access_token, path, data)
+    response = Net::HTTP.post(uri(path), default_data.merge(data).to_json, request_headers(access_token))
+    return @log.error(response) unless response.is_a?(Net::HTTPSuccess)
+
+    JSON.parse(response.body)
+  end
+
+  private
+
+  # @return [Module<URI>]
+  def uri(path)
+    URI("https://#{SWGOH::API::PATH::BASE}/#{path}")
+  end
+
+  # @param [String]  username
+  # @param [String] password
+  # @return [Hash]
+  def auth_request_form(username, password)
+    {
+      username: username,
+      password: password,
+      grant_type: 'password',
+      client_id: 123,
+      client_secret: 'abc'
+    }
+  end
+
+  # @return [Hash]
+  def request_headers(access_token)
+    {
+      Authorization: 'Bearer ' + access_token,
+      'Content-Type': 'application/json;charset=utf-8'
+    }
+  end
+
+  # @return [Hash]
+  def default_data
+    {
+      language: SWGOH::API::LANGUAGE::ENG_US,
+      enums: false,
+      structure: false
+    }
+  end
+end

data/lib/SWGOH/API/version.rb

@@ -2,6 +2,6 @@
 
 module SWGOH
   module API
-    VERSION = '0.4.0'
+    VERSION = '1.0.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: SWGOH-API
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Jonathan Quass
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-23 00:00:00.000000000 Z
+date: 2020-11-06 00:00:00.000000000 Z
 dependencies: []
 description: A ruby gem client for api.swgoh.help
 email:
@@ -29,7 +29,9 @@ files:
 - SWGOH-API.gemspec
 - bin/setup
 - lib/SWGOH/API.rb
+- lib/SWGOH/API/CLIENT/LOG/log.rb
 - lib/SWGOH/API/CLIENT/client.rb
+- lib/SWGOH/API/CLIENT/requester.rb
 - lib/SWGOH/API/version.rb
 homepage: https://github.com/jquass/SWGOH-API
 licenses: