ib-ruby 0.7.6 → 0.7.8

data/HISTORY

@@ -161,3 +161,11 @@
 == 0.7.6 / 2012-04-18
 
 * Bugfix for FundamentalData
+
+== 0.7.7 / 2012-04-20
+
+* Model validations and DB backend
+
+== 0.7.8 / 2012-04-23
+
+* Models are now fully DB-backed

data/Rakefile

@@ -38,3 +38,11 @@ begin
 rescue LoadError => e
   puts "gem install standalone_migrations to get db:migrate:* tasks! (Error: #{e})"
 end
+
+# rake db:redo DB=test"
+namespace :db do
+  desc "Remake db from scratch: $ rake db:redo DB=test"
+  task :redo => [:drop, :create, :migrate] do
+    puts "Redo Finished!"
+  end
+end

data/VERSION

@@ -1 +1 @@
-0.7.6
+0.7.8

data/bin/fundamental_data

@@ -16,13 +16,8 @@ ib = IB::Connection.new :client_id => 1112 #, :port => 7496 # TWS
 
 ib.subscribe(:Alert) { |msg| puts msg.to_human }
 
-# Fundamental Data will arrive as XML. Need to parse it
-ib.subscribe(:FundamentalData) do |msg|
-  puts 'Got fundamental data.'
-  @xml = XmlSimple.xml_in(msg.data)
-  pp @xml
-  @parsing_finished = true
-end
+# Fundamental Data will arrive as XML, parse it
+ib.subscribe(:FundamentalData) { |msg| @xml = XmlSimple.xml_in(msg.data) }
 
 ibm = IB::Contract.new :symbol => 'IBM',
                        :exchange => 'NYSE',
@@ -38,5 +33,7 @@ ib.send_message :RequestFundamentalData,
                 :contract => ibm,
                 :report_type => 'snapshot'
 
-# Needs some time to receive, parse and print XML. Standard timeout of 1 sec is too low.
-ib.wait_for(40) { @parsing_finished }
+# Needs some time to receive and parse XML. Standard timeout of 1 sec is just too low.
+ib.wait_for(30) { @xml}
+
+pp @xml

data/lib/ib-ruby/connection.rb

@@ -28,7 +28,10 @@ module IB
 
     attr_accessor :server, #   Info about IB server and server connection state
                   :options, #  Connection options
-                  :next_order_id # Next valid order id
+                  :next_local_id # Next valid order id
+
+    alias next_order_id next_local_id
+    alias next_order_id= next_local_id=
 
     def initialize opts = {}
       @options = DEFAULT_OPTIONS.merge(opts)
@@ -39,7 +42,7 @@ module IB
 
       self.default_logger = options[:logger] if options[:logger]
       @connected = false
-      @next_order_id = nil
+      self.next_local_id = nil
       @server = Hash.new
 
       connect if options[:connect]
@@ -53,8 +56,8 @@ module IB
 
       # TWS always sends NextValidId message at connect - save this id
       self.subscribe(:NextValidId) do |msg|
-        @next_order_id = msg.order_id
-        log.info "Got next valid order id: #{next_order_id}."
+        self.next_local_id = msg.local_id
+        log.info "Got next valid order id: #{next_local_id}."
       end
 
       server[:socket] = IBSocket.open(options[:host], options[:port])
@@ -181,7 +184,9 @@ module IB
 
     # Check if messages of given type were received at_least n times
     def received? message_type, times=1
-      received[message_type].size >= times
+      @receive_lock.synchronize do
+        received[message_type].size >= times
+      end
     end
 
     # Check if all given conditions are satisfied
@@ -292,26 +297,18 @@ module IB
     # Place Order (convenience wrapper for send_message :PlaceOrder).
     # Assigns client_id and order_id fields to placed order. Returns assigned order_id.
     def place_order order, contract
-      error "Unable to place order, next_order_id not known" unless @next_order_id
-      order.client_id = server[:client_id]
-      order.order_id = @next_order_id
-      @next_order_id += 1
-      modify_order order, contract
+      order.place contract, self
     end
 
     # Modify Order (convenience wrapper for send_message :PlaceOrder). Returns order_id.
     def modify_order order, contract
-      send_message :PlaceOrder,
-                   :order => order,
-                   :contract => contract,
-                   :order_id => order.order_id
-      order.order_id
+      order.modify contract, self
     end
 
