eoat 0.1.0

data/eoat.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'eoat/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'eoat'
+  spec.version     = EOAT::VERSION
+  spec.authors     = ['Ivan Kotov']
+  spec.email       = ['i.spec.kotov@gmail.com']
+  spec.homepage    = 'https://github.com/elDante/eoat'
+  spec.summary     = %q{Eve Online API toolbox}
+  spec.description = %q{Eve Online API toolbox}
+  spec.license       = 'MIT'
+
+  spec.platform    = Gem::Platform::RUBY
+  spec.required_ruby_version = '>= 2.0.0'
+  spec.add_dependency 'httparty', '>= 0.11.0'
+
+  spec.post_install_message = 'Thank you for choosing EOAT.'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec-core', '~> 2.10.0'
+  spec.add_development_dependency 'rspec-expectations', '~> 2.10.0'
+  spec.add_development_dependency 'rr', '~> 1.0.4'
+  spec.add_development_dependency 'yard', '~> 0.8.7'
+  spec.add_development_dependency 'redcarpet', '~> 2.1.1'
+  spec.add_development_dependency 'webmock', '~> 1.13.0'
+  spec.add_development_dependency 'memcache', '~> 1.4.1'
+  spec.add_development_dependency 'redis', '~> 3.0.4'
+end

data/lib/eoat.rb

@@ -0,0 +1,80 @@
+require 'httparty'
+
+require 'eoat/exception'
+require 'eoat/request'
+require 'eoat/version'
+require 'eoat/cache/file_cache'
+require 'eoat/cache/memcached_cache'
+require 'eoat/cache/none_cache'
+require 'eoat/cache/redis_cache'
+require 'eoat/result/eve_type'
+
+# Eve Online API Toolbox (EOAT) module
+# @author Ivan Kotov {mailto:i.s.kotov.ws e-mail}
+module EOAT
+  @cache = EOAT::Cache::NoneCache.new
+  @headers = {
+      'User-Agent' => "EOAT/#{EOAT::VERSION} (Eve Online Api Toolbox;+https://github.com/elDante/eoat)",
+      'Accept-Encoding' => 'gzip',
+      'Accept-Charset' => 'utf-8'
+  }
+  @max_ttl = 30*24*60*60
+
+  # Return current cache storage class instance
+  # @example Get current cache storage
+  #   EOAT.cache #=> #<EOAT::Cache::NoneCache:0x007ff97a8b6bd8>
+  # @return [EOAT::Cache #read] the instance of cache class
+  def self.cache
+    @cache
+  end
+  #
+  # Define new cache store class.
+  # @note Available cache classes:
+  #  {EOAT::Cache::FileCache FileCache},
+  #  {EOAT::Cache::MemcachedCache MemcachedCache},
+  #  {EOAT::Cache::NoneCache NoneCache}
+  #  {EOAT::Cache::RedisCache RedisCache}
+  # @example Store cache to memcached
+  #   EOAT.cache = EOAT::Cache::MemcachedCache.new
+  # @param [CacheClass] val
+  def self.cache=(val)
+    if EOAT::Cache.constants.include? val.class.name.split('::').last.to_sym
+      @cache = val
+    else
+      raise TypeError, "Wrong cache class #{val.class}"
+    end
+  end
+
+  # This method allows to control the request headers
+  # @example Get current headers
+  #   EOAT.headers #=> {"User-Agent"=>"EOAT/0.0.1 (Eve Online Api Toolbox;+https://github.com/elDante/eoat)"}
+  # @example Set 'From' header
+  #   EOAT.headers['From'] = 'user@example.com' #=> 'user@example.com'
+  # @return [Hash #read] the hash of request headers
+  def self.headers
+    @headers
+  end
+
+  # Return a current maximum TTL of cache in seconds
+  # By default: 30 days. Has been introduced to support the memcached.
+  # Since the TTL is calculated from the cached_until - request_time,
+  # and it may be ~ 10 years.
+  # Example: https://api.eveonline.com/eve/SkillTree.xml.aspx
+  # @return [Fixnum, #read]
+  def self.max_ttl
+    @max_ttl
+  end
+
+  # Allow set maximum TTL of cache
+  # @param [Fixnum] val
+  def self.max_ttl=(val)
+    if val.class == Fixnum
+      @max_ttl = val
+    else
+      raise TypeError, "Wrong class #{val.class} of value, it should be Fixnum"
+    end
+  end
+end
+
+require 'eoat/eve_api'
+require 'eoat/zk_api'

data/lib/eoat/cache/file_cache.rb

