eve_badger 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 70091024d0ac71348a011738d03fad11d937efb4
-  data.tar.gz: d6f3520205e3c0490f8a3a078bd4bb9617345f28
+  metadata.gz: 2bc45c7eb50a097472bc492371e1e500712dfca9
+  data.tar.gz: 9a0307ae74ba1477a86911ebf27f252ec77982f0
 SHA512:
-  metadata.gz: 13506be23d15db31f10590b2a50e50918893c44c6f8cbed53d1e7c8aff80a13460564eb5ffb78acefa26f66191361a9b1ba058b54030e06748e39ae0821714b7
-  data.tar.gz: 26f8fef264d81b8ac4de5e30e5f1be9cee96888c4b860f41db0947d0fa24c8b3114df67fb6d49bb82e0315aaca4569fb00cabbe68e94cff1fc0ad76101812161
+  metadata.gz: 6d4ebf620cbc554ba9eb5066e4bc43c6d284c16377e0dbef12bb23e44b601506724504bdfcd7a5875519f134be148d91ef71ba3225186ec9c3e22be385db8416
+  data.tar.gz: 72ed8c09f93b607f7db34483d23d564f7285374d12fe35c5242919ef1fb32d1b6418c08d3216aff4bc05b4a375d3cdca4d278b8d93b3e3740bcdf05c04b3c055

data/README.md

@@ -1,65 +1,80 @@
 # EveBadger
 