-    # Cancel Orders by their ids (convenience wrapper for send_message :CancelOrder).
-    def cancel_order *order_ids
-      order_ids.each do |order_id|
-        send_message :CancelOrder, :order_id => order_id.to_i
+    # Cancel Orders by their local ids (convenience wrapper for send_message :CancelOrder).
+    def cancel_order *local_ids
+      local_ids.each do |local_id|
+        send_message :CancelOrder, :local_id => local_id.to_i
       end
     end
 

data/lib/ib-ruby/constants.rb

@@ -171,6 +171,8 @@ module IB
        'FOP' => :futures_option,
        'CASH' => :forex,
        'BOND' => :bond,
+       'WAR' => :warrant,
+       'FUND' => :fund, # ETF?
        'BAG' => :bag}.freeze
 
   # Obtain symbolic value from given property code:
@@ -285,7 +287,7 @@ module IB
 
   # Obtain property code from given symbolic value:
   # CODES[:side][:buy] -> 'B'
-  CODES = Hash[VALUES.map { |property, hash| [property, hash.invert] }]
+  CODES = Hash[VALUES.map { |property, hash| [property, hash.invert] }].freeze
 
   # Most common property processors
   PROPS = {:side =>

data/lib/ib-ruby/extensions.rb

@@ -48,6 +48,11 @@ class Symbol
   def to_f
     0
   end
+
+  # ActiveModel serialization depends on this method
+  def <=> other
+    to_s <=> other.to_s
+  end
 end
 
 class Object

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

@@ -14,68 +14,69 @@ module IB
                       [:contract, :currency, :string],
                       [:contract, :local_symbol, :string],
 
-                      [:contract, :market_name, :string], # extended
-                      [:contract, :trading_class, :string],
+                      [:contract_detail, :market_name, :string], # extended
+                      [:contract_detail, :trading_class, :string],
                       [:contract, :con_id, :int],
-                      [:contract, :min_tick, :decimal],
+                      [:contract_detail, :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_detail, :order_types, :string],
+                      [:contract_detail, :valid_exchanges, :string],
+                      [:contract_detail, :price_magnifier, :int],
+                      [:contract_detail, :under_con_id, :int],
+                      [:contract_detail, :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])
+                      [:contract_detail, :contract_month, :string],
+                      [:contract_detail, :industry, :string],
+                      [:contract_detail, :category, :string],
+                      [:contract_detail, :subcategory, :string],
+                      [:contract_detail, :time_zone, :string],
+                      [:contract_detail, :trading_hours, :string],
+                      [:contract_detail, :liquid_hours, :string])
 
       class ContractData
 
         def contract
-          @contract = IB::Contract.build @data[:contract]
+          @contract = IB::Contract.build @data[:contract].
+                                             merge(:contract_detail => contract_detail)
         end
+
+        def contract_detail
+          @contract_detail = IB::ContractDetail.new @data[:contract_detail]
+        end
+
+        alias contract_details contract_detail
+
       end # ContractData
 
       BondContractData =
-          def_message [18, 4],
+          def_message [18, 4], ContractData,
                       [: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_detail, :cusip, :string],
+                      [:contract_detail, :coupon, :decimal],
+                      [:contract_detail, :maturity, :string],
+                      [:contract_detail, :issue_date, :string],
+                      [:contract_detail, :ratings, :string],
+                      [:contract_detail, :bond_type, :string],
+                      [:contract_detail, :coupon_type, :string],
+                      [:contract_detail, :convertible, :boolean],
+                      [:contract_detail, :callable, :boolean],
+                      [:contract_detail, :puttable, :boolean],
+                      [:contract_detail, :desc_append, :string],
                       [:contract, :exchange, :string],
                       [:contract, :currency, :string],
