ib-ruby 0.7.4 → 0.7.6

data/lib/ib-ruby/constants.rb

@@ -5,41 +5,32 @@ module IB
 
   # Enumeration of bar size types for convenience.
   # Bar sizes less than 30 seconds do not work for some securities.
-  BAR_SIZES = {:sec1 => '1 sec',
-               :sec5 => '5 secs',
-               :sec15 => '15 secs',
-               :sec30 => '30 secs',
-               :min1 => '1 min',
-               :min2 => '2 mins',
-               :min3 => '3 mins',
-               :min5 => '5 mins',
-               :min15 => '15 mins',
-               :min30 => '30 mins',
-               :hour1 => '1 hour',
-               :day1 => '1 day'}
+  BAR_SIZES = {'1 sec' => :sec1,
+               '5 secs' => :sec5,
+               '15 secs' =>:sec15,
+               '30 secs' =>:sec30,
+               '1 min' => :min1,
+               '2 mins' => :min2,
+               '3 mins' => :min3,
+               '5 mins' => :min5,
+               '15 mins' =>:min15,
+               '30 mins' =>:min30,
+               '1 hour' =>:hour1,
+               '1 day' => :day1
+  }.freeze
 
   # Enumeration of data types.
   # Determines the nature of data being extracted. Valid values:
-  DATA_TYPES = {:trades => 'TRADES',
-                :midpoint => 'MIDPOINT',
-                :bid => 'BID',
-                :ask => 'ASK',
-                :bid_ask => 'BID_ASK',
-                :historical_volatility => 'HISTORICAL_VOLATILITY',
-                :option_implied_volatility => 'OPTION_IMPLIED_VOLATILITY',
-                :option_volume => 'OPTION_VOLUME',
-                :option_open_interest => 'OPTION_OPEN_INTEREST',
-  }
-
-  # Valid security types (sec_type attribute of IB::Contract)
-  SECURITY_TYPES = {:stock => "STK",
-                    :option => "OPT",
-                    :future => "FUT",
-                    :index => "IND",
-                    :futures_option => "FOP",
-                    :forex => "CASH",
-                    :bond => "BOND",
-                    :bag => "BAG"}
+  DATA_TYPES = {'TRADES' => :trades,
+                'MIDPOINT' => :midpoint,
+                'BID' => :bid,
+                'ASK' => :ask,
+                'BID_ASK' => :bid_ask,
+                'HISTORICAL_VOLATILITY' => :historical_volatility,
+                'OPTION_IMPLIED_VOLATILITY' => :option_implied_volatility,
+                'OPTION_VOLUME' => :option_volume,
+                'OPTION_OPEN_INTEREST' => :option_open_interest
+  }.freeze
 
   ### These values are typically received from TWS in incoming messages
 
@@ -117,9 +108,17 @@ module IB
   }
 
   # Financial Advisor types (FaMsgTypeName)
-  FA_TYPES = {1 => 'GROUPS',
-              2 => 'PROFILES',
-              3 =>'ALIASES'}
+  FA_TYPES = {
+      1 => :groups,
+      2 => :profiles,
+      3 => :aliases}.freeze
+
+  # Received in new MarketDataType (58 incoming) message
+  MARKET_DATA_TYPES = {
+      0 => :unknown,
+      1 => :real_time,
+      2 => :frozen,
+  }
 
   # Market depth messages contain these "operation" codes to tell you what to do with the data.
   # See also http://www.interactivebrokers.com/php/apiUsersGuide/apiguide/java/updatemktdepth.htm
@@ -127,10 +126,206 @@ module IB
       0 => :insert, # New order, insert into the row identified by :position
       1 => :update, # Update the existing order at the row identified by :position
       2 => :delete # Delete the existing order at the row identified by :position