-It badgers the Eve: Online API for [badgerfish](http://badgerfish.ning.com/) responses. Get it?
+It badgers the Eve: Online API for [badgerfish](http://badgerfish.ning.com/) responses. Get it? (Don't worry. You can still get plain XML if you want to.)
 
 ## About
 
-EveBadger is a lightweight interface to the Eve: Online API. Build an EveAPI object to represent your API key and call out to the endpoint you're interested in. It'll return a JSON/Hash representing the response. It also handles caching, throttling and access masks out of the box.
+EveBadger is a lightweight interface to the Eve: Online XML API. Build an EveAPI object to represent your API key and call out to the endpoint you're interested in. It'll return a response object that you can can easily consume as JSON or XML. EveBadger also respects access masks automatically and makes caching and throttling responses as easy as flipping a switch.
 
 I wrote this for 3 reasons:
 
 * I prefer working with JSON over XML
 * I wasn't in love with existing EveAPI solutions
 * I wanted to learn how to build a custom Gem (Ruby packaging is awesome, btw)
- 
+
 ## What does it do?
 
 * Obeys CCP's default request rate limit (can be disabled if you have an exception)
-* Caches responses until their respective cachedUntil timestamps (can be disabled if you prefer your own method)
-* Respects access masks for keys and endpoints (it will raise an exception if you try to access an endpoint that isn't allowed by the keys access mask)
-* Probably annoys OO purists
+* Uses Moneta to cache responses with whatever supported backend you prefer. (Disabled by default.)
+* Automatically fetches missing access_mask and key_type values from the API Key Info endpoint.
+* Respects access masks for keys and endpoints (it will raise an exception instead of making an HTTP request if you try to access an endpoint that isn't allowed by the key's access mask)
+* Probably annoys OO purists a little.
 
 ## What doesn't it do?
 
-* EveBadger won't wrap each response inside a nice endpoint specific object, it just gives you the JSON.
-* Doesn't cover the entire EveAPI (just Account, Character and Corporation endpoints this will improve in time)
-* It doesn't install from rubygems yet, because I haven't published it (but you can add a git entry to your Gemfile if you want to use it before I do)
+* EveBadger won't wrap each response inside a nice endpoint specific object, it just gives you the JSON or XML and can truncate the response to the <result> section if you prefer.
 
 ## Planned Improvements
 
 * **Full API Coverage** Right now EveBadger covers the stuff I use the most. Eventually I'll go through and add all the remaining endpoints.
-* **Cache Configuration** EveBadger uses the Moneta gem for caching. Currently it's pretty dumb and only tries to link up with an unprotected redis instance on localhost, if this fails it'll fall back to an in-memory Moneta store. I'd like to allow users to configure most aspects of the Moneta store.
 * **Rowset Extraction** *(Maybe)* I'm happy with JSON responses for the most part. I don't want or need a full object for every endpoint, but a single basic response object which does a nice job of extracting rowsets and delegating indexes might be nice.
-* **RubyGems** Once I polish a few things and settle on a handful of decisions I'll publish this to rubygems.
 
-## Usage Examples
+## Basic Usage
 
-The basic idea is to make an EveAPI object and call the appropriate category method with the symbol representing the name of the endpoint. It'll spit back JSON and you take it from there.
+The basic idea is to make an EveAPI object and call the appropriate category method with the symbol representing the name of the endpoint. It'll spit back a response object you can take JSON or XML from and use however you want.
 
-I think you'll find that the category methods and endpoint names map directly to the EveAPI documentation at [this location](https://neweden-dev.com/API). 
+I think you'll find that the category methods and endpoint names map directly to the EveAPI documentation at [this location](https://neweden-dev.com/API).
 
-### Getting a Character List
+
+### Getting Key Info as JSON
 ```ruby
 api = EveBadger::EveAPI.new(key_id: my_key_id, vcode: my_vcode)
-response = api.account(:list_of_characters)
-response['rowset']['row'].each do |row|
-  puts row['@name']
-end
+response = api.account(:api_key_info).as_json
 ```
 
-### Getting Key Info
+### Getting Key Info as XML
 ```ruby
 api = EveBadger::EveAPI.new(key_id: my_key_id, vcode: my_vcode)
-response = api.account(:api_key_info)
-puts response['key']['@accessMask']
-puts response['key']['@type']
+response = api.account(:api_key_info).as_xml
+document = MyFavoriteXMLParser.new(response)
+```
+
+## More Examples
+
+You'll notice that these examples all use `.result_as_json` and `.result_as_xml`. Instead of `.as_json` or `.as_xml`. This isn't a typo. The response object allows you to take the whole response as JSON/XML or only the contents enclosed in `<result></result>` tags.
+
+The full responses from `.as_*` are good if you need the timestamp data for your own uses.
+
+The truncated responses from `.result_as_*` are nice if you don't need the extra stuff and just want to skip the `<eveapi>`  and `<result>` nodes.
+
+### Getting a Character List
+```ruby
+api = EveBadger::EveAPI.new(key_id: my_key_id, vcode: my_vcode)
+response = api.account(:list_of_characters).result_as_json
+response['rowset']['row'].each do |row|
+  puts row['@name']
+end
 ```
 
 ### Getting a Tower List
 ```ruby
-# corporation endpoints expect you to also pass the character_id for the character on the key
-api = EveBadger::EveAPI.new(key_id: my_key_id, vcode: my_vcode, character_id: my_character_id)
-response = api.corporation(:starbase_list)
+# Corporation endpoints expect you to also pass
+# the character_id for the character on the key.
+api = EveBadger::EveAPI.new
+api.key_id = my_key_id
+api.vcode = my_vcode
+api.character_id = my_character_id
+response = api.corporation(:starbase_list).result_as_json
 response['rowset']['row'].each |starbase|
   puts starbase['@state']
 end
@@ -67,20 +82,36 @@ end
 
 ### Getting the Details of a Specific Object
 ```ruby
-api = EveBadger::EveAPI.new(key_id: my_key_id, vcode: my_vcode, character_id: my_character_id)
-# Detail endpoints are the only exception to the category/endpoint pattern
-# Any endpoint that pulls the details of a particular thing is accessed via the details method
-# Simply pass the extra argument for id_of_interest
-response = api.details(:starbase_detail, my_id_of_interest)  
+# Detail endpoints are the only exception to the category/endpoint pattern.
+# Any endpoint that pulls the details of a particular thing is accessed via
+# the details method by passing an extra argument for id_of_interest.
+api = EveBadger::EveAPI.new
+api.key_id = my_key_id
+api.vcode = my_vcode
+api.character_id my_character_id
+response = api.details(:starbase_detail, my_id_of_interest).result_as_json  
 response['rowset']['row'].each |fuel_row|
   puts "#{fuel_row['@typeID']} - #{fuel_row['@quantity']}"
 end
 ```
 
-### Creating an Object for a Test Server API
+### Creating an Object for the Test Server API
+```ruby
+api = EveBadger::EveAPI.new(server: :sisi)
+api.key_id = my_key_id
+api.vcode = my_vcode
+api.character_id = my_character_id)
+# then continue as normal
+```
+
+### Enable Request Caching
 ```ruby
-api = EveBadger::EveAPI.new(server: :sisi, key_id: my_key_id, vcode: my_vcode, character_id: my_character_id)
-# then ontinue as normal
+# EveBadger::Cache.enable! takes the same arguments as Moneta.new
+# See Moneta API docs for possible configurations:
+# http://www.rubydoc.info/gems/moneta/frames
+# Note: EveBadger will automatically merge in {expires: true} if the
+# chosen adapter doesn't support expiration natively.
+EveBadger::Cache.enable!(:Redis)
 ```
 
 ### Tips for Edge Cases

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/lib/eve_badger.rb

@@ -3,11 +3,13 @@ require 'eve_badger/eve_api'
 
 module EveBadger
   def self.version
-    @version ||= File.read(File.expand_path(File.join(File.dirname(__FILE__), '..', 'VERSION')))
+    @version ||= File.read(File.expand_path(File.join(File.dirname(__FILE__), '..', 'VERSION'))).chomp
   end
-  def self.user_agent
+
+  def self.default_user_agent
     "EveBadger-#{EveBadger.version}/Ruby-#{RUBY_VERSION}"
   end
+
   def self.tq_domain
     'https://api.eveonline.com/'
   end
@@ -25,16 +27,13 @@ module EveBadger
   end
 
   def self.enable_default_throttling
-    SlowWeb.limit(@tq_domain, 30, 60)
-    SlowWeb.limit(@sisi_domain, 30, 60)
+    SlowWeb.limit(tq_domain, 30, 60)
+    SlowWeb.limit(sisi_domain, 30, 60)
   end
 
   def self.enable_custom_throttling(requests_per_minute)
     SlowWeb.reset
-    SlowWeb.limit(@tq_domain, requests_per_minute, 60)
-    SlowWeb.limit(@sisi_domain, requests_per_minute, 60)
-  end
-
-  class CCPPleaseError < StandardError
+    SlowWeb.limit(tq_domain, requests_per_minute, 60)
+    SlowWeb.limit(sisi_domain, requests_per_minute, 60)
   end
 end

data/lib/eve_badger/cache.rb

@@ -0,0 +1,50 @@
+require 'moneta'
+require 'digest/sha1'
+
+module EveBadger
+  # A wrapper around a Moneta object that provides automatic request caching for Evebadger::EveAPI when enabled.
+  module Cache
+    # Cache is disabled by default
+    @cache = nil
+    # These adapters support expiration natively and don't need to be wrapped in Moneta::Expires
+    @native_expires = [:Mongo, :MongoOfficial, :MongoMoped, :Redis, :Cassandra, :MemcachedDalli, :Memcached, :MemcachedNative, :Cookie]
+
+    # Enable the cache with a specified Moneta adapter.
+    # See Moneta API documentation for possible configurations: http://www.rubydoc.info/gems/moneta/frames
+    def self.enable!(*args, **kwargs)
+      unless @native_expires.any? { |name| args.include?(name) }
+      # unless false
+        kwargs.merge!({expires: true})
+      end
+      @cache = Moneta.new(*args, **kwargs)
+    end
+
+    def self.disable!
+      @cache = nil
+    end
+
+    def self.enabled?
+      @cache ? true : false
+    end
+
+    def self.type
+      @cache.class
+    end
+
+    def self.store(key, value, options={})
+      if @cache
+        @cache.store(key, value, options)
+      else
+        raise "Cannot store when cache is disabled."
+      end
+    end
+
+    def self.get(key)
+      if @cache
+        @cache[key]
+      else
+        raise "Cannot get when cache is disabled."
+      end
+    end
+  end
+end

data/lib/eve_badger/endpoints.rb

@@ -0,0 +1,59 @@
+require 'json'
+
+module EveBadger
+  class Endpoint
+    attr_reader :path, :access_mask, :detail_id
+
+    def initialize(data)
+      @path = data[:path]
+      @access_mask = data[:access_mask]
+      @detail_id = data[:detail_id] if data[:detail_id]
+    end
+
+    def permitted?(other_mask)
+      @access_mask.zero? or (other_mask & @access_mask != 0)
+    end
+  end
+
+  module Endpoints
+    open(File.join(File.dirname(__FILE__), 'json', 'account_endpoints.json'), 'r') do |file|
+      @account_endpoints = JSON.parse(file.read.to_s, :symbolize_names => true)
+    end
+
+    open(File.join(File.dirname(__FILE__), 'json', 'character_endpoints.json'), 'r') do |file|
+      @character_endpoints = JSON.parse(file.read.to_s, :symbolize_names => true)
+    end
+
+    open(File.join(File.dirname(__FILE__), 'json', 'corporation_endpoints.json'), 'r') do |file|
+      @corporation_endpoints = JSON.parse(file.read.to_s, :symbolize_names => true)
+    end
+
+    open(File.join(File.dirname(__FILE__), 'json', 'detail_endpoints.json'), 'r') do |file|
+      @detail_endpoints = JSON.parse(file.read.to_s, :symbolize_names => true)
+    end
+
+    def self.account(endpoint)
+      data = @account_endpoints[endpoint]
+      raise ArgumentError, "unsupported endpoint: #{endpoint}" unless data
+      Endpoint.new(data)
+    end
+
+    def self.character(endpoint)
+      data = @character_endpoints[endpoint]
+      raise ArgumentError, "unsupported endpoint: #{endpoint}" unless data
+      Endpoint.new(data)
+    end
+
+    def self.corporation(endpoint)
+      data = @corporation_endpoints[endpoint]
+      raise ArgumentError, "unsupported endpoint: #{endpoint}" unless data
+      Endpoint.new(data)
+    end
+
+    def self.detail(endpoint)
+      data = @detail_endpoints[endpoint]
+      raise ArgumentError, "unsupported endpoint: #{endpoint}" unless data
+      Endpoint.new(data)
+    end
+  end
+end

data/lib/eve_badger/eve_api.rb

@@ -1,20 +1,24 @@
 require 'nokogiri'
 require 'time'
-require 'badgerfish'
 require 'open-uri'
-require 'eve_badger/endpoint_data'
-require 'eve_badger/request_cache'
+require 'eve_badger'
+require 'eve_badger/endpoints'
+require 'eve_badger/response'
+require 'eve_badger/cache'
+require 'digest/sha1'
 
 module EveBadger
   class EveAPI
     attr_accessor :user_agent
-    attr_reader :key_id, :vcode, :character_id
-    include EveBadger::EndpointData
-    include EveBadger::RequestCache
+    attr_reader :key_id, :vcode, :character_id, :domain
 
     def initialize(args={})
-      @domain = args[:sisi] ? EveBadger.sisi_domain : EveBadger.tq_domain
-      @user_agent = EveBadger.user_agent
+      if args[:server] == :sisi
+        @domain = EveBadger.sisi_domain
+      else
+        @domain = EveBadger.tq_domain
+      end
+      @user_agent = EveBadger.default_user_agent
       @key_id = args[:key_id].to_s if args[:key_id]
       @vcode = args[:vcode].to_s if args[:vcode]
       @character_id = args[:character_id].to_s if args[:character_id]
@@ -51,52 +55,48 @@ module EveBadger
     end
 
     def account(endpoint_name)
-      raise 'missing required key_id or vcode' unless @key_id && @vcode
-      endpoint = EveAPI.account_endpoint[endpoint_name.to_sym]
-      badgerfish_from api_request(endpoint)
+      raise EveBadger::APIKeyError, 'missing required key_id or vcode' unless @key_id && @vcode
+      endpoint = EveBadger::Endpoints.account(endpoint_name.to_sym)
+      api_request(endpoint)
     end
 
     def character(endpoint_name)
-      raise 'missing required character_id key_id or_vcode' unless @character_id && @key_id && @vcode
-      raise 'wrong key type' unless key_type == :Character || :Account
-      endpoint = EveAPI.character_endpoint[endpoint_name.to_sym]
-      badgerfish_from api_request(endpoint)
+      raise EveBadger::APIKeyError, 'missing required character_id key_id or_vcode' unless @character_id && @key_id && @vcode
+      raise EveBadger::APIKeyError, 'wrong key type' unless [:Character, :Account].include?(key_type)
+      endpoint = EveBadger::Endpoints.character(endpoint_name.to_sym)
+      api_request(endpoint)
     end
 
     def corporation(endpoint_name)
-      raise 'missing required character_id key_id or_vcode' unless @character_id && @key_id && @vcode
-      raise 'wrong key type' unless key_type == :Corporation
-      endpoint = EveAPI.corporation_endpoint[endpoint_name.to_sym]
-      badgerfish_from api_request(endpoint)
+      raise EveBadger::APIKeyError, 'missing required character_id key_id or_vcode' unless @character_id && @key_id && @vcode
+      raise EveBadger::APIKeyError, 'wrong key type' unless key_type == :Corporation
+      endpoint = EveBadger::Endpoints.corporation(endpoint_name.to_sym)
+      api_request(endpoint)
     end
 
     def details(endpoint_name, id_of_interest, fromid=nil, rowcount=nil)
-      raise 'wrong key type' unless key_type == :Character || :Corporation || :Account
-      endpoint = EveAPI.detail_endpoint[endpoint_name.to_sym]
-      if endpoint_permitted?(endpoint)
+      raise EveBadger::APIKeyError, 'wrong key type' unless [:Character, :Corporation, :Account].include?(key_type)
+      endpoint = EveBadger::Endpoints.detail(endpoint_name.to_sym)
+      if endpoint.permitted?(access_mask)
         uri = build_uri(endpoint)
-        uri << "&#{endpoint[:detail_id]}=#{id_of_interest}"
+        uri << "&#{endpoint.detail_id}=#{id_of_interest}"
         uri << "&fromID=#{fromid}" if fromid
         uri << "&rowCount=#{rowcount}" if rowcount
-        badgerfish_from get_response(uri)
+        get_response(uri)
       else
-        raise "#{endpoint[:path]} not permitted by access mask"
+        raise EveBadger::APIKeyError, "#{endpoint.path} not permitted by access mask"
       end
     end
 
     private
     def api_request(endpoint)
-      if endpoint_permitted?(endpoint)
+      if endpoint.access_mask.zero? or endpoint.permitted?(access_mask)
         get_response(build_uri(endpoint))
       else
-        raise "#{endpoint[:path]} not permitted by access mask"
+        raise EveBadger::APIKeyError, "#{endpoint.path} not permitted by access mask"
       end
     end
 
-    def endpoint_permitted?(endpoint)
-      endpoint[:access_mask].zero? or (access_mask & endpoint[:access_mask] != 0)
-    end
-
     def get_access_mask
       fetch_key_info unless @access_mask
       @access_mask
@@ -108,13 +108,13 @@ module EveBadger
     end
 
     def fetch_key_info
-      info = account(:api_key_info)
+      info = account(:api_key_info).result_as_json
       @access_mask = info['key']['@accessMask'].to_i
       @key_type = info['key']['@type'].to_sym
     end
 
     def build_uri(endpoint)
-      "#{@domain}#{endpoint[:path]}.xml.aspx#{params}"
+      "#{@domain}#{endpoint.path}.xml.aspx#{params}"
     end
 
     def params
@@ -123,13 +123,12 @@ module EveBadger
 
     def get_response(uri)
       response = cache_get(uri) || http_get(uri)
-      raise_for_api_errors! response
-      response
+      EveBadger::Response.new(response)
     end
 
     def cache_get(uri)
-      if EveAPI.request_cache
-        EveAPI.request_cache[uri]
+      if EveBadger::Cache.enabled?
+        EveBadger::Cache.get(hash_of(uri))
       end
     end
 
@@ -139,32 +138,29 @@ module EveBadger
       rescue OpenURI::HTTPError => error
         response = error.io.string
       end
-      cache_response(uri, response)
-      cache_get(uri) || response
+      store_response(uri, response)
+      response || cache_get(uri)
     end
 
-    def cache_response(uri, response)
-      if EveAPI.request_cache
-        EveAPI.request_cache.store(uri, response, expires: seconds_until_expire(response))
+    def store_response(uri, response)
+      if EveBadger::Cache.enabled?
+        EveBadger::Cache.store(hash_of(uri), response, expires: cached_until(response))
       end
     end
 
-    def seconds_until_expire(xml)
-      noko = Nokogiri::XML xml
-      cached_until = Time.parse(noko.xpath('//cachedUntil').first.content)
-      cached_until.to_i - Time.now.to_i
+    # Hash URI's before use as a cache key so that API key/vcode combinations don't leak from the cache monitor or logs.
+    def hash_of(uri)
+      Digest::SHA1.hexdigest(uri)
     end
 
-    def raise_for_api_errors!(response)
-      noko = Nokogiri::XML(response)
-      if noko.xpath('//error').any?
-        raise EveBadger::CCPPleaseError, "#{noko.xpath('//error').first}"
-      end
+    def cached_until(xml)
+      noko = Nokogiri::XML xml
+      seconds_until_expire = Time.parse(noko.xpath('//cachedUntil').text)
+      seconds_until_expire.to_i - Time.now.to_i
     end
+  end
 
-    def badgerfish_from(xml)
-      response = Nokogiri::XML(xml)
-      Badgerfish::Parser.new.load(response.xpath('//result/*').to_s)
-    end
+  # Exception to raise when an EveAPI object needs attributes which are missing or invalid.
+  class APIKeyError < StandardError
   end
 end

data/lib/eve_badger/response.rb

@@ -0,0 +1,43 @@
+require 'badgerfish'
+require 'nokogiri'
+require 'time'
+
+module EveBadger
+  class Response
+    def initialize(content)
+      @content = content
+    end
+
+    # returns json in badgerfish notation
+    def as_json
+      Badgerfish::Parser.new.load(@content)
+    end
+
+    # returns the response content as xml string
+    def as_xml
+      @content
+    end
+
+    # same as #as_xml but truncates to just <result> data
+    def result_as_xml
+      Nokogiri::XML(@content).xpath("//result/*").to_s
+    end
+
+    # same as #as_json but truncates to just <result> data
+    def result_as_json
+      Badgerfish::Parser.new.load(@content)['eveapi']['result']
+    end
+
+    # raise an exception if the response contains an Eve API error
+    def raise_for_api_errors!(response)
+      document = Nokogiri::XML(response)
+      if document.xpath('//error').any?
+        raise EveBadger::CCPPleaseError, "#{document.xpath('//error').first}"
+      end
+    end
+  end
+
+  # Exception to raise when the Eve API returns an error code in the response.
+  class CCPPleaseError < StandardError
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eve_badger
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Corey Smedstad
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-12 00:00:00.000000000 Z
+date: 2015-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -66,41 +66,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.0
-- !ruby/object:Gem::Dependency
-  name: redis
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.0
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3'
-description: For more information look at the README on the github repository.
+description: For more information look at the README in the github repository (homepage
+  link).
 email: smedstadc@gmail.com
 executables: []
 extensions: []
@@ -110,13 +77,14 @@ files:
 - README.md
 - VERSION
 - lib/eve_badger.rb
-- lib/eve_badger/endpoint_data.rb
+- lib/eve_badger/cache.rb
+- lib/eve_badger/endpoints.rb
 - lib/eve_badger/eve_api.rb
 - lib/eve_badger/json/account_endpoints.json
 - lib/eve_badger/json/character_endpoints.json
 - lib/eve_badger/json/corporation_endpoints.json
 - lib/eve_badger/json/detail_endpoints.json
-- lib/eve_badger/request_cache.rb
+- lib/eve_badger/response.rb
 homepage: https://github.com/smedstadc/eve_badger
 licenses:
 - MIT
@@ -137,9 +105,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: 'A gem for interacting with the Eve: Online API.'
+summary: 'A gem for interacting with the Eve: Online XML API.'
 test_files: []
-has_rdoc: 

data/lib/eve_badger/endpoint_data.rb

@@ -1,40 +0,0 @@
-require 'json'
-
-module EveBadger
-  module EndpointData
-    def self.included(base)
-      base.extend(EndpointData)
-    end
-
-    module EndpointData
-      open(File.join(File.dirname(__FILE__), 'json', 'account_endpoints.json'), 'r') do |file|
-        @@account_endpoint = JSON.parse(file.read.to_s, :symbolize_names => true)
-      end
-      open(File.join(File.dirname(__FILE__), 'json', 'character_endpoints.json'), 'r') do |file|
-        @@character_endpoint = JSON.parse(file.read.to_s, :symbolize_names => true)
-      end
-      open(File.join(File.dirname(__FILE__), 'json', 'corporation_endpoints.json'), 'r') do |file|
-        @@corporation_endpoint = JSON.parse(file.read.to_s, :symbolize_names => true)
-      end
-      open(File.join(File.dirname(__FILE__), 'json', 'detail_endpoints.json'), 'r') do |file|
-        @@detail_endpoint = JSON.parse(file.read.to_s, :symbolize_names => true)
-      end
-
-      def account_endpoint
-        @@account_endpoint
-      end
-
-      def character_endpoint
-        @@character_endpoint
-      end
-
-      def corporation_endpoint
-        @@corporation_endpoint
-      end
-
-      def detail_endpoint
-        @@detail_endpoint
-      end
-    end
-  end
-end

data/lib/eve_badger/request_cache.rb

@@ -1,33 +0,0 @@
-require 'moneta'
-
-module EveBadger
-  module RequestCache
-    def self.included(base)
-      base.extend(RequestCache)
-    end
-
-    module RequestCache
-      begin
-        @@request_cache = Moneta.new(:Redis)
-      rescue
-        @@request_cache = Moneta.new(:File, dir: File.expand_path(File.join(File.dirname(__FILE__), '..', 'cache')))
-      end
-
-      def request_cache
-        @@request_cache
-      end
-
-      def disable_request_cache
-        @@request_cache = nil
-      end
-
-      def enable_request_cache
-        begin
-          @@request_cache = Moneta.new(:Redis)
-        rescue
-          @@request_cache = Moneta.new(:File, dir: File.expand_path(File.join(File.dirname(__FILE__), '..', 'cache')))
-        end
-      end
-    end
-  end
-end