-                      [:contract, :market_name, :string], # extended
-                      [:contract, :trading_class, :string],
+                      [:contract_detail, :market_name, :string], # extended
+                      [:contract_detail, :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
+                      [:contract_detail, :min_tick, :decimal],
+                      [:contract_detail, :order_types, :string],
+                      [:contract_detail, :valid_exchanges, :string],
+                      [:contract_detail, :valid_next_option_date, :string],
+                      [:contract_detail, :valid_next_option_type, :string],
+                      [:contract_detail, :valid_next_option_partial, :string],
+                      [:contract_detail, :notes, :string],
+                      [:contract_detail, :long_name, :string]
 
     end # module Incoming
   end # module Messages

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

@@ -6,13 +6,16 @@ module IB
       # - 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]
+                                           [:underlying, :con_id, :int],
+                                           [:underlying, :delta, :decimal],
+                                           [:underlying, :price, :decimal]
       class DeltaNeutralValidation
-        def contract
-          @contract = IB::Contract.build @data[:contract].merge(:under_comp => true)
+        def underlying
+          @underlying = IB::Underlying.new @data[:underlying]
         end
+
+        alias under_comp underlying
+
       end # DeltaNeutralValidation
 
     end # module Incoming

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

@@ -6,7 +6,7 @@ module IB
           def_message [11, 8],
                       # The reqID that was specified previously in the call to reqExecution()
                       [:request_id, :int],
-                      [:execution, :order_id, :int],
+                      [:execution, :local_id, :int],
                       [:contract, :con_id, :int],
                       [:contract, :symbol, :string],
                       [:contract, :sec_type, :string],
@@ -22,7 +22,7 @@ module IB
                       [:execution, :account_name, :string],
                       [:execution, :exchange, :string],
                       [:execution, :side, :string],
-                      [:execution, :shares, :int],
+                      [:execution, :quantity, :int],
                       [:execution, :price, :decimal],
                       [:execution, :perm_id, :int],
                       [:execution, :client_id, :int],

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

@@ -0,0 +1,18 @@
+module IB
+  module Messages
+    module Incoming
+
+      # This message is always sent by TWS automatically at connect.
+      # The IB::Connection class subscribes to it automatically and stores
+      # the order id in its @next_local_id attribute.
+      NextValidID = NextValidId = def_message(9, [:local_id, :int])
+
+      class NextValidId
+
+        # Legacy accessor
+        alias order_id local_id
+
+      end # class NextValidId
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -5,7 +5,7 @@ module IB
       # OpenOrder is the longest message with complex processing logics
       OpenOrder =
           def_message [5, [23, 28]],
-                      [:order, :order_id, :int],
+                      [:order, :local_id, :int],
 
                       [:contract, :con_id, :int],
                       [:contract, :symbol, :string],
@@ -70,12 +70,20 @@ module IB
                       [:order, :delta_neutral_order_type, :string],
                       [:order, :delta_neutral_aux_price, :decimal_max]
 
-
       class OpenOrder
 
-
         # Accessors to make OpenOrder API-compatible with OrderStatus message
 
+        def local_id
+          order.local_id
+        end
+
+        alias order_id local_id
+
+        def status
+          order.status
+        end
+
         def order
           @order ||= IB::Order.new @data[:order].merge(:order_state => order_state)
         end
@@ -83,23 +91,23 @@ module IB
         def order_state
           @order_state ||= IB::OrderState.new(
               @data[:order_state].merge(
-                  :order_id => @data[:order][:order_id],
+                  :local_id => @data[:order][:local_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]
+          @contract ||= IB::Contract.build(
+              @data[:contract].merge(:underlying => underlying)
+          )
         end
 
-        def order_id
-          order.order_id
+        def underlying
+          @underlying = @data[:underlying_present] ? IB::Underlying.new(@data[:underlying]) : nil
         end
 
-        def status
-          order.status
-        end
+        alias under_comp underlying
 
         def load
           super
@@ -152,7 +160,6 @@ module IB
                          [:order, :scale_profit_offset, :decimal_max],
                          [:order, :scale_auto_reset, :boolean],
                          [:order, :scale_init_position, :int_max],
-                         [:order, :scale_init_position, :int_max],
                          [:order, :scale_init_fill_qty, :decimal_max],
                          [:order, :scale_random_percent, :boolean]]
                    ],
@@ -169,12 +176,12 @@ module IB
                    [:order, :clearing_account, :string],
                    [:order, :clearing_intent, :string],
                    [:order, :not_held, :boolean],
-                   [:contract, :under_comp, :boolean],
+                   [:underlying_present, :boolean],
 
-                   [proc { | | filled?(@data[:contract][:under_comp]) },
-                    [:contract, :under_con_id, :int],
-                    [:contract, :under_delta, :decimal],
-                    [:contract, :under_price, :decimal]
+                   [proc { | | filled?(@data[:underlying_present]) },
+                    [:underlying, :con_id, :int],
+                    [:underlying, :delta, :decimal],
+                    [:underlying, :price, :decimal]
                    ],
 
                    [:order, :algo_strategy, :string],

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

@@ -32,7 +32,7 @@ module IB
       #      order to be held. For example, 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_state, :order_id, :int],
+                                [:order_state, :local_id, :int],
                                 [:order_state, :status, :string],
                                 [:order_state, :filled, :int],
                                 [:order_state, :remaining, :int],
@@ -49,10 +49,12 @@ module IB
         end
 
         # Accessors to make OpenOrder and OrderStatus messages API-compatible
-        def order_id
-          order_state.order_id
+        def local_id
+          order_state.local_id
         end
 
+        alias order_id local_id
+
         def status
           order_state.status
         end

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

@@ -24,17 +24,21 @@ module IB
 
           @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),
+             :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,
+                     :contract_detail =>
+                         IB::ContractDetail.new(
+                             :market_name => socket.read_str,
+                             :trading_class => socket.read_str)),
              :distance => socket.read_str,
              :benchmark => socket.read_str,
              :projection => socket.read_str,

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

