eve-4 2.0.1 → 2.0.2

data/lib/eve/api/connectivity.rb

@@ -0,0 +1,39 @@
+module Eve
+  class API
+    module Connectivity
+      MAX_JOURNAL_ENTRIES = 1000
+
+      def walk(walk_id, walk_association, options = {}, &block)
+        raise ArgumentError, "Requires :walk_id" if walk_id.blank?
+        raise ArgumentError, "Requires :walk_association" if walk_association.blank?
+        options[walk_id] ||= 0
+        return_value = yield options
+        array = return_value.send(walk_association)
+        if array.size >= MAX_JOURNAL_ENTRIES
+          begin
+            min_id = nil
+            primary_key = array.primary_key
+            array.each { |txn| min_id = txn.send(primary_key) if min_id.nil? || min_id > txn.send(primary_key) }
+            array.concat walk(walk_id, options.merge(walk_id => min_id), &block).send(walk_association)
+          rescue Eve::Errors::UserInputErrors::InvalidBeforeTransID, Eve::Errors::UserInputErrors::InvalidBeforeRefID,
+                 Eve::Errors::UserInputErrors::InvalidBeforeKillID
+            # walking is internal, so we should catch the error internally too.
+          end
+        end
+        return_value
+      end
+
+      def request(namespace, service_name, options = {})
+        walk_id = options.delete(:walk_id) # we don't want these being sent to the server; it messes with the cache.
+        walk_association = options.delete(:walk_association)
+        if options.delete(:walk)
+          walk(walk_id.to_s, walk_association, options) do |walk_options|
+            Eve::API::Request.new(namespace, service_name, self.options.merge(walk_options)).dispatch
+          end
+        else
+          Eve::API::Request.new(namespace, service_name, self.options.merge(options)).dispatch
+        end
+      end
+    end
+  end
+end

data/lib/eve/api/request.rb

@@ -0,0 +1,80 @@
+module Eve
+  class API
+    class Request
+      attr_reader :response, :uri, :options, :namespace, :service
+      
+      def initialize(namespace, service, options = {})
+        options.reverse_merge! default_options
+        namespace = namespace.to_s if namespace.is_a?(Symbol)
+        service   = service.to_s   if service.is_a?(Symbol)
+
+        unless [:xml,:string].include? options[:response_type]
+          raise ArgumentError, "Expected :response_type to be :xml or :string"
+        end
+
+        @options = options.dup
+        @service = options[:camelize] ? service.camelize : service
+        @namespace = namespace
+        @response_type = options[:response_type]
+
+        @uri = File.join(@options.delete(:base_uri), @namespace, "#{@service}.#{options[:extension]}")
+      end
+
+      def dispatch
+        r = cached_response || cache_response {
+          url = URI.parse uri
+          request = Net::HTTP::Post.new url.path
+          request.set_form_data post_options
+          http = Net::HTTP.new url.host, url.port
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          http.start { |http| http.request(request) }.body
+        }
+        if r.respond_to?(:error) && r.error
+          Eve::Errors.raise(:code => r.error.code, :message => r.error)
+        end
+        r
+      end
+
+      def cached_response
+        if xml = (options[:cache] ? Eve.cache.read(cache_key) : nil)
+          potential_response = response_for(xml)
+          if !potential_response.respond_to?(:cached_until) || potential_response.cached_until >= Time.now
+            return potential_response
+          end
+        end
+        nil
+      end
+
+      def response_for(body)
+        @response_type == :xml ? Eve::API::Response.new(body, options) : body
+      end
+
+      def cache_response
+        xml = yield
+        Eve.cache.write(cache_key, xml) if options[:cache]
+        response_for xml
+      end
+
+      def cache_key
+        @cache_key ||= ActiveSupport::Cache.expand_cache_key(post_options, @uri)
+      end
+
+      private
+      def post_options
+        options.without(default_options.keys).camelize_keys
+      end
+
+      def default_options
+        {
+          :base_uri => "https://api.eve-online.com",
+          :extension => "xml.aspx",
+          :camelize => true,
+          :response_type => :xml,
+          :column_mapping => nil,
+          :cache => true
+        }
+      end
+    end
+  end
+end

data/lib/eve/api/response.rb

@@ -0,0 +1,34 @@
+module Eve
+  class API
+    class Response
+      autoload :Result, 'eve/api/response/result'
+      autoload :Row,    'eve/api/response/row'
+      autoload :Rowset, 'eve/api/response/rowset'
+
+      include Eve::API::Response::Result
+      attr_reader :rowsets
+      attr_reader :api_version, :content
+      alias_method :apiVersion, :api_version
+
+      def initialize(xml, options = {})
+        @options = options
+        @rowsets = []
+
+        if xml.kind_of? String
+          @xml = Nokogiri::XML(xml).root
+        else
+          @xml = xml
+        end
+
+        unless options[:process_xml] == false
+          @api_version = @xml.attributes['version'].value
+          parse_children @xml
+          result = @xml.xpath("//result")[0]
+          parse_children result if result
+          all_fields << 'api_version'
+          all_fields.delete 'result'
+        end
+      end
+    end
+  end
+end

