Remove Lodestone cache, market methods

All Lodestone data is served in realtime, removing the Info hash as well
as the need for polling. All previously cached Lodestone requests are
now treated as regular requests. Custom Lodestone errors have been
removed. Market methods have been removed since the endpoint no longer
exists.

Author: mattantonelli

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    xivapi (0.2.5)
+    xivapi (0.3.0)
       rest-client (~> 2.0.2)
 
 GEM

README.md

@@ -7,7 +7,7 @@ A Ruby library for [XIVAPI](https://www.xivapi.com/).
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'xivapi', git: 'https://github.com/xivapi/xivapi-ruby.git', tag: 'v0.2.5'
+gem 'xivapi', git: 'https://github.com/xivapi/xivapi-ruby.git', tag: 'v0.3.0'
 ```
 
 And then run:
@@ -31,7 +31,7 @@ require 'xivapi'
 client = XIVAPI::Client.new(api_key: 'abc123')
 
 # Advanced configuration
-client = XIVAPI::Client.new(api_key: 'abc123', language: 'en', poll_rate: 5)
+client = XIVAPI::Client.new(api_key: 'abc123', language: 'fr')
 ```
 
 Now that you have a client, you can use it to contact the API. Examples have been provided below for the various endpoints. For the full list of endpoints and their parameters, please reference the [request documentation](https://xivapi.github.io/xivapi-ruby/XIVAPI/Request.html).
@@ -108,7 +108,7 @@ See the examples below to get a better idea of how to access the data.
 => ...
 >> id = linkshells.first.id
 => "21955048183495181"
->> linkshell = client.linkshell(id: id, poll: true).linkshell
+>> linkshell = client.linkshell(id: id).linkshell
 => ...
 >> linkshell.name
 => "Thunderbirds"

lib/xivapi.rb

@@ -30,13 +30,11 @@ class Client
     # Initializes a new client for querying XIVAPI
     # @param api_key [String] API key provided by XIVAPI
     # @param language [String] Requested response langauge
-    # @param poll_rate [Integer] Frequency at which to poll when waiting for data to cache
     # @param staging [true, false] Whether or not to query the staging API instead of production
-    def initialize(api_key: nil, language: :en, poll_rate: 5, staging: false)
+    def initialize(api_key: nil, language: :en, staging: false)
       @api_key = api_key
 
       self.language = language
-      self.poll_rate = poll_rate
       self.staging = staging
     end
 
@@ -53,18 +51,6 @@ def language=(language)
       @language = lang
     end
 
-    # @return [Integer] The rate at which cached requests are polled
-    def poll_rate
-      @poll_rate
-    end
-
-    # @param rate [Integer] The rate at which to poll cached requests
-    # @return [Integer] The poll rate
-    def poll_rate=(rate)
-      raise ArgumentError, 'Poll rate must be a positive integer' unless rate.is_a?(Integer) && rate > 0
-      @poll_rate = rate
-    end
-
     # @return [Hash] The default parameters for the client
     def default_params
       { private_key: @api_key, language: @language }

lib/xivapi/errors.rb

@@ -20,33 +20,5 @@ def initialize
         super('Too many requests.')
       end
     end
-
-    # Content not available
-    class ContentNotAvailable < StandardError
-      def initialize
-        super('Content is not currently available on XIVAPI.')
-      end
-    end
-
-    # Content not found
-    class ContentNotFound < StandardError
-      def initialize
-        super('Content does not exist on the Lodestone.')
-      end
-    end
-
-    # Content blacklisted
-    class ContentBlacklisted < StandardError
-      def initialize
-        super('Content has been blacklisted.')
-      end
-    end
-
-    # Content private
-    class ContentPrivate < StandardError
-      def initialize
-        super('Content is private.')
-      end
-    end
   end
 end

lib/xivapi/http.rb

@@ -39,44 +39,6 @@ def request(client, endpoint, params = {}, payload = nil)
       end
     end
 
-    # Makes a request to XIVAPI for cached data. This is data that must be cached
-    # by XIVAPI before it can be served. This method should be used over the standard
-    # request in order to properly throw custom errors and enable polling. Polling
-    # will continuously call the API until the data is cached and returned.
-    #
-    # @param client [XIVAPI::Client] The client making the request
-    # @param endpoint [String, Symbol] The endpoint to request
-    # @param key [String, Symbol] The results key that stores the cached data
-    # @param params [Hash] Request parameters
-    # @param poll [true, false] Whether or not to poll XIVAPI until data is returned
-    # @return the results of the request
-    def request_cached(client, endpoint, key, params = {}, poll = false)
-      columns = params[:columns]
-      unless columns.empty? || columns.match?('Info')
-        params[:columns] = columns.split(',').push('Info').join(',')
-      end
-
-      response = request(client, endpoint, params)
-
-      case(response.info[key].state)
-      when 0
-        raise XIVAPI::ContentNotAvailable
-      when 1
-        if poll
-          sleep(client.poll_rate)
-          response = request_cached(client, endpoint, key, params, poll)
-        end
-      when 3
-        raise XIVAPI::ContentNotFound
-      when 4
-        raise XIVAPI::ContentBlacklisted
-      when 5
-        raise XIVAPI::ContentPrivate
-      end
-
-      response
-    end
-
     private
     def request_url(client, endpoint)
       "#{client.staging ? STAGING_API_BASE : API_BASE}/#{endpoint}"

lib/xivapi/request.rb

@@ -61,51 +61,14 @@ def servers(group: false)
     request(self, endpoint)
   end
 
-  # @param ids [Integer, Array<Integer>] ID(s) of the item(s) to look up
-  # @param servers [String, Array<String>] Server(s) to retrieve the market for
-  # @param data_center [String] Data center to retrieve the market for
-  # @param max_history [Integer] The maximum amount of history to retrieve
-  # @param columns [String, Array <String>] One or more columns to limit results to
-  # @return [OpenStruct] Market price results
-  def market(ids: [], servers: [], data_center: nil, max_history: nil, columns: [])
-    ids, server_names = [*ids], [*servers]
-    params = { max_history: max_history, columns: [*columns].join(',') }
-
-    if ids.size > 1
-      params.merge!(ids: ids.join(','), dc: data_center, servers: server_names.join(','))
-      request(self, 'market/items', params)
-    elsif data_center || server_names.size > 1 || server_names[0].match?(',')
-      params.merge!(dc: data_center, servers: server_names.join(','))
-      request(self, "market/item/#{ids.first}", params)
-    else
-      request(self, "market/#{server_names.first}/item/#{ids.first}", params)
-    end
-  end
-
-  # @return [Array<OpenStruct>] List of Market categories
-  def market_categories
-    request(self, 'market/categories')
-  end
-
   # @param id [Integer] Character ID
   # @param all_data [true, false] Return the full set of character data
-  # @param poll [true, false] Continuously call the API until a result is cached and returned
   # @param data [String, Array <String>] Additional data to request, see: https://xivapi.com/docs/Character#character
   # @param columns [String, Array <String>] One or more columns to limit results to
   # @return [OpenStruct] The requested character
-  def character(id: nil, all_data: false, poll: false, data: [], columns: [])
+  def character(id: nil, all_data: false, data: [], columns: [])
     params = { data: character_data(all_data, data), columns: [*columns].join(',') }
-    request_cached(self, "character/#{id}", :character, params, poll)
-  end
-
-  # @param ids [String, Array<Integer>] Character IDs
-  # @param all_data [true, false] Return the full set of character data
-  # @param data [String, Array <String>] Additional data to request, see: https://xivapi.com/docs/Character#character
-  # @param columns [String, Array <String>] One or more columns to limit results to
-  # @return [Array<OpenStruct>] The requested characters
-  def characters(ids: nil, all_data: false, data: [], columns: [])
-    body = { ids: [*ids].join(','), data: character_data(all_data, data), columns: [*columns].join(',') }
-    request(self, 'characters', {}, body)
+    request(self, "character/#{id}", params)
   end
 
   # @param name [String] Character name
@@ -117,27 +80,20 @@ def character_search(name: nil, server: nil, columns: [])
     XIVAPI::Paginator.new(self, params, 'character/search', LODESTONE_LIMIT)
   end
 
-  # @param id [Integer] Character ID
-  # @return [true, false] Whether or not the character update was requested successfully
-  def character_update(id: nil)
-    request(self, "character/#{id}/update") == 1
-  end
-
   # @param id [Integer] Character ID
   # @param token [String] Verification token to check for
   # @return [true, false] Whether or not the character is verified
   def character_verified?(id: nil, token: nil)
-    request(self, "character/#{id}/verification", { token: token }).pass
+    character(id: id, columns: 'Character.Bio').character.bio.match?(token)
   end
 
   # @param id [Integer] Free company ID
   # @param members [true, false] Return member data
-  # @param poll [true, false] Continuously call the API until a result is cached and returned
   # @param columns [String, Array <String>] One or more columns to limit results to
   # @return [OpenStruct] The requested free company
-  def free_company(id: nil, members: false, poll: false, columns: [])
+  def free_company(id: nil, members: false, columns: [])
     params = { data: members ? 'FCM' : nil, columns: [*columns].join(',') }
-    request_cached(self, "freecompany/#{id}", :free_company, params, poll)
+    request(self, "freecompany/#{id}", params)
   end
 
   # @param name [String] Free company name
@@ -150,12 +106,11 @@ def free_company_search(name: nil, server: nil, columns: [])
   end
 
   # @param id [Integer] Linkshell ID
-  # @param poll [true, false] Continuously call the API until a result is cached and returned
   # @param columns [String, Array <String>] One or more columns to limit results to
   # @return [OpenStruct] The requested linkshell
-  def linkshell(id: nil, poll: false, columns: [])
+  def linkshell(id: nil, columns: [])
     params = { columns: [*columns].join(',') }
-    request_cached(self, "linkshell/#{id}", :linkshell, params, poll)
+    request(self, "linkshell/#{id}", params)
   end
 
   # @param name [String] Linkshell name
@@ -168,12 +123,11 @@ def linkshell_search(name: nil, server: nil, columns: [])
   end
 
   # @param id [Integer] PVP team ID
-  # @param poll [true, false] Continuously call the API until a result is cached and returned
   # @param columns [String, Array <String>] One or more columns to limit results to
   # @return [OpenStruct] The requested PVP team
-  def pvp_team(id: nil, poll: false, columns: [])
+  def pvp_team(id: nil, columns: [])
     params = { columns: [*columns].join(',') }
-    request_cached(self, "pvpteam/#{id}", :pvp_team, params, poll)
+    request(self, "pvpteam/#{id}", params)
   end
 
   # @param name [String] PVP team name

lib/xivapi/version.rb

@@ -1,4 +1,4 @@
 module XIVAPI
   # Gem version
-  VERSION = "0.2.5"
+  VERSION = "0.3.0"
 end