@@ -26,11 +26,6 @@ module IB
 
       AccountUpdateTime = def_message 8, [:time_stamp, :string]
 
-      # This message is always sent by TWS automatically at connect.
-      # The IB::Connection class subscribes to it automatically and stores
-      # the order id in its @next_order_id attribute.
-      NextValidID = NextValidId = def_message(9, [:order_id, :int])
-
       NewsBulletins =
           def_message 14, [:request_id, :int], # unique incrementing bulletin ID.
                       [:type, :int], # Type of bulletin. Valid values include:
@@ -87,6 +82,7 @@ module IB
       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/next_valid_id'
       require 'ib-ruby/messages/incoming/open_order'
       require 'ib-ruby/messages/incoming/order_status'
       require 'ib-ruby/messages/incoming/portfolio_value'

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

@@ -36,7 +36,8 @@ module IB
         def encode server
           [self.class.message_id,
            self.class.version,
-           @data[:id] || @data[:ticker_id] || @data[:request_id]|| @data[:order_id] || [],
+           @data[:id] || @data[:ticker_id] || @data[:request_id] ||
+               @data[:local_id] || @data[:order_id] || [],
            self.class.data_map.map do |(field, default_method, args)|
              case
                when default_method.nil?

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

@@ -2,7 +2,7 @@ module IB
   module Messages
     module Outgoing
 
-      # Data format is { :id => int: order_id,
+      # Data format is { :id => int: local_id,
       #                  :contract => Contract,
       #                  :order => Order }
       PlaceOrder = def_message [3, 31] # v.38 is NOT properly supported by API yet

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

@@ -45,7 +45,7 @@ module IB
       CancelCalculateImpliedVolatility = CancelImpliedVolatility = def_message(56)
       CancelCalculateOptionPrice = CancelOptionPrice = def_message(57)
 
-      ## Data format is: @data ={ :id => order_id to cancel }
+      ## Data format is: @data ={ :id => local_id of order to cancel }
       CancelOrder = def_message 4
 
       ## These messages contain just one or two extra fields:

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

@@ -0,0 +1,59 @@
+require 'ib-ruby/models/contract'
+
+module IB
+  module Models
+
+    # "BAG" is not really a contract, but a combination (combo) of securities.
+    # AKA basket or bag of securities. Individual securities in combo are represented
+    # by ComboLeg objects.
+    class Bag < Contract
+      # 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")
+
+      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 default_attributes
+        {:legs => Array.new,
+         :sec_type => :bag}.merge super
+      end
+
+      def description
+        self[:description] || to_human
+      end
+
+      def to_human
+        "<Bag: #{[symbol, exchange, currency].join(' ')} legs: #{legs_description} >"
+      end
+
+      ### Leg-related methods
+
+      # TODO: Rewrite with legs and legs_description being strictly in sync...
+      # TODO: Find a way to serialize legs without references...
+      # IB-equivalent leg description.
+      def legs_description
+        self[:legs_description] || legs.map { |leg| "#{leg.con_id}|#{leg.weight}" }.join(',')
+      end
+
+      # Check if two Contracts have same legs (maybe in different order)
+      def same_legs? other
+        legs == other.legs ||
+            legs_description.split(',').sort == other.legs_description.split(',').sort
+      end
+
+      # Contract comparison
+      def == other
+        super && same_legs?(other)
+      end
+
+    end # class Bag
+  end # Models
+end # IB

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

@@ -7,6 +7,8 @@ module IB
     class ComboLeg < Model.for(:combo_leg)
       include ModelProperties
 
+      belongs_to :contract
+
       # 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.
@@ -36,12 +38,14 @@ module IB
       validates_format_of :designated_location, :with => /^$/,
                           :message => "should be blank or orders will be rejected"
 
-      DEFAULT_PROPS = {:con_id => 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, }
+      def default_attributes
+        {:con_id => 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, }.merge super
+      end
 
       #  Leg's weight is a combination of action and ratio
       def weight