ib-ruby 0.7.4 → 0.7.6

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

@@ -0,0 +1,61 @@
+require 'ib-ruby/messages/abstract_message'
+
+module IB
+  module Messages
+    module Outgoing
+
+      # Container for specific message classes, keyed by their message_ids
+      Classes = {}
+
+      class AbstractMessage < IB::Messages::AbstractMessage
+
+        def initialize data={}
+          @data = data
+          @created_at = Time.now
+        end
+
+        # This causes the message to send itself over the server socket in server[:socket].
+        # "server" is the @server instance variable from the IB object.
+        # You can also use this to e.g. get the server version number.
+        #
+        # Subclasses can either override this method for precise control over how
+        # stuff gets sent to the server, or else define a method encode() that returns
+        # an Array of elements that ought to be sent to the server by calling to_s on
+        # each one and postpending a '\0'.
+        #
+        def send_to server
+          self.encode(server).flatten.each do |datum|
+            #p datum
+            server[:socket].write_data datum
+          end
+        end
+
+        # At minimum, Outgoing message contains message_id and version.
+        # Most messages also contain (ticker, request or order) :id.
+        # Then, content of @data Hash is encoded per instructions in data_map.
+        def encode server
+          [self.class.message_id,
+           self.class.version,
+           @data[:id] || @data[:ticker_id] || @data[:request_id]|| @data[:order_id] || [],
+           self.class.data_map.map do |(field, default_method, args)|
+             case
+               when default_method.nil?
+                 @data[field]
+
+               when default_method.is_a?(Symbol) # method name with args
+                 @data[field].send default_method, *args
+
+               when default_method.respond_to?(:call) # callable with args
+                 default_method.call @data[field], *args
+
+               else # default
+                 @data[field].nil? ? default_method : @data[field] # may be false still
+             end
+           end
+          ].flatten
+        end
+
+      end # AbstractMessage
+    end # module Outgoing
+  end # module Messages
+end # module IB

data/lib/ib-ruby/messages/outgoing/bar_requests.rb