@@ -0,0 +1,109 @@
+module EOAT
+  module Cache
+    # Store cache to files on disk.
+    # Default use `~/.eoat/cache` as destination directory.
+    # @author Ivan Kotov {mailto:i.s.kotov.ws e-mail}
+    # @example Set FileCache as a cache storage, with default destination directory
+    #   EOAT.cache = EOAT::Cache::FileCache.new
+    # @example Set FileCache as a cache storage, with custom destination directory
+    #   EOAT.cache = EOAT::Cache::FileCache.new('path/to/cache/dir')
+    class FileCache
+      require 'yaml'
+      require 'fileutils'
+
+      # @param [String] path destination path
+      def initialize(path = "#{ENV['HOME']}/.eoat/cache")
+        @path = path.chomp('/')
+        FileUtils.mkpath(@path) unless File.exists?(@path)
+        perform_cache_dir
+      end
+
+      # Get object from cache
+      # @param [String] host the request host string
+      # @param [String] uri the query string
+      # @return [Object, NilClass] the instance of result class
+      #   or nil if key not does not exist
+      def get(host, uri)
+        perform_cache_dir
+        # Perform host string to md5 string
+        host = EOAT::Cache.md5hash(host)
+        # Perform uri string to md5 string
+        uri = EOAT::Cache.md5hash(uri)
+        # Combine parameters to path
+        request_path = "#{@path}/#{host}/#{uri}"
+        if File.exists?(request_path)
+          # Set now in UTC timezone to timestamp
+          now = Time.now.utc.to_i
+          # Get all directories in request_path
+          Dir["#{request_path}/*"].each do |dir|
+            # Check timestamp
+            if dir.split('/').last.to_i > now
+              return YAML::load_file("#{dir}/result.yml")
+            else
+              FileUtils.rmtree("#{dir}")
+            end
+          end
+        end
+        # Return false if data not found
+        false
+      end
+
+      # Save instance of result class.
+      # @param [String] host the request host string
+      # @param [String] uri the query string
+      # @param [Object] content the result class instance
+      def save(host, uri, content)
+        # Check expired
+        perform_cache_dir
+        # Calculate TTL in seconds
+        expire = (content.cached_until - content.request_time).to_i
+        # If TTL > EOAT.max_ttl set EOAT.max_tt as expire
+        expire = expire > EOAT.max_ttl ? EOAT.max_ttl : expire
+        # If 0 or a negative value, it does not save
+        if expire > 0
+          # Set expired as timestamp of date
+          expired = (content.request_time + expire).to_i
+          # Perform host string to md5 string
+          host = EOAT::Cache.md5hash(host)
+          # Perform uri string to md5 string
+          uri = EOAT::Cache.md5hash(uri)
+          # Combine parameters to path
+          save_path = "#{@path}/#{host}/#{uri}/#{expired}"
+          # This principle is not possible, but should be checked
+          if File.exists?(save_path)
+            raise EOAT::Exception::CacheSaveError.new("Save path: #{save_path} already exists!")
+          end
+          # Create directory
+          FileUtils.mkpath(save_path)
+          # Save instance to result.yml
+          File.write("#{save_path}/result.yml", content.to_yaml)
+        end
+      end
+
+      private
+
+      # Validation of the file structure and the removal of expired data.
+      def perform_cache_dir
+        timestamps = Dir["#{@path}/*/*/*"]
+        unless timestamps.empty?
+          timestamp_now = Time.now.utc.to_i
+          timestamps.each do |timestamp|
+            FileUtils.rmtree(timestamp) if timestamp.split('/').last.to_i < timestamp_now
+          end
+        end
+        uri_hashes = Dir["#{@path}/*/*"]
+        unless uri_hashes.empty?
+          uri_hashes.each do |uri|
+            FileUtils.rmtree(uri) if Dir["#{uri}/*"].empty?
+          end
+        end
+        host_hashes = Dir["#{@path}/*"]
+        unless host_hashes.empty?
+          host_hashes.each do |host|
+            FileUtils.rmtree(host) if Dir["#{host}/*"].empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eoat/cache/memcached_cache.rb