-  }
+  }.freeze
 
   MARKET_DEPTH_SIDES = {
       0 => :ask,
       1 => :bid
-  }
+  }.freeze
+
+  ORDER_TYPES =
+      {'LMT' => :limit, #                  Limit Order
+       'LIT' => :limit_if_touched, #       Limit if Touched
+       'LOC' => :limit_on_close, #         Limit-on-Close      LMTCLS ?
+       'LOO' => :limit_on_open, #          Limit-on-Open
+       'MKT' => :market, #                 Market
+       'MIT' => :market_if_touched, #      Market-if-Touched
+       'MOC' => :market_on_close, #        Market-on-Close     MKTCLSL ?
+       'MOO' => :market_on_open, #         Market-on-Open
+       'MTL' => :market_to_limit, #        Market-to-Limit
+       'MKTPRT' => :market_protected, #   Market with Protection
+       'QUOTE' => :request_for_quote, #    Request for Quote
+       'STP' => :stop, #                   Stop
+       'STPLMT' => :stop_limit, #         Stop Limit
+       'TRAIL' => :trailing_stop, #        Trailing Stop
+       'TRAIL LIMIT' => :trailing_limit, # Trailing Stop Limit
+       'TRAIL LIT' => :trailing_limit_if_touched, #  Trailing Limit if Touched
+       'TRAIL MIT' => :trailing_market_if_touched, # Trailing Market If Touched
+       'PEG MKT' => :pegged_to_market, #   Pegged-to-Market
+       'REL' => :relative, #               Relative
+       'BOX TOP' => :box_top, #            Box Top
+       'PEG MID' => :pegged_to_midpoint, # Pegged-to-Midpoint
+       'VWAP' => :vwap, #                  VWAP-Guaranteed
+       'OCA' => :one_cancels_all, #        One-Cancels-All
+       'VOL' => :volatility, #             Volatility
+       'SCALE' => :scale, #                Scale
+       'NONE' => :no_order # Used to indicate no hedge in :delta_neutral_order_type
+      }.freeze
+
+  # Valid security types (sec_type attribute of IB::Contract)
+  SECURITY_TYPES =
+      {'STK' => :stock,
+       'OPT' => :option,
+       'FUT' => :future,
+       'IND' => :index,
+       'FOP' => :futures_option,
+       'CASH' => :forex,
+       'BOND' => :bond,
+       'BAG' => :bag}.freeze
+
+  # Obtain symbolic value from given property code:
+  # VALUES[:side]['B'] -> :buy
+  VALUES = {
+      :sec_type => SECURITY_TYPES,
+      :order_type => ORDER_TYPES,
+      :delta_neutral_order_type => ORDER_TYPES,
+
+      :origin => {0 => :customer, 1 => :firm},
+      :volatility_type => {1 => :daily, 2 => :annual},
+      :reference_price_type => {1 => :average, 2 => :bid_or_ask},
+
+      # This property encodes differently for ComboLeg and Order objects,
+      # we use ComboLeg codes and transcode for Order codes as needed
+      :open_close =>
+          {0 => :same, # Default for Legs, same as the parent (combo) security.
+           1 => :open, #  Open. For Legs, this value is only used by institutions.
+           2 => :close, # Close. For Legs, this value is only used by institutions.
+           3 => :unknown}, # WTF
+
+      :right =>
+          {'' => :none, # Not an option
+           'P' => :put,
+           'C' => :call},
+
+      :side => # AKA action
+          {'B' => :buy, # or BOT
+           'S' => :sell, # or SLD
+           'T' => :short, # short
+           'X' => :short_exempt # Short Sale Exempt action. This allows some orders
+           # to be exempt from the SEC recent changes to Regulation SHO, which
+           # eliminated the old uptick rule and replaced it with a new "circuit breaker"
+           # rule, and allows some orders to be exempt from the new rule.
+          },
+
+      :short_sale_slot =>
+          {0 => :default, #      The only valid option for retail customers
+           1 => :broker, #       Shares are at your clearing broker, institutions
+           2 => :third_party}, # Shares will be delivered from elsewhere, institutions
+
+      :oca_type =>
+          {0 => :none, # Not a member of OCA group
+           1 => :cancel_with_block, # Cancel all remaining orders with block
+           2 => :reduce_with_block, # Remaining orders are reduced in size with block
+           3 => :reduce_no_block}, # Remaining orders are reduced in size with no block
+
+      :auction_strategy =>
+          {0 => :none, # Not a BOX order
+           1 => :match,
+           2 => :improvement,
+           3 => :transparent},
+
+      :trigger_method =>
+          {0 => :default, # "double bid/ask" used for OTC/US options, "last" otherswise.
+           1 => :double_bid_ask, # stops are triggered by 2 consecutive bid or ask prices.
+           2 => :last, # stops are triggered based on the last price.
+           3 => :double_last,
+           4 => :bid_ask, # bid >= trigger price for buy orders, ask <= trigger for sell orders
+           7 => :last_or_bid_ask, # bid OR last price >= trigger price for buy orders
+           8 => :mid_point}, # midpoint >= trigger price for buy orders and the
+      #      spread between the bid and ask must be less than 0.1% of the midpoint
+
+      :hedge_type =>
+          {'D' => :delta, # parent order is an option and the child order is a stock
+           'B' => :beta, # offset market risk by entering into a position with
+           #               another contract based on the system or user-defined beta
+           'F' => :forex, # offset risk with currency different from your base currency
+           'P' => :pair}, # trade a mis-valued pair of contracts and provide the
+      #                     ratio between the parent and hedging child order
+
+      :clearing_intent =>
+          {'' => :none,
+           'IB' => :ib,
+           'AWAY' => :away,
+           'PTA' => :post_trade_allocation},
+
+      :delta_neutral_clearing_intent =>
+          {'' => :none,
+           'IB' => :ib,
+           'AWAY' => :away,
+           'PTA' => :post_trade_allocation},
+
+      :tif =>
+          {'DAY' => :day,
+           'GAT' => :good_after_time,
+           'GTD' => :good_till_date,
+           'GTC' => :good_till_cancelled,
+           'IOC' => :immediate_or_cancel},
+
+      :rule_80a =>
+          {'I' => :individual,
+           'A' => :agency,
+           'W' => :agent_other_member,
+           'J' => :individual_ptia,
+           'U' => :agency_ptia,
+           'M' => :agent_other_member_ptia,
+           'K' => :individual_pt,
+           'Y' => :agency_pt,
+           'N' => :agent_other_member_pt},
+
+      :opt? => # TODO: unknown Order property, like OPT_BROKER_DEALER... in Order.java
+          {'?' => :unknown,
+           'b' => :broker_dealer,
+           'c' => :customer,
+           'f' => :firm,
+           'm' => :isemm,
+           'n' => :farmm,
+           'y' => :specialist},
+
+  }.freeze
+
+  # Obtain property code from given symbolic value:
+  # CODES[:side][:buy] -> 'B'
+  CODES = Hash[VALUES.map { |property, hash| [property, hash.invert] }]
+
+  # Most common property processors
+  PROPS = {:side =>
+               {:set => proc { |val| # BUY(BOT)/SELL(SLD)/SSHORT/SSHORTX
+                 self[:side] = case val.to_s.upcase
+                                 when /SHORT.*X|^X$/
+                                   'X'
+                                 when /SHORT|^T$/
+                                   'T'
+                                 when /^B/
+                                   'B'
+                                 when /^S/
+                                   'S'
+                               end },
+                :validate =>
+                    {:format =>
+                         {:with => /^buy$|^sell$|^short$|^short_exempt$/,
+                          :message => "should be buy/sell/short"}
+                    }
+               },
+
+           :open_close =>
+               {:set => proc { |val|
+                 self[:open_close] = case val.to_s.upcase[0..0]
+                                       when 'S', '0' # SAME
+                                         0
+                                       when 'O', '1' # OPEN
+                                         1
+                                       when 'C', '2' # CLOSE
+                                         2
+                                       when 'U', '3' # Unknown
+                                         3
+                                     end
+               },
+                :validate =>
+                    {:format =>
+                         {:with => /^same$|^open$|^close$|^unknown$/,
+                          :message => "should be same/open/close/unknown"}
+                    },
+               }
+  }.freeze
+
 end # module IB