data/lib/eve/api/response/result.rb

@@ -0,0 +1,87 @@
+module Eve::API::Response::Result
+  def all_fields
+    @all_fields ||= []
+  end
+
+  def delegate_to_rowset(field_name, rowset)
+    all_fields << field_name.underscore
+    klass = (class << self; self; end)
+    rowset = Eve::API::Response::Rowset.new rowset
+    klass.module_eval do
+      define_method field_name do
+        rowset
+      end
+
+      if field_name.underscore != field_name
+        alias_method field_name.underscore, field_name
+      end
+    end
+    rowset
+  end
+
+  def literal_value_for(str)
+    YAML::load str
+  rescue (defined?(Psych::SyntaxError) ? Psych::SyntaxError : StandardError)
+    str
+  end
+
+  def delegate_to_child(field_name, node)
+    all_fields << field_name.underscore
+    klass = (class << self; self; end)
+    if !node.children.empty? && node.children.reject { |c| c.text? }.empty?
+      # this seems less correct but specs pass this way
+      if node.name != 'error'
+        child = literal_value_for node.content.strip
+      else
+        child = Eve::API::Response::Row.new node
+      end
+
+      # if node.attributes.empty?
+      #   # node contains only text
+      #   child = literal_value_for node.content.strip
+      # else
+      #   child = Eve::API::Response::Row.new node
+      # end
+    else
+      child = Eve::API::Response::Row.new node
+    end
+    klass.module_eval do
+      define_method field_name do
+        child
+      end
+
+      if field_name.underscore != field_name
+        alias_method field_name.underscore, field_name
+      end
+    end
+    child
+  end
+
+  def parse_children(node)
+    node.children.each do |child|
+      next if child.text?
+      case child.name
+        when 'rowset'
+          rowset = delegate_to_rowset child.attributes['name'].value, child
+          rowsets << rowset
+        else
+          delegate_to_child child.name, child
+      end
+    end
+  end
+
+  def [](name)
+    send name
+  end
+
+  def to_hash
+    all_fields.inject({}) do |hash, field_name|
+      hash[field_name] = self[field_name]
+      hash
+    end
+  end
+
+  def to_yaml(*args)
+    to_hash.to_yaml(*args)
+  end
+end

data/lib/eve/api/response/row.rb

@@ -0,0 +1,42 @@
+class Eve::API::Response::Row
+  include Eve::API::Response::Result
+  attr_reader :fields
+  attr_reader :rowsets
+
+  def initialize(row, columns = row.attribute_nodes.collect { |c| c.name })
+    @rowsets = []
+
+    # @fields = row.attributes.keys.collect { |f| f.underscore }
+    @fields = columns.collect { |c| c.underscore }
+
+    # pre-emptively define all known columns to return nil
+    klass = (class << self; self; end)
+    columns.each { |c| klass.send(:define_method, c.underscore) { nil } }
+
+    row.attribute_nodes.each_with_index do |attr, i|
+      name = columns[i]
+      if name.nil?
+        name = attr.name
+        @fields << name.underscore
+      end
+      value = literal_value_for attr.value
+
+      klass.module_eval do
+        define_method name.underscore do
+          value
+        end
+
+        alias_method name, name.underscore
+      end
+    end
+
+    parse_children row
+  end
+
+  def inspect
+    "<Row " +
+    fields.map do |field_name|
+      "#{field_name}: #{send field_name}"
+    end.join(', ') + ">"
+  end
+end

data/lib/eve/api/response/rowset.rb

@@ -0,0 +1,18 @@
+class Eve::API::Response::Rowset < Array
+  attr_reader :columns, :key, :name
+
+  def initialize(rowset)
+    super()
+
+    @columns = rowset.attributes['columns'].value.split(/\s*,\s*/)
+    @name = rowset.attributes['name'].value
+
+    if rowset.attributes.key?('key')
+      @key  = rowset.attributes['key'].value
+    end
+
+    rowset.children.each do |child|
+      self << Eve::API::Response::Row.new(child, @columns) unless child.text?
+    end
+  end
+end

data/lib/eve/api/services.rb