@@ -0,0 +1,54 @@
+module EOAT
+  module Cache
+    # Memcached cache handler. Used `gem memcache`
+    # Default use standard connection parameters.
+    # @author Ivan Kotov {mailto:i.s.kotov.ws e-mail}
+    # @example Set Memcached as a cache storage, with default Memcached `address` and `port`
+    #   EOAT.cache = EOAT::Cache::MemcachedCache.new
+    # @example Set Redis as a cache storage, with connect to custom server:port and not set key prefix
+    #   EOAT.cache = EOAT::Cache::MemcachedCache.new('10.0.1.1:11212', '')
+    class MemcachedCache
+      require 'yaml'
+
+      # @param [String] server the connection string `<ip-address>:<port>`
+      # @param [String] prefix the prefix for keys
+      def initialize(server='localhost:11211', prefix='eoat')
+        require 'memcache'
+
+        @backend = Memcache.new(:server => server, :namespace => prefix, :segment_large_values => true)
+      end
+
+      # Get object from cache
+      # @param [String] host the request host string
+      # @param [String] uri the query string
+      # @return [Object, NilClass] the instance of result class
+      #   or nil if key not does not exist
+      def get(host, uri)
+        # Set key as md5 string
+        key = EOAT::Cache.md5hash(host + uri)
+        @backend.get(key)
+      end
+
+      # Save instance of result class.
+      # @param [String] host the request host string
+      # @param [String] uri the query string
+      # @param [Object] content the result class instance
+      def save(host, uri, content)
+        # Calculate TTL in seconds
+        expire = (content.cached_until - content.request_time).to_i
+        # If TTL > EOAT.max_ttl set EOAT.max_tt as expire
+        expire = expire > EOAT.max_ttl ? EOAT.max_ttl : expire
+        # If 0 or a negative value, it does not save.
+        if expire > 0
+          # Set key as md5 string
+          key = EOAT::Cache.md5hash(host + uri)
+          @backend.set(
+              key,
+              content,
+              :expiry => expire
+          )
+        end
+      end
+    end
+  end
+end

data/lib/eoat/cache/none_cache.rb

@@ -0,0 +1,36 @@
+module EOAT
+  # Collection of EOAT cache handlers
+  # @author Ivan Kotov {mailto:i.s.kotov.ws e-mail}
+  # All handlers have a public methods: #get and #save
+  module Cache
+    # NoneCache - fake cache class. The default cache handler.
+    # @author Ivan Kotov {mailto:i.s.kotov.ws e-mail}
+    class NoneCache
+
+      # Fake get method. Always return false
+      # @param [String] host the request host string
+      # @param [String] uri the query string
+      # @return [FalseClass]
+      def get(host, uri)
+        return false
+      end
+
+      # Fake save method. It does not make anything
+      # @param [String] host the request host string
+      # @param [String] uri the query string
+      # @param [Object] content the result class instance
+      def save(host, uri, content)
+      end
+    end
+
+    # Module method. Calculating md5 of string.
+    # Used by all cached handlers.
+    # @param [String] string
+    # @return [String] the md5 hash string
+    def self.md5hash(string)
+      require 'digest/md5'
+
+      return Digest::MD5.hexdigest(string.to_s)
+    end
+  end
+end

data/lib/eoat/cache/redis_cache.rb

@@ -0,0 +1,61 @@
+module EOAT
+  module Cache
+    # Redis cache handler. Used `gem redis`
+    # Default use standard connection parameters.
+    # @author Ivan Kotov {mailto:i.s.kotov.ws e-mail}
+    # @example Set Redis as a cache storage, with default Redis `address` and `port`
+    #   EOAT.cache = EOAT::Cache::RedisCache.new
+    # @example Set Redis as a cache storage, with connect to socket and not set key prefix
+    #   EOAT.cache = EOAT::Cache::RedisCache.new(:path => '/var/run/redis.sock', :prefix => '')
+    class RedisCache
+
+      # @see https://github.com/redis/redis-rb Official gem website
+      # @param [Hash] kwargs the keywords arguments.
+      #   If not send `:prefix => value` set default `:prefix => 'eoat:'`
+      #   Allows  take the connection parameters, example
+      #   `:host => "10.0.1.1", :port => 6380` or `:path => "/tmp/redis.sock"`
+      def initialize(**kwargs)
+        require 'redis'
+
+        @prefix = kwargs.key?(:prefix) ? kwargs.delete(:prefix) : 'eoat:'
+        @backend = Redis.new(kwargs)
+      end
+
+      # Get object from cache
+      # @param [String] host the request host string
+      # @param [String] uri the query string
+      # @return [Object, NilClass] the instance of result class
+      #   or nil if key not does not exist
+      def get(host, uri)
+        # Set key as md5 string
+        key = @prefix + EOAT::Cache.md5hash(host + uri)
+        cache = @backend.get(key)
+        # If the data is successfully received,
+        # then restore instance from yaml string
+        cache ? YAML::load(cache) : false
+      end
+
+      # Save instance of result class.
+      # @param [String] host the request host string
+      # @param [String] uri the query string
+      # @param [Object] content the result class instance
+      def save(host, uri, content)
+        # Calculate TTL in seconds
+        expire = (content.cached_until - content.request_time).to_i
+        # If TTL > EOAT.max_ttl set EOAT.max_tt as expire
+        expire = expire > EOAT.max_ttl ? EOAT.max_ttl : expire
+        # If 0 or a negative value, it does not save.
+        if expire > 0
+          # Set key as md5 string
+          key = @prefix + EOAT::Cache.md5hash(host + uri)
+          # Export result instance to yaml string.
+          yaml = content.to_yaml
+          # Store yaml string in Redis
+          @backend.set(key, yaml)
+          # Set TTL
+          @backend.expire(key, expire)
+        end
+      end
+    end
+  end
+end