@@ -0,0 +1,149 @@
+module IB
+  module Messages
+    module Outgoing
+
+      # Messages that request bar data have special processing of @data
+
+      class BarRequestMessage < AbstractMessage
+        # Preprocessor for some data fields
+        def parse data
+          type = data[:data_type] || data[:what_to_show]
+          data_type = DATA_TYPES.invert[type] || type
+          unless  DATA_TYPES.keys.include?(data_type)
+            error ":data_type must be one of #{DATA_TYPES.inspect}", :args
+          end
+
+          size = data[:bar_size] || data[:size]
+          bar_size = BAR_SIZES.invert[size] || size
+          unless  BAR_SIZES.keys.include?(bar_size)
+            error ":bar_size must be one of #{BAR_SIZES.inspect}", :args
+          end
+
+          contract = data[:contract].is_a?(IB::Contract) ?
+              data[:contract] : IB::Contract.from_ib_ruby(data[:contract])
+
+          [data_type, bar_size, contract]
+        end
+      end
+
+      #  data = { :id => ticker_id (int),
+      #           :contract => Contract ,
+      #           :bar_size => int/Symbol? Currently only 5 second bars are supported,
+      #                        if any other value is used, an exception will be thrown.,
+      #           :data_type => Symbol: Determines the nature of data being extracted.
+      #                       :trades, :midpoint, :bid, :ask, :bid_ask,
+      #                       :historical_volatility, :option_implied_volatility,
+      #                       :option_volume, :option_open_interest
+      #                       - converts to "TRADES," "MIDPOINT," "BID," etc...
+      #          :use_rth => int: 0 - all data available during the time span requested
+      #                     is returned, even data bars covering time intervals where the
+      #                     market in question was illiquid. 1 - only data within the
+      #                     "Regular Trading Hours" of the product in question is returned,
+      #                     even if the time span requested falls partially or completely
+      #                     outside of them.
+      RequestRealTimeBars = def_message 50, BarRequestMessage
+
+      class RequestRealTimeBars
+        def encode server
+          data_type, bar_size, contract = parse @data
+
+          [super,
+           contract.serialize_long,
+           bar_size,
+           data_type.to_s.upcase,
+           @data[:use_rth]].flatten
+        end
+      end # RequestRealTimeBars
+
+      # data = { :id => int: Ticker id, needs to be different than the reqMktData ticker
+      #                 id. If you use the same ticker ID you used for the symbol when
+      #                 you did ReqMktData, nothing comes back for the historical data call
+      #          :contract => Contract: requested ticker description
+      #          :end_date_time => String: "yyyymmdd HH:mm:ss", with optional time zone
+      #                            allowed after a space: "20050701 18:26:44 GMT"
+      #          :duration => String, time span the request will cover, and is specified
+      #                  using the format: <integer> <unit>, eg: '1 D', valid units are:
+      #                        '1 S' (seconds, default if no unit is specified)
+      #                        '1 D' (days)
+      #                        '1 W' (weeks)
+      #                        '1 M' (months)
+      #                        '1 Y' (years, currently limited to one)
+      #          :bar_size => String: Specifies the size of the bars that will be returned
+      #                       (within IB/TWS limits). Valid values include:
+      #                             '1 sec'
+      #                             '5 secs'
+      #                             '15 secs'
+      #                             '30 secs'
+      #                             '1 min'
+      #                             '2 mins'
+      #                             '3 mins'
+      #                             '5 mins'
+      #                             '15 mins'
+      #                             '30 min'
+      #                             '1 hour'
+      #                             '1 day'
+      #          :what_to_show => Symbol: Determines the nature of data being extracted.
+      #                           Valid values:
+      #                             :trades, :midpoint, :bid, :ask, :bid_ask,
+      #                             :historical_volatility, :option_implied_volatility,
+      #                             :option_volume, :option_open_interest
+      #                              - converts to "TRADES," "MIDPOINT," "BID," etc...
+      #          :use_rth => int: 0 - all data available during the time span requested
+      #                     is returned, even data bars covering time intervals where the
+      #                     market in question was illiquid. 1 - only data within the
+      #                     "Regular Trading Hours" of the product in question is returned,
+      #                     even if the time span requested falls partially or completely
+      #                     outside of them.
+      #          :format_date => int: 1 - text format, like "20050307 11:32:16".
+      #                               2 - offset in seconds from the beginning of 1970,
+      #                                   which is the same format as the UNIX epoch time.
+      #         }
+      #
+      # Note that as of 4/07 there is no historical data available for forex spot.
+      #
+      # data[:contract] may either be a Contract object or a String. A String should be
+      # in serialize_ib_ruby format; that is, it should be a colon-delimited string in
+      # the format (e.g. for Globex British pound futures contract expiring in Sep-2008):
+      #
+      #    symbol:security_type:expiry:strike:right:multiplier:exchange:primary_exchange:currency:local_symbol
+      #    GBP:FUT:200809:::62500:GLOBEX::USD:
+      #
+      # Fields not needed for a particular security should be left blank (e.g. strike
+      # and right are only relevant for options.)
+      #
+      # A Contract object will be automatically serialized into the required format.
+      #
+      # See also http://chuckcaplan.com/twsapi/index.php/void%20reqIntradayData%28%29
+      # for general information about how TWS handles historic data requests, whence
+      # the following has been adapted:
+      #
+      # The server providing historical prices appears to not always be
+      # available outside of market hours. If you call it outside of its
+      # supported time period, or if there is otherwise a problem with
+      # it, you will receive error #162 "Historical Market Data Service
+      # query failed.:HMDS query returned no data."
+      #
+      # For backfill on futures data, you may need to leave the Primary
+      # Exchange field of the Contract structure blank; see
+      # http://www.interactivebrokers.com/discus/messages/2/28477.html?1114646754
+      RequestHistoricalData = def_message [20, 4], BarRequestMessage
+
+      class RequestHistoricalData
+        def encode server
+          data_type, bar_size, contract = parse @data
+
+          [super,
+           contract.serialize_long(:include_expired),
+           @data[:end_date_time],
+           bar_size,
+           @data[:duration],
+           @data[:use_rth],
+           data_type.to_s.upcase,
+           @data[:format_date],
+           contract.serialize_legs].flatten
+        end
+      end # RequestHistoricalData
+
+    end # module Outgoing
+  end # module Messages
+end # module IB

data/lib/ib-ruby/messages/outgoing/place_order.rb

@@ -0,0 +1,24 @@
+module IB
+  module Messages
+    module Outgoing
+
+      # Data format is { :id => int: order_id,
+      #                  :contract => Contract,
+      #                  :order => Order }
+      PlaceOrder = def_message [3, 31] # v.38 is NOT properly supported by API yet
+
+      class PlaceOrder
+
+        def encode server
+          # Old server version supports no enhancements
+          @version = 31 if server[:server_version] <= 60
+
+          [super,
+           @data[:order].serialize_with(server, @data[:contract])].flatten
+        end
+      end # PlaceOrder
+
+
+    end # module Outgoing
+  end # module Messages
+end # module IB

data/lib/ib-ruby/models.rb

@@ -1,9 +1,13 @@
 module IB
   module Models