@@ -0,0 +1,20 @@
+require 'eve/api/services/map'
+require 'eve/api/services/misc'
+require 'eve/api/services/server'
+require 'eve/api/services/eve'
+require 'eve/api/services/account'
+require 'eve/api/services/character'
+require 'eve/api/services/corporation'
+
+module Eve
+  class API
+    module Services
+      def self.included(base)
+        base.instance_eval do
+          include ::Eve::API::Services::Misc
+          include ::Eve::API::Services::Server
+        end
+      end
+    end
+  end
+end

data/lib/eve/api/services/account.rb

@@ -0,0 +1,12 @@
+module Eve
+  class API
+    module Services
+      module Account
+        def characters
+          validate_credentials(:limited)
+          request(:account, :characters)
+        end
+      end
+    end
+  end
+end

data/lib/eve/api/services/character.rb

@@ -0,0 +1,96 @@
+module Eve
+  class API
+    module Services
+      module Character
+        #limited API key
+        def character_sheet; request(:char, :character_sheet); end
+        #limited API key
+        def fac_war_stats; request(:char, :fac_war_stats); end
+        #limited API key
+        def medals; request(:char, :medals); end
+        #limited API key
+        def skill_in_training; request(:char, :skill_in_training); end
+        #limited API key
+        def skill_queue; request(:char, :skill_queue); end
+        #limited API key
+        def standings; request(:char, :standings); end
+
+        # full API key
+        def account_balance; request(:char, :account_balance); end
+        # full API key
+        def asset_list(version = nil)
+          request(:char, :asset_list, {:version => version}.optionalize)
+        end
+        # full API key
+        def industry_jobs; request(:char, :industry_jobs); end
+
+        # This API call only returns 1000 entries. Often, you will need to gather all entries, and not just the
+        # most recent 1000. If this is true for your application, simply pass the :walk option and this EVE library
+        # will automatically "walk" backward in time until the server reports that there are no more entries available.
+        #
+        # Walking is disabled by default, so you need to pass the :walk => true option if you wish to enable this.
+        #
+        # full API key
+        def kill_log(options = {})
+          options.reverse_merge!({:walk => false, :walk_id => 'before_kill_id', :walk_association => 'kills' })
+          validate_options(options, :walk, :walk_id, :walk_association)
+          request(:char, :kill_log, options)
+        end
+        # full API key
+        def mailing_lists; request(:char, :mailing_lists); end
+        # full API key
+        def mail_messages; request(:char, :mail_messages); end
+        # full API key
+        def market_orders; request(:char, :market_orders); end
+        # full API key
+        def notifications; request(:char, :notifications); end
+        # full API key
+        def research; request(:char, :research); end
+
+        # This API call only returns 1000 entries. Often, you will need to gather all entries, and not just the
+        # most recent 1000. If this is true for your application, simply pass the :walk option and this EVE library
+        # will automatically "walk" backward in time until the server reports that there are no more entries available.
+        #
+        # Walking is disabled by default, so you need to pass the :walk => true option if you wish to enable this.
+        #
+        # full API key
+        def wallet_journal(account_key = 1000, options = { })
+          if account_key.kind_of?(Hash)
+            options = account_key
+            account_key = 1000
+          end
+          options.reverse_merge!({:walk => false, :walk_id => 'before_ref_id', :walk_association => 'entries' })
+          validate_options(options, :walk, :walk_id, :walk_association)
+          request(:char, :wallet_journal, options.merge(:account_key => account_key))
+        end
+
+        # This API call only returns 1000 entries. Often, you will need to gather all entries, and not just the
+        # most recent 1000. If this is true for your application, simply pass the :walk option and this EVE library
+        # will automatically "walk" backward in time until the server reports that there are no more entries available.
+        #
+        # Walking is disabled by default, so you need to pass the :walk => true option if you wish to enable this.
+        #
+        # full API key
+        def wallet_transactions(options = {})
+          options.reverse_merge!({:walk => false, :walk_id => 'before_trans_id', :walk_association => 'transactions' })
+          validate_options(options, :walk, :walk_id, :walk_association)
+          request(:char, :wallet_transactions, options)
+        end
+
+        alias journal_entries wallet_journal
+
+        def self.included(base)
+          base.instance_eval do
+            validate_credentials :limited, :character_id,
+                                 :for => %w(character_sheet fac_war_stats medals skill_in_training skill_queue standings
+                                           )
+            validate_credentials :full, :character_id,
+                                 :for => %w(account_balance asset_list industry_jobs kill_log mailing_lists
+                                            mail_messages market_orders notifications research wallet_journal
+                                            wallet_transactions journal_entries)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eve/api/services/corporation.rb

