ib-ruby 0.7.4 → 0.7.6

data/lib/ib-ruby/messages/incoming/abstract_message.rb

@@ -0,0 +1,100 @@
+require 'ib-ruby/messages/abstract_message'
+
+module IB
+  module Messages
+    module Incoming
+
+      # Container for specific message classes, keyed by their message_ids
+      Classes = {}
+
+      class AbstractMessage < IB::Messages::AbstractMessage
+
+        def version # Per message, received messages may have the different versions
+          @data[:version]
+        end
+
+        def check_version actual, expected
+          unless actual == expected || expected.is_a?(Array) && expected.include?(actual)
+            error "Unsupported version #{actual} received, expected #{expected}"
+          end
+        end
+
+        # Create incoming message from a given source (IB server or data Hash)
+        def initialize source
+          @created_at = Time.now
+          if source[:socket] # Source is a server
+            @server = source
+            @data = Hash.new
+            begin
+              self.load
+            rescue => e
+              error "Reading #{self.class}: #{e.class}: #{e.message}", :load, e.backtrace
+            ensure
+              @server = nil
+            end
+          else # Source is a @data Hash
+            @data = source
+          end
+        end
+
+        def socket
+          @server[:socket]
+        end
+
+        # Every message loads received message version first
+        # Override the load method in your subclass to do actual reading into @data.
+        def load
+          @data[:version] = socket.read_int
+
+          check_version @data[:version], self.class.version
+
+          load_map *self.class.data_map
+        end
+
+        # Load @data from the socket according to the given data map.
+        #
+        # map is a series of Arrays in the format of
+        #   [ :name, :type ], [  :group, :name, :type]
+        # type identifiers must have a corresponding read_type method on socket (read_int, etc.).
+        # group is used to lump together aggregates, such as Contract or Order fields
+        def load_map(*map)
+          map.each do |instruction|
+            # We determine the function of the first element
+            head = instruction.first
+            case head
+              when Integer # >= Version condition: [ min_version, [map]]
+                load_map *instruction.drop(1) if version >= head
+
+              when Proc # Callable condition: [ condition, [map]]
+                load_map *instruction.drop(1) if head.call
+
+              when true # Pre-condition already succeeded!
+                load_map *instruction.drop(1)
+
+              when nil, false # Pre-condition already failed! Do nothing...
+
+              when Symbol # Normal map
+                group, name, type, block =
+                    if  instruction[2].nil? || instruction[2].is_a?(Proc)
+                      [nil] + instruction # No group, [ :name, :type, (:block) ]
+                    else
+                      instruction # [ :group, :name, :type, (:block)]
+                    end
+
+                data = socket.__send__("read_#{type}", &block)
+                if group
+                  @data[group] ||= {}
+                  @data[group][name] = data
+                else
+                  @data[name] = data
+                end
+              else
+                error "Unrecognized instruction #{instruction}"
+            end
+          end
+        end
+
+      end # class AbstractMessage
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib-ruby/messages/incoming/alert.rb

@@ -0,0 +1,34 @@
+module IB
+  module Messages
+    module Incoming
+
+      # Called Error in Java code, but in fact this type of messages also
+      # deliver system alerts and additional (non-error) info from TWS.
+      ErrorMessage = Error = Alert = def_message([4, 2],
+                                                 [:error_id, :int],
+                                                 [:code, :int],
+                                                 [:message, :string])
+      class Alert
+        # Is it an Error message?
+        def error?
+          code < 1000
+        end
+
+        # Is it a System message?
+        def system?
+          code > 1000 && code < 2000
+        end
+
+        # Is it a Warning message?
+        def warning?
+          code > 2000
+        end
+
+        def to_human
+          "TWS #{ error? ? 'Error' : system? ? 'System' : 'Warning'} #{code}: #{message}"
+        end
+      end # class Alert
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib-ruby/messages/incoming/contract_data.rb

