eve 1.0.0

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

@@ -0,0 +1,62 @@
+module Eve
+  class API
+    class Response
+      module Inspection
+        def protected_instance_variables
+          (respond_to?(:content) && !content.blank? ? [] : ["@content"]) +
+          #(respond_to?(:rowsets) && !rowsets.empty? ? rowsets.collect { |r| "@#{r.name}" } : []) +
+          %w(@rowsets @options @xml @columns @row @name)
+        end
+
+        def inspected_name
+          respond_to?(:name) ? self.name : "(Response)"
+        end
+
+        def inspected_rowsets
+          return nil unless respond_to?(:rowsets) && !rowsets.empty?
+          "[#{rowsets.collect { |r| r.inspect }.join(", ")}]"
+        end
+
+        def inspected_elements
+          return nil unless respond_to?(:empty?) && !empty?
+          "[#{self.collect { |i| i.inspect }.join(", ")}]"
+        end
+
+        def inspected_instance_variables
+          return nil if (ivars = instance_variables - protected_instance_variables).empty?
+
+          ivars.sort! do |a, b|
+            original = a <=> b
+            a = instance_variable_get(a)
+            b = instance_variable_get(b)
+            a_rowset = a.kind_of?(Rowset)
+            b_rowset = b.kind_of?(Rowset)
+
+            if a_rowset && b_rowset then a.name <=> b.name
+            elsif a_rowset && !b_rowset then 1
+            elsif !a_rowset && b_rowset then -1
+            else original
+            end
+          end
+
+          "#{ivars.map do |ivar|
+            v = instance_variable_get(ivar)
+            if v.kind_of?(Rowset)
+              v.inspect
+            else
+              "#{ivar[1..-1]}=>#{instance_variable_get(ivar).inspect}"
+            end
+          end.join(" ")}"
+        end
+
+        def inspect
+          r = "#<#{inspected_name}"
+          r.concat " #{inspected_instance_variables}" if !inspected_instance_variables.nil?
+          r.concat ">"
+          r.concat "#{inspected_elements}" if !inspected_elements.nil?
+          return r
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Eve
+  class API
+    class Response
+      class Rowset < Array
+        include Inspection
+        include WrapObject
+        attr_reader :name, :primary_key, :columns
+        alias key primary_key
+
+        def initialize(elem, options = {})
+          super()
+          @options = options
+          parse_elem(elem)
+        end
+
+        def delegate_from(object)
+          klass = class << object; self; end
+          var_name = name.underscore
+          object.instance_variable_set("@#{var_name}", self)
+          klass.send(:attr_reader, var_name)
+          klass.send(:alias_method, var_name.camelize.dehumanize, var_name)
+        end
+
+        def to_yaml(*args)
+          to_a.to_yaml(*args)
+        end
+
+        private
+        def parse_elem(elem)
+          raise ArgumentError, "Expected an Hpricot::Elem, got #{elem.class}" unless elem.kind_of?(Hpricot::Elem)
+          raise ArgumentError, "Expected a rowset element, got #{elem.name}" unless elem.name == 'rowset'
+
+          @name = elem['name']
+          @primary_key = elem['key']
+          @columns = elem['columns'].split(/,/).collect { |c| c.strip }
+
+          elem.children.each do |child|
+            if child.is_a?(Hpricot::Elem)
+              case child.name
+                when 'row' then parse_row(child)
+                else raise "Expected a row element, got #{child.name.inspect}"
+              end
+            end
+          end if elem.children
+        end
+
+        def parse_row(elem)
+          row = Eve::API::Response.new(elem, @options)
+          row.copy_attributes(columns, elem)
+          row.send(:parse_children, elem)
+          self << row
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Eve
+  class API
+    class Response
+      module Rowsets
+        def rowset_names
+          rowsets.collect { |c| c.name }
+        end
+
+        def add_rowset(rowset)
+          rowsets << rowset
+          rowset.delegate_from(self)
+        end
+
+        def rowsets; @rowsets ||= []; end
+
+        def copy_attributes(columns, row_element, into = self)
+          attributes = row_element.attributes.to_hash.rename((@options[:column_mapping] || {}))
+
+          #missing_attributes = columns - attributes.keys
+          #extra_attributes = attributes.keys - columns
+          #raise Eve::Errors::InvalidRowset,
+          #      "Missing attributes from row: #{missing_attributes.inspect}" if !missing_attributes.empty?
+          #raise Eve::Errors::InvalidRowset,
+          #      "Extra attributes in row: #{extra_attributes.inspect}" if !extra_attributes.empty?
+          if !into.respond_to?(:wrap_object)
+            klass = into.class
+            klass.send(:include, WrapObject)
+          end
+          columns.each do |column|
+            into.send(:wrap_object, column, value_for(attributes[column]))
+          end
+        end
+
+        def value_for(candidate)
+          candidate.kind_of?(String) ? YAML::load(candidate) : candidate
+        rescue
+          candidate
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Eve
+  class API
+    class Response
+      module WrapObject
+        def wrap_object(method_name, value)
+          klass = (class << self; self; end)
+          underscored = method_name.to_s.underscore
+          klass.send(:attr_reader, underscored)
+          klass.send(:delegate, method_name, :to => underscored) unless method_name == underscored
+          instance_variable_set("@#{underscored}", value)
+        end
+      end
+    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