data/lib/ib-ruby/db.rb

@@ -0,0 +1,25 @@
+# By requiring this file, we make all IB:Models database-backed ActiveRecord subclasses
+
+require 'active_record'
+
+module IB
+  module DB
+
+    def self.logger= logger
+      ActiveRecord::Base.logger = logger
+    end
+
+    # Establish DB connection and do other plumbing here
+    def self.connect config
+      #log.warn "Starting Database connection"
+      ActiveRecord::Base.establish_connection(config)
+      #ActiveRecord.colorize_logging = false
+
+      # Get rid of nasty conversion issues
+      ActiveRecord::Base.default_timezone = :utc
+      Time.zone = 'UTC'
+    end
+
+     # Load ActiveRecord::Schema ? where from ?
+  end # module DB
+end

data/lib/ib-ruby/extensions.rb

@@ -1,11 +1,61 @@
-# Add method to_ib to render datetime in IB format (zero padded "yyyymmdd HH:mm:ss")
 class Time
+  # Render datetime in IB format (zero padded "yyyymmdd HH:mm:ss")
   def to_ib
     "#{year}#{sprintf("%02d", month)}#{sprintf("%02d", day)} " +
         "#{sprintf("%02d", hour)}:#{sprintf("%02d", min)}:#{sprintf("%02d", sec)}"
   end
 end # Time
 