+
+    require 'ib-ruby/models/model_properties'
+    require 'ib-ruby/models/model'
     require 'ib-ruby/models/contracts'
     # Flatten namespace (IB::Models::Option instead of IB::Models::Contracts::Option)
     include Contracts
 
+    require 'ib-ruby/models/order_state'
     require 'ib-ruby/models/order'
     require 'ib-ruby/models/combo_leg'
     require 'ib-ruby/models/execution'

data/lib/ib-ruby/models/bar.rb

@@ -1,26 +1,43 @@
-require 'ib-ruby/models/model'
-
 module IB
   module Models
-    # This is a single data point delivered by HistoricData messages.
+    # This is a single data point delivered by HistoricData or RealTimeBar messages.
     # Instantiate with a Hash of attributes, to be auto-set via initialize in Model.
-    class Bar < Model
-      prop :time, # The date-time stamp of the start of the bar. The format is
-           #        determined by the reqHistoricalData() formatDate parameter.
-           :open, #   The bar opening price.
+    class Bar < Model.for(:bar)
+      include ModelProperties
+
+      prop :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 bar opening price.
+           :volume, # Volume
            :wap, #    Weighted average price during the time covered by the bar.
-           :has_gaps, # Whether or not there are gaps in the data.
-           :trades # int: When TRADES data history is returned, represents number
-                   # of trades that occurred during the time period the bar covers
+           :trades, # int: When TRADES data history is returned, represents number
+           #           of trades that occurred during the time period the bar covers
+           :time, # TODO: convert into Time object?
+           #        The date-time stamp of the start of the bar. The format is
+           #        determined by the reqHistoricalData() formatDate parameter.
+           :has_gaps => :bool # Whether or not there are gaps in the data.
 
-      def to_s
-        "<Bar #{time}: wap: #{wap}, OHLC: #{open}, #{high}, #{low}, #{close}, " +
-            (trades ? "trades: #{trades}," : "") + " vol: #{volume}, gaps? #{has_gaps}>"
+      validates_numericality_of :open, :high, :low, :close, :volume
+
+      # Order comparison
+      def == other
+        time == other.time &&
+            open == other.open &&
+            high == other.high &&
+            low == other.low &&
+            close == other.close &&
+            wap == other.wap &&
+            trades == other.trades &&
+            volume == other.volume
+      end
+
+      def to_human
+        "<Bar: #{time} wap #{wap} OHLC #{open} #{high} #{low} #{close} " +
+            (trades ? "trades #{trades}" : "") + " vol #{volume} gaps #{has_gaps}>"
       end
+
+      alias to_s to_human
     end # class Bar
   end # module Models
 end # module IB

data/lib/ib-ruby/models/combo_leg.rb

@@ -4,53 +4,57 @@ module IB
     # ComboLeg objects represent individual securities in a "BAG" contract - which
     # is not really a contract, but a combination (combo) of securities. AKA basket
     # or bag of securities.
-    class ComboLeg < Model
+    class ComboLeg < Model.for(:combo_leg)
+      include ModelProperties
+
       # General Notes:
       # 1. The exchange for the leg definition must match that of the combination order.
       # The exception is for a STK leg definition, which must specify the SMART exchange.
 
-      # // open/close leg value is same as combo
-      # Specifies whether the order is an open or close order. Valid values are:
-      SAME = 0 #  Same as the parent security. The only option for retail customers.
-      OPEN = 1 #  Open. This value is only valid for institutional customers.
-      CLOSE = 2 # Close. This value is only valid for institutional customers.
-      UNKNOWN = 3
-
       prop :con_id, # int: The unique contract identifier specifying the security.
            :ratio, # int: Select the relative number of contracts for the leg you
            #              are constructing. To help determine the ratio for a
            #              specific combination order, refer to the Interactive
            #              Analytics section of the User's Guide.
 
-           :action, # String: BUY/SELL/SSHORT/SSHORTX The side (buy or sell) for the leg.
            :exchange, # String: exchange to which the complete combo order will be routed.
-           :open_close, # int: Specifies whether the order is an open or close order.
-           #              Valid values: ComboLeg::SAME/OPEN/CLOSE/UNKNOWN
-
            # For institutional customers only! For stock legs when doing short sale
-           :short_sale_slot, # int: 0 - retail, 1 = clearing broker, 2 = third party
+           :short_sale_slot, # int: 0 - retail(default), 1 = clearing broker, 2 = third party
            :designated_location, # String: Only for shortSaleSlot == 2.
            #                    Otherwise leave blank or orders will be rejected.