@@ -0,0 +1,82 @@
+module IB
+  module Messages
+    module Incoming
+
+      ContractDetails = ContractData =
+          def_message([10, 6],
+                      [:request_id, :int], # request id
+                      [:contract, :symbol, :string],
+                      [:contract, :sec_type, :string],
+                      [:contract, :expiry, :string],
+                      [:contract, :strike, :decimal],
+                      [:contract, :right, :string],
+                      [:contract, :exchange, :string],
+                      [:contract, :currency, :string],
+                      [:contract, :local_symbol, :string],
+
+                      [:contract, :market_name, :string], # extended
+                      [:contract, :trading_class, :string],
+                      [:contract, :con_id, :int],
+                      [:contract, :min_tick, :decimal],
+                      [:contract, :multiplier, :string],
+                      [:contract, :order_types, :string],
+                      [:contract, :valid_exchanges, :string],
+                      [:contract, :price_magnifier, :int],
+                      [:contract, :under_con_id, :int],
+                      [:contract, :long_name, :string],
+                      [:contract, :primary_exchange, :string],
+                      [:contract, :contract_month, :string],
+                      [:contract, :industry, :string],
+                      [:contract, :category, :string],
+                      [:contract, :subcategory, :string],
+                      [:contract, :time_zone, :string],
+                      [:contract, :trading_hours, :string],
+                      [:contract, :liquid_hours, :string])
+
+      class ContractData
+
+        def contract
+          @contract = IB::Contract.build @data[:contract]
+        end
+      end # ContractData
+
+      BondContractData =
+          def_message [18, 4],
+                      [:request_id, :int],
+                      [:contract, :symbol, :string],
+                      [:contract, :sec_type, :string],
+                      [:contract, :cusip, :string],
+                      [:contract, :coupon, :decimal],
+                      [:contract, :maturity, :string],
+                      [:contract, :issue_date, :string],
+                      [:contract, :ratings, :string],
+                      [:contract, :bond_type, :string],
+                      [:contract, :coupon_type, :string],
+                      [:contract, :convertible, :boolean],
+                      [:contract, :callable, :boolean],
+                      [:contract, :puttable, :boolean],
+                      [:contract, :desc_append, :string],
+                      [:contract, :exchange, :string],
+                      [:contract, :currency, :string],
+                      [:contract, :market_name, :string], # extended
+                      [:contract, :trading_class, :string],
+                      [:contract, :con_id, :int],
+                      [:contract, :min_tick, :decimal],
+                      [:contract, :order_types, :string],
+                      [:contract, :valid_exchanges, :string],
+                      [:contract, :valid_next_option_date, :string],
+                      [:contract, :valid_next_option_type, :string],
+                      [:contract, :valid_next_option_partial, :string],
+                      [:contract, :notes, :string],
+                      [:contract, :long_name, :string]
+
+      class BondContractData
+
+        def contract
+          @contract = IB::Contract.build @data[:contract]
+        end
+      end # BondContractData
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib-ruby/messages/incoming/delta_neutral_validation.rb

@@ -0,0 +1,20 @@
+module IB
+  module Messages
+    module Incoming
+
+      # The server sends this message upon accepting a Delta-Neutral DN RFQ
+      # - see API Reference p. 26
+      DeltaNeutralValidation = def_message 56,
+                                           [:request_id, :int],
+                                           [:contract, :under_con_id, :int],
+                                           [:contract, :under_delta, :decimal],
+                                           [:contract, :under_price, :decimal]
+      class DeltaNeutralValidation
+        def contract
+          @contract = IB::Contract.build @data[:contract].merge(:under_comp => true)
+        end
+      end # DeltaNeutralValidation
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib-ruby/messages/incoming/execution_data.rb