+class Numeric
+  # Conversion 0/1 into true/false
+  def to_bool
+    self == 0 ? false : true
+  end
+end
+
+class TrueClass
+  def to_bool
+    self
+  end
+end
+
+class FalseClass
+  def to_bool
+    self
+  end
+end
+
+class String
+  def to_bool
+    case self.chomp.upcase
+      when 'TRUE', 'T'
+        true
+      when 'FALSE', 'F', ''
+        false
+      else
+        error "Unable to convert #{self} to bool"
+    end
+  end
+end
+
+class NilClass
+  def to_bool
+    false
+  end
+end
+
+class Symbol
+  def to_f
+    0
+  end
+end
+
+class Object
+  def to_sup
+    self.to_s.upcase
+  end
+end
+
 ### Patching Object#error in ib-ruby/errors
 #  def error message, type=:standard
 

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

@@ -1,11 +1,3 @@
-# EClientSocket.java uses sendMax() rather than send() for a number of these.
-# It sends an EOL rather than a number if the value == Integer.MAX_VALUE (or Double.MAX_VALUE).
-# These fields are initialized to this MAX_VALUE.
-# This has been implemented with nils in Ruby to represent the case where an EOL should be sent.
-
-# TODO: Don't instantiate messages, use their classes as just namespace for .encode/decode
-# TODO: realize Message#fire method that raises EWrapper events
-
 module IB
   module Messages
 

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

@@ -1,4 +1,4 @@
-require 'ib-ruby/messages/abstract_message'
+require 'ib-ruby/messages/incoming/abstract_message'
 
 # EClientSocket.java uses sendMax() rather than send() for a number of these.
 # It sends an EOL rather than a number if the value == Integer.MAX_VALUE (or Double.MAX_VALUE).
@@ -15,144 +15,7 @@ module IB
     module Incoming
       extend Messages # def_message macros
 