-           :exempt_code # int: ?
+           :exempt_code, # int: ?
+           [:side, :action] => PROPS[:side], # String: Action/side: BUY/SELL/SSHORT/SSHORTX
+           :open_close => PROPS[:open_close]
+      # int: Whether the order is an open or close order. Values:
+      # SAME = 0 Same as the parent security. The only option for retail customers.
+      # OPEN = 1 Open. This value is only valid for institutional customers.
+      # CLOSE = 2 Close. This value is only valid for institutional customers.
+      # UNKNOWN = 3
+
+      # Extra validations
+      validates_numericality_of :ratio, :con_id
+      validates_format_of :designated_location, :with => /^$/,
+                          :message => "should be blank or orders will be rejected"
 
       DEFAULT_PROPS = {:con_id => 0,
-                       :open_close => SAME,
-                       :short_sale_slot => 0,
+                       :open_close => :same, # The only option for retail customers.
+                       :short_sale_slot => :default,
                        :designated_location => '',
+                       :exchange => 'SMART', # Unless SMART, Order modification fails
                        :exempt_code => -1, }
 
       #  Leg's weight is a combination of action and ratio
       def weight
-        action == 'BUY' ? ratio : -ratio
+        side == :buy ? ratio : -ratio
       end
 
       def weight= value
         value = value.to_i
         if value > 0
-          self.action = 'BUY'
+          self.side = :buy
           self.ratio = value
         else
-          self.action = 'SELL'
+          self.side = :sell
           self.ratio = -value
         end
       end
@@ -59,13 +63,34 @@ module IB
       def serialize *fields
         [con_id,
          ratio,
-         action,
+         side.to_sup,
          exchange,
-         (fields.include?(:extended) ? [open_close, short_sale_slot,
-                                        designated_location, exempt_code] : [])
+         (fields.include?(:extended) ?
+             [self[:open_close],
+              self[:short_sale_slot],
+              designated_location,
+              exempt_code] :
+             [])
         ].flatten
       end
-    end # ComboLeg
 
+      def to_human
+        "<ComboLeg: #{side} #{ratio} con_id #{con_id} at #{exchange}>"
+      end
+
+      # Order comparison
+      def == other
+        other && other.is_a?(ComboLeg) &&
+            con_id == other.con_id &&
+            ratio == other.ratio &&
+            open_close == other.open_close &&
+            short_sale_slot == other.short_sale_slot&&
+            exempt_code == other.exempt_code &&
+            side == other.side &&
+            exchange == other.exchange &&
+            designated_location == other.designated_location
+      end
+
+    end # ComboLeg
   end # module Models
 end # module IB

data/lib/ib-ruby/models/contracts.rb

@@ -15,8 +15,8 @@ module IB
     module Contracts
       # Specialized Contract subclasses representing different security types
       TYPES = Hash.new(Contract)
-      TYPES[IB::SECURITY_TYPES[:bag]] = Bag
-      TYPES[IB::SECURITY_TYPES[:option]] = Option
+      TYPES[:bag] = Bag
+      TYPES[:option] = Option
 
       # Returns concrete subclass for this sec_type, or default Contract
       def [] sec_type

data/lib/ib-ruby/models/contracts/bag.rb

@@ -11,11 +11,20 @@ module IB
         # General Notes:
         # 1. :exchange for the leg definition must match that of the combination order.
         # The exception is for a STK legs, which must specify the SMART exchange.
-        # 2. :symbol => "USD" For combo Contract, this is an arbitrary value (like �USD�)
+        # 2. :symbol => "USD" For combo Contract, this is an arbitrary value (like "USD")
+
+        validates_format_of :sec_type, :with => /^bag$/, :message => "should be a bag"
+        validates_format_of :right, :with => /^none$/, :message => "should be none"
+        validates_format_of :expiry, :with => /^$/, :message => "should be blank"
+        validate :legs_cannot_be_empty
+
+        def legs_cannot_be_empty
+          errors.add(:legs, "legs cannot be empty") if legs.empty?
+        end
 
         def initialize opts = {}
           @legs = Array.new
-          self[:sec_type] = IB::SECURITY_TYPES[:bag]
+          self.sec_type = :bag
           super opts
         end
 
@@ -36,11 +45,6 @@ module IB
           self[:legs_description] || legs.map { |leg| "#{leg.con_id}|#{leg.weight}" }.join(',')
         end
 
-        def serialize_legs *fields
-          return [0] if legs.empty?
-          [legs.size, legs.map { |leg| leg.serialize *fields }]
-        end
-
         # Check if two Contracts have same legs (maybe in different order)
         def same_legs? other
           legs == other.legs ||