data/lib/eoat/eve_api.rb

@@ -0,0 +1,49 @@
+module EOAT
+  # EveApi class - call class. Collects user input, building a url request
+  # and passes it  to the Request class.
+  # @author Ivan Kotov {mailto:i.s.kotov.ws e-mail}
+  # @example Get EVE skills from https://api.eveonline.com/eve/SkillTree.xml.aspx
+  #   skills = EOAT::EveApi.new.SkillTree
+  #   skills.result #=> ["skillGroups"]
+  # @example Get API key info
+  #   key_info = EOAT::EveApi.new('keyID', 'vCode', scope: 'account').APIKeyInfo
+  #   key_info.key.type #=> "Corporation"
+  class EveApi
+
+    # @param [Integer, String] key_id EVE API keyID
+    # @param [String] v_code EVE API vCode
+    # @param [String] scope part of request uri
+    # @param [String] host request host
+    def initialize(key_id='', v_code='', scope: 'eve', host: 'https://api.eveonline.com')
+      @key_id = key_id.to_s
+      @v_code = v_code.to_s
+      @scope = scope.to_s
+      @host = host.to_s
+      unless key_id.to_s.empty?
+        raise ArgumentError, 'You do not specify vCode' if v_code.to_s.empty?
+      end
+      raise ArgumentError, 'vCode must be string' unless v_code.instance_of? String
+    end
+
+    # Create an request according to the method called.
+    # This is used to dynamically create api calls.
+    # @return [Object] the result class
+    def method_missing(method, **kwargs)
+      uri = create_uri(method.id2name, kwargs)
+      EOAT::Request.new(@host, uri, EOAT::Result::EveType::Result).get
+    end
+
+    private
+
+    # Collect all request parameters and combine it to query string.
+    # @param [String] fake_method the name of missing method
+    # @param [Hash] kwargs the keyword arguments
+    # @return [String]
+    def create_uri(fake_method, **kwargs)
+      kwargs = kwargs.merge({:keyID => @key_id, :vCode => @v_code}) unless @key_id.empty?
+      query_string = kwargs ? kwargs.map {|k, v| "#{k}=#{v}"}.join('&') : ''
+      query_string.insert(0, '?') unless query_string.empty?
+      "#{@scope}/#{fake_method}.xml.aspx#{query_string}"
+    end
+  end
+end

data/lib/eoat/exception.rb

@@ -0,0 +1,63 @@
+module EOAT
+  # Collection of all EOAT exceptions
+  # @author Ivan Kotov {mailto:i.s.kotov.ws e-mail}
+  module Exception
+    # Standard EOAT error.
+    # All other exception inherited from it.
+    class EOATError < StandardError
+    end
+
+    # It is used when the HTTP response code different from 200, 404 or 0.
+    class HTTPError < EOATError
+      attr_reader :status, :headers
+
+      # @param [Integer] status the HTTP status code
+      # @param [Hash] headers the Hash of response headers
+      def initialize(status, headers)
+        @status = status
+        @headers = headers
+      end
+    end
+
+    # Raised when response return 404 HTTP error
+    class HTTP404Error < EOATError
+    end
+
+    # Used when response data is incorrect.
+    class ParseError < EOATError
+    end
+
+    # Very rare error. Made just in case.
+    # Used to prevent overwriting the cache.
+    class CacheSaveError < EOATError
+    end
+
+    # All EveApi xml errors will be raise this error.
+    # It has a method that stores the error number.
+    # @see
+    #   https://api.eveonline.com/eve/ErrorList.xml.aspx Full error list
+    class EveApiError < EOATError
+      attr_reader :number
+
+      # @param [Integer] number the custom EVE API error number
+      def initialize(number)
+        @number = number
+      end
+    end
+
+    # TODO: Check parse algorithm
+
+    # Called when the HTTP response code is 0
+    # Parse EveType xml error page and raise EveApiError with parsed number.
+    # @param [Hash] page parsed response body
+    # @raise [EOAT::Exception::EveApiError] EVE API response custom error
+    def self.parse_error_page(page)
+      if page.class == Hash
+        if page['eveapi']
+          error = page['eveapi']['error']
+          raise EOAT::Exception::EveApiError.new(error['code'].to_i), "#{error['__content__']}"
+        end
+      end
+    end
+  end
+end