@@ -0,0 +1,59 @@
+module IB
+  module Messages
+    module Incoming
+
+      ExecutionData =
+          def_message [11, 8],
+                      # The reqID that was specified previously in the call to reqExecution()
+                      [:request_id, :int],
+                      [:execution, :order_id, :int],
+                      [:contract, :con_id, :int],
+                      [:contract, :symbol, :string],
+                      [:contract, :sec_type, :string],
+                      [:contract, :expiry, :string],
+                      [:contract, :strike, :decimal],
+                      [:contract, :right, :string],
+                      [:contract, :exchange, :string],
+                      [:contract, :currency, :string],
+                      [:contract, :local_symbol, :string],
+
+                      [:execution, :exec_id, :string], # Weird format
+                      [:execution, :time, :string],
+                      [:execution, :account_name, :string],
+                      [:execution, :exchange, :string],
+                      [:execution, :side, :string],
+                      [:execution, :shares, :int],
+                      [:execution, :price, :decimal],
+                      [:execution, :perm_id, :int],
+                      [:execution, :client_id, :int],
+                      [:execution, :liquidation, :int],
+                      [:execution, :cumulative_quantity, :int],
+                      [:execution, :average_price, :decimal]
+
+      class ExecutionData
+
+        def contract
+          @contract = IB::Contract.build @data[:contract]
+        end
+
+        def execution
+          @execution = IB::Execution.new @data[:execution]
+        end
+
+        def load
+          super
+
+          # As of client v.53, we can receive orderRef in ExecutionData
+          load_map [proc { | | @server[:client_version] >= 53 },
+                    [:execution, :order_ref, :string]
+                   ]
+        end
+
+        def to_human
+          "<ExecutionData #{request_id}: #{contract.to_human}, #{execution}>"
+        end
+
+      end # ExecutionData
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib-ruby/messages/incoming/historical_data.rb

@@ -0,0 +1,55 @@
+module IB
+  module Messages
+    module Incoming
+
+      # HistoricalData contains following @data:
+      # General:
+      #    :request_id - The ID of the request to which this is responding
+      #    :count - Number of Historical data points returned (size of :results).
+      #    :results - an Array of Historical Data Bars
+      #    :start_date - beginning of returned Historical data period
+      #    :end_date   - end of returned Historical data period
+      # Each returned Bar in @data[:results] Array contains this data:
+      #    :date - The date-time stamp of the start of the bar. The format is
+      #       determined by the RequestHistoricalData formatDate parameter.
+      #    :open -  The bar opening price.
+      #    :high -  The high price during the time covered by the bar.
+      #    :low -   The low price during the time covered by the bar.
+      #    :close - The bar closing price.
+      #    :volume - The volume during the time covered by the bar.
+      #    :trades - When TRADES historical data is returned, represents number of trades
+      #             that occurred during the time period the bar covers
+      #    :wap - The weighted average price during the time covered by the bar.
+      #    :has_gaps - Whether or not there are gaps in the data.
+
+      HistoricalData = def_message [17, 3],
+                                   [:request_id, :int],
+                                   [:start_date, :string],
+                                   [:end_date, :string],
+                                   [:count, :int]
+      class HistoricalData
+        attr_accessor :results
+
+        def load
+          super
+
+          @results = Array.new(@data[:count]) do |_|
+            IB::Bar.new :time => socket.read_string,
+                        :open => socket.read_decimal,
+                        :high => socket.read_decimal,
+                        :low => socket.read_decimal,
+                        :close => socket.read_decimal,
+                        :volume => socket.read_int,
+                        :wap => socket.read_decimal,
+                        :has_gaps => socket.read_string,
+                        :trades => socket.read_int
+          end
+        end
+
+        def to_human
+          "<HistoricalData: #{request_id}, #{count} items, #{start_date} to #{end_date}>"
+        end
+      end # HistoricalData
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib-ruby/messages/incoming/market_depths.rb