@@ -0,0 +1,150 @@
+module Eve
+  class API
+    module Services
+      module Corporation
+        # limited or no API key
+        def corporation_sheet(corporation_id = nil)
+          request(:corp, :corporation_sheet, {:corporation_id => corporation_id}.optionalize)
+        end
+
+        # limited API key
+        def fac_war_stats
+          validate_credentials :limited, :character_id
+          request(:corp, :fac_war_stats)
+        end
+
+        # limited API key
+        def medals
+          validate_credentials :limited, :character_id
+          request(:corp, :medals)
+        end
+
+        # limited API key
+        def member_medals
+          validate_credentials :limited, :character_id
+          request(:corp, :member_medals)
+        end
+
+        # full API key
+        def account_balance
+          validate_credentials :full, :character_id
+          request(:corp, :account_balance)
+        end
+
+        # full API key
+        def asset_list
+          validate_credentials :full, :character_id
+          request(:corp, :asset_list)
+        end
+
+        # full API key
+        def container_log
+          validate_credentials :full, :character_id
+          request(:corp, :container_log)
+        end
+
+        # full API key
+        def industry_jobs
+          validate_credentials :full, :character_id
+          request(:corp, :industry_jobs)
+        end
+
+        # full API key
+        def market_orders
+          validate_credentials :full, :character_id
+          request(:corp, :market_orders)
+        end
+
+        # full API key
+        def member_security
+          validate_credentials :full, :character_id
+          request(:corp, :member_security)
+        end
+
+        # full API key
+        def member_security_log
+          validate_credentials :full, :character_id
+          request(:corp, :member_security_log)
+        end
+
+        # full API key
+        def member_tracking
+          validate_credentials :full, :character_id
+          request(:corp, :member_tracking)
+        end
+
+        # full API key
+        def shareholders
+          validate_credentials :full, :character_id
+          request(:corp, :shareholders)
+        end
+
+        # full API key
+        def standings
+          validate_credentials :full, :character_id
+          request(:corp, :standings)
+        end
+
+        # full API key
+        def titles
+          validate_credentials :full, :character_id
+          request(:corp, :titles)
+        end
+
+        def starbase_detail(item_id, version = 2)
+          validate_credentials :full, :character_id
+          request(:corp, :starbase_detail, {:item_id => item_id, :version => version})
+        end
+
+        def starbase_list
+          validate_credentials :full, :character_id
+          request(:corp, :starbase_list, :version => 2)
+        end
+
+        # This API call only returns 1000 entries. Often, you will need to gather all entries, and not just the
+        # most recent 1000. If this is true for your application, simply pass the :walk option and this EVE library
+        # will automatically "walk" backward in time until the server reports that there are no more entries available.
+        #
+        # Walking is disabled by default, so you need to pass the :walk => true option if you wish to enable this.
+        def kill_log(options = {})
+          validate_credentials :full, :character_id
+          options.reverse_merge!({:walk => false, :walk_id => 'before_kill_id', :walk_association => 'kills' })
+          validate_options(options, :walk, :walk_id, :walk_association)
+          request(:corp, :kill_log, options)
+        end
+
+        # This API call only returns 1000 entries. Often, you will need to gather all entries, and not just the
+        # most recent 1000. If this is true for your application, simply pass the :walk option and this EVE library
+        # will automatically "walk" backward in time until the server reports that there are no more entries available.
+        #
+        # Walking is disabled by default, so you need to pass the :walk => true option if you wish to enable this.
+        def wallet_journal(account_key = 1000, options = {})
+          validate_credentials :full, :character_id
+          if account_key.kind_of?(Hash)
+            options.merge! account_key
+            account_key = 1000
+          end
+          options.reverse_merge!({:walk => false, :walk_id => 'before_ref_id', :walk_association => 'entries' })
+          validate_options(options, :walk, :walk_id, :walk_association)
+          request(:corp, :wallet_journal, options.merge(:account_key => account_key))
+        end
+
+        # This API call only returns 1000 entries. Often, you will need to gather all entries, and not just the
+        # most recent 1000. If this is true for your application, simply pass the :walk option and this EVE library
+        # will automatically "walk" backward in time until the server reports that there are no more entries available.
+        #
+        # Walking is disabled by default, so you need to pass the :walk => true option if you wish to enable this.
+        def wallet_transactions(account_key = 1000, options = {})
+          validate_credentials :full, :character_id
+          if account_key.kind_of?(Hash)
+            options.merge! account_key
+            account_key = 1000
+          end
+          options.reverse_merge!({:walk => false, :walk_id => 'before_trans_id', :walk_association => 'transactions' })
+          validate_options(options, :walk, :walk_id, :walk_association)
+          request(:corp, :wallet_transactions, options.merge(:account_key => account_key))
+        end
+      end
+    end
+  end
+end