-      # 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
-
-      ### Actual message classes (short definitions):
-
-      # :status - String: Displays the order status. Possible values include:
-      # � PendingSubmit - indicates that you have transmitted the order, but
-      #   have not yet received confirmation that it has been accepted by the
-      #   order destination. NOTE: This order status is NOT sent back by TWS
-      #   and should be explicitly set by YOU when an order is submitted.
-      # � PendingCancel - indicates that you have sent a request to cancel
-      #   the order but have not yet received cancel confirmation from the
-      #   order destination. At this point, your order cancel is not confirmed.
-      #   You may still receive an execution while your cancellation request
-      #   is pending. NOTE: This order status is not sent back by TWS and
-      #   should be explicitly set by YOU when an order is canceled.
-      # � PreSubmitted - indicates that a simulated order type has been
-      #   accepted by the IB system and that this order has yet to be elected.
-      #   The order is held in the IB system until the election criteria are
-      #   met. At that time the order is transmitted to the order destination
-      #   as specified.
-      # � Submitted - indicates that your order has been accepted at the order
-      #   destination and is working.
-      # � Cancelled - indicates that the balance of your order has been
-      #   confirmed canceled by the IB system. This could occur unexpectedly
-      #   when IB or the destination has rejected your order.
-      # � Filled - indicates that the order has been completely filled.
-      # � Inactive - indicates that the order has been accepted by the system
-      #   (simulated orders) or an exchange (native orders) but that currently
-      #   the order is inactive due to system, exchange or other issues.
-      # :why_held - This field is used to identify an order held when TWS is trying to
-      #      locate shares for a short sell. The value used to indicate this is 'locate'.
-      OrderStatus = def_message [3, 6], [:order_id, :int],
-                                [:status, :string],
-                                [:filled, :int],
-                                [:remaining, :int],
-                                [:average_fill_price, :decimal],
-                                [:perm_id, :int],
-                                [:parent_id, :int],
-                                [:last_fill_price, :decimal],
-                                [:client_id, :int],
-                                [:why_held, :string] do
-        "<OrderStatus: #{status} filled: #{filled}/#{remaining + filled}" +
-            " @ last/avg: #{last_fill_price}/#{average_fill_price}" +
-            (parent_id > 0 ? " parent_id: #{parent_id}" : "") +
-            (why_held != "" ? " why_held: #{why_held}" : "") +
-            " id/perm: #{order_id}/#{perm_id}>"
-      end
+      ### Define short message classes in-line:
 
       AccountValue = def_message([6, 2], [:key, :string],
                                  [:value, :string],
@@ -184,9 +47,7 @@ module IB
       ReceiveFA =
           def_message 16, [:type, :int], # type of Financial Advisor configuration data
                       #                    being received from TWS. Valid values include:
-                      #                      1 = GROUPS
-                      #                      2 = PROFILE
-                      #                      3 = ACCOUNT ALIASES
+                      #                    1 = GROUPS, 2 = PROFILE, 3 = ACCOUNT ALIASES
                       [:xml, :string] # XML string with requested FA configuration information.
 
       # Receives an XML document that describes the valid parameters that a scanner
@@ -198,7 +59,7 @@ module IB
 
       # Receive Reuters global fundamental market data. There must be a subscription to
       # Reuters Fundamental set up in Account Management before you can receive this data.
-      FundamentalData = def_message 50, [:request_id, :int], [:data, :string]
+      FundamentalData = def_message 51, [:request_id, :int], [:data, :string]
 
       ContractDataEnd = def_message 52, [:request_id, :int]
 
@@ -218,361 +79,25 @@ module IB
                       [:yield, :decimal],
                       [:yield_redemption_date, :int]
 
-      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]
-
-      # 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
-
-      PortfolioValue = def_message [7, 7],
-                                   [:contract, :con_id, :int],
-                                   [:contract, :symbol, :string],
-                                   [:contract, :sec_type, :string],
-                                   [:contract, :expiry, :string],
-                                   [:contract, :strike, :decimal],
-                                   [:contract, :right, :string],
-                                   [:contract, :multiplier, :string],
-                                   [:contract, :primary_exchange, :string],
-                                   [:contract, :currency, :string],
-                                   [:contract, :local_symbol, :string],
-                                   [:position, :int],
-                                   [:market_price, :decimal],
-                                   [:market_value, :decimal],
-                                   [:average_cost, :decimal],
-                                   [:unrealized_pnl, :decimal_max], # May be nil!
-                                   [:realized_pnl, :decimal_max], #   May be nil!
-                                   [:account_name, :string]
-      class PortfolioValue
-
-        def load
-          super
-          @contract = IB::Contract.build @data[:contract]
-        end
-
-        def to_human
-          "<PortfolioValue: #{contract.to_human} (#{position}): Market #{market_price}" +
-              " price #{market_value} value; PnL: #{unrealized_pnl} unrealized," +
-              " #{realized_pnl} realized; account #{account_name}>"
-        end
-      end # PortfolioValue
-
-      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 load
-          super
-          @contract = IB::Contract.build @data[:contract]
-        end
-      end # ContractData
-
-      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 load
-          super
-
-          # As of client v.53, we can receive orderRef in ExecutionData
-          load_map [proc { | | @server[:client_version] >= 53 },
-                    [:execution, :order_ref, :string]
-                   ]
-          @contract = IB::Contract.build @data[:contract]
-          @execution = IB::Execution.new @data[:execution]
-        end
-
-        def to_human
-          "<ExecutionData #{request_id}: #{contract.to_human}, #{execution}>"
-        end
-
-      end # ExecutionData
-
-      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 load
-          super
-          @contract = IB::Contract.build @data[:contract]
-        end
-      end # BondContractData
-
-      # 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 load
-          super
-          @contract = IB::Contract.build @data[:contract].merge(:under_comp => true)
-        end
-      end # DeltaNeutralValidation
-
-      # RealTimeBar contains following @data:
-      #    :request_id - The ID of the *request* to which this is responding
-      #    :time - The date-time stamp of the start of the bar. The format is offset in
-      #            seconds from the beginning of 1970, same format as the UNIX epoch time
-      #    :bar - received RT Bar
-      RealTimeBar = def_message 50,
-                                [:request_id, :int],
-                                [:bar, :time, :int],
-                                [:bar, :open, :decimal],
-                                [:bar, :high, :decimal],
-                                [:bar, :low, :decimal],
-                                [:bar, :close, :decimal],
-                                [:bar, :volume, :int],
-                                [:bar, :wap, :decimal],
-                                [:bar, :trades, :int]
-      class RealTimeBar
-        def load
-          super
-          @bar = IB::Bar.new @data[:bar]
-        end
-
-        def to_human
-          "<RealTimeBar: #{request_id} #{time}, #{bar}>"
-        end
-      end # RealTimeBar
-
-      ### Messages with really complicated message loading logics (cycles, conditions)
-
-      # This method receives the requested market scanner data results.
-      # ScannerData contains following @data:
-      # :request_id - The ID of the request to which this row is responding
-      # :count - Number of data points returned (size of :results).
-      # :results - an Array of Hashes, each hash contains a set of
-      #            data about one scanned Contract:
-      #            :contract - a full description of the contract (details).
-      #            :distance - Varies based on query.
-      #            :benchmark - Varies based on query.
-      #            :projection - Varies based on query.
-      #            :legs - Describes combo legs when scan is returning EFP.
-      ScannerData = def_message [20, 3],
-                                [:request_id, :int], # request id
-                                [:count, :int]
-      class ScannerData
-        attr_accessor :results
-
-        def load
-          super
-
-          @results = Array.new(@data[:count]) do |_|
-            {:rank => socket.read_int,
-             :contract => Contract.build(:con_id => socket.read_int,
-                                         :symbol => socket.read_str,
-                                         :sec_type => socket.read_str,
-                                         :expiry => socket.read_str,
-                                         :strike => socket.read_decimal,
-                                         :right => socket.read_str,
-                                         :exchange => socket.read_str,
-                                         :currency => socket.read_str,
-                                         :local_symbol => socket.read_str,
-                                         :market_name => socket.read_str,
-                                         :trading_class => socket.read_str),
-             :distance => socket.read_str,
-             :benchmark => socket.read_str,
-             :projection => socket.read_str,
-             :legs => socket.read_str,
-            }
-          end
-        end
-      end # ScannerData
-
-      # 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
+      ### Require standalone source files for more complex message classes:
+
+      require 'ib-ruby/messages/incoming/alert'
+      require 'ib-ruby/messages/incoming/contract_data'
+      require 'ib-ruby/messages/incoming/delta_neutral_validation'
+      require 'ib-ruby/messages/incoming/execution_data'
+      require 'ib-ruby/messages/incoming/historical_data'
+      require 'ib-ruby/messages/incoming/market_depths'
+      require 'ib-ruby/messages/incoming/open_order'
+      require 'ib-ruby/messages/incoming/order_status'
+      require 'ib-ruby/messages/incoming/portfolio_value'
+      require 'ib-ruby/messages/incoming/real_time_bar'
+      require 'ib-ruby/messages/incoming/scanner_data'
+      require 'ib-ruby/messages/incoming/ticks'
 
     end # module Incoming
   end # module Messages
 end # module IB
 
-# Require standalone message source files
-require 'ib-ruby/messages/incoming/ticks'
-require 'ib-ruby/messages/incoming/open_order'
 
 __END__
     // incoming msg id's