@@ -0,0 +1,44 @@
+module IB
+  module Messages
+    module Incoming
+
+      MarketDepth =
+          def_message 12, [:request_id, :int],
+                      [:position, :int], # The row Id of this market depth entry.
+                      [:operation, :int], # How it should be applied to the market depth:
+                      #   0 = insert this new order into the row identified by :position
+                      #   1 = update the existing order in the row identified by :position
+                      #   2 = delete the existing order at the row identified by :position
+                      [:side, :int], # side of the book: 0 = ask, 1 = bid
+                      [:price, :decimal],
+                      [:size, :int]
+
+      class MarketDepth
+        def side
+          @data[:side] == 0 ? :ask : :bid
+        end
+
+        def operation
+          @data[:operation] == 0 ? :insert : @data[:operation] == 1 ? :update : :delete
+        end
+
+        def to_human
+          "<#{self.message_type}: #{operation} #{side} @ "+
+              "#{position} = #{price} x #{size}>"
+        end
+      end
+
+      MarketDepthL2 =
+          def_message 13, MarketDepth, # Fields descriptions - see above
+                      [:request_id, :int],
+                      [:position, :int],
+                      [:market_maker, :string], # The exchange hosting this order.
+                      [:operation, :int],
+                      [:side, :int],
+                      [:price, :decimal],
+                      [:size, :int]
+
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib-ruby/messages/incoming/open_order.rb

@@ -1,8 +1,8 @@
-# OpenOrder is the longest message with complex processing logics, it is isolated here
 module IB
   module Messages
     module Incoming
 
+      # OpenOrder is the longest message with complex processing logics
       OpenOrder =
           def_message [5, [23, 28]],
                       [:order, :order_id, :int],
@@ -73,13 +73,32 @@ module IB
 
       class OpenOrder
 
+
         # Accessors to make OpenOrder API-compatible with OrderStatus message
+
+        def order
+          @order ||= IB::Order.new @data[:order].merge(:order_state => order_state)
+        end
+
+        def order_state
+          @order_state ||= IB::OrderState.new(
+              @data[:order_state].merge(
+                  :order_id => @data[:order][:order_id],
+                  :perm_id => @data[:order][:perm_id],
+                  :parent_id => @data[:order][:parent_id],
+                  :client_id => @data[:order][:client_id]))
+        end
+
+        def contract
+          @contract ||= IB::Contract.build @data[:contract]
+        end
+
         def order_id
-          order && order.order_id
+          order.order_id
         end
 
         def status
-          order && order.status
+          order.status
         end
 
         def load
@@ -166,20 +185,17 @@ module IB
                    ],
 
                    [:order, :what_if, :boolean],
-                   [:order, :status, :string],
 
+                   [:order_state, :status, :string],
                    # IB uses weird String with Java Double.MAX_VALUE to indicate no value here
-                   [:order, :init_margin, :decimal_max], # :string],
-                   [:order, :maint_margin, :decimal_max], # :string],
-                   [:order, :equity_with_loan, :decimal_max], # :string],
-                   [:order, :commission, :decimal_max], # May be nil!
-                   [:order, :min_commission, :decimal_max], # May be nil!
-                   [:order, :max_commission, :decimal_max], # May be nil!
-                   [:order, :commission_currency, :string],
-                   [:order, :warning_text, :string]
-
-          @order = IB::Order.new @data[:order]
-          @contract = IB::Contract.build @data[:contract]
+                   [:order_state, :init_margin, :decimal_max], # :string],
+                   [:order_state, :maint_margin, :decimal_max], # :string],
+                   [:order_state, :equity_with_loan, :decimal_max], # :string],
+                   [:order_state, :commission, :decimal_max], # May be nil!
+                   [:order_state, :min_commission, :decimal_max], # May be nil!
+                   [:order_state, :max_commission, :decimal_max], # May be nil!
+                   [:order_state, :commission_currency, :string],
+                   [:order_state, :warning_text, :string]
         end
 
         # Check if given value was set by TWS to something vaguely "positive"
@@ -195,7 +211,7 @@ module IB
         end
 
         def to_human
-          "<OpenOrder: #{@contract.to_human} #{@order.to_human}>"
+          "<OpenOrder: #{contract.to_human} #{order.to_human}>"
         end
 
       end # class OpenOrder