ib-ruby 0.8.1 → 0.8.3

data/lib/{ib-ruby → ib}/messages/outgoing.rb

@@ -1,4 +1,4 @@
-require 'ib-ruby/messages/outgoing/abstract_message'
+require 'ib/messages/outgoing/abstract_message'
 
 # TODO: Don't instantiate messages, use their classes as just namespace for .encode/decode
 
@@ -108,7 +108,7 @@ module IB
                                       :side)
 
       # data = { :id => ticker_id (int),
-      #          :contract => Contract,
+      #          :contract => IB::Contract,
       #          :exercise_action => int, 1 = exercise, 2 = lapse
       #          :exercise_quantity => int, The number of contracts to be exercised
       #          :account => string,
@@ -130,7 +130,7 @@ module IB
 
       # @data={:id => int: ticker_id - Must be a unique value. When the market data
       #                                returns, it will be identified by this tag,
-      #      :contract => Models::Contract, requested contract.
+      #      :contract => IB::Contract, requested contract.
       #      :tick_list => String: comma delimited list of requested tick groups:
       #        Group ID - Description - Requested Tick Types
       #        100 - Option Volume (currently for stocks) - 29, 30
@@ -268,8 +268,8 @@ module IB
                       :scanner_setting_pairs,
                       :stock_type_filter)
 
-      require 'ib-ruby/messages/outgoing/place_order'
-      require 'ib-ruby/messages/outgoing/bar_requests'
+      require 'ib/messages/outgoing/place_order'
+      require 'ib/messages/outgoing/bar_requests'
 
     end # module Outgoing
   end # module Messages

data/lib/ib/messages.rb

@@ -0,0 +1,8 @@
+module IB
+  module Messages
+  end
+end
+
+require 'ib/messages/outgoing'
+require 'ib/messages/incoming'
+

data/lib/ib/model.rb

@@ -0,0 +1,8 @@
+require 'ib/base_properties'
+require 'ib/base'
+
+module IB
+  # IB Models can be either lightweight (tableless) or database-backed.
+  # require 'ib/db' - to make all IB models database-backed
+  Model =  IB.db_backed? ? ActiveRecord::Base : IB::Base
+end

data/lib/ib/models.rb

@@ -0,0 +1,10 @@
+  require 'ib/model'
+
+  require 'models/ib/contract_detail'
+  require 'models/ib/underlying'
+  require 'models/ib/contract'
+  require 'models/ib/order_state'
+  require 'models/ib/order'
+  require 'models/ib/combo_leg'
+  require 'models/ib/execution'
+  require 'models/ib/bar'

data/lib/ib/requires.rb

@@ -0,0 +1,9 @@
+require 'ib/version'
+require 'ib/extensions'
+require 'ib/errors'
+require 'ib/constants'
+require 'ib/connection'
+
+require 'ib/models'
+require 'ib/messages'
+require 'ib/symbols'

data/lib/{ib-ruby → ib}/symbols/forex.rb

@@ -1,4 +1,4 @@
-# Note that the :description field is particular to ib-ruby, and is NOT part of the
+# Note that the :description field is particular to ib, and is NOT part of the
 # standard TWS API. It is never transmitted to IB. It's purely used clientside, and
 # you can store any arbitrary string that you may find useful there.
 module IB

data/lib/{ib-ruby → ib}/symbols/futures.rb

@@ -4,7 +4,7 @@
 # takes over as the volume leader.
 #
 #
-# Note that the :description field is particular to ib-ruby, and is NOT part of the standard TWS API.
+# Note that the :description field is particular to ib, and is NOT part of the standard TWS API.
 # It is never transmitted to IB. It's purely used clientside, and you can store any arbitrary string that
 # you may find useful there.
 #
@@ -39,7 +39,7 @@ module IB
       "#{ next_quarter_year(time) }#{ sprintf("%02d", next_quarter_month(time)) }"
     end
 
-    # Convenience method; generates a Models::Contract instance for a futures
+    # Convenience method; generates an IB::Contract instance for a futures
     # contract with the given parameters.
     #
     # If expiry is nil, it will use the end month of the current

data/lib/{ib-ruby → ib}/symbols/options.rb

@@ -1,6 +1,6 @@
 # Stock contracts definitions
 #
-# Note that the :description field is particular to ib-ruby, and is NOT part of the
+# Note that the :description field is particular to ib, and is NOT part of the
 # standard TWS API. It is never transmitted to IB. It's purely used clientside, and
 # you can store any arbitrary string that you may find useful there.
 

data/lib/{ib-ruby → ib}/symbols/stocks.rb

@@ -1,6 +1,6 @@
 # Stock contracts definitions
 #
-# Note that the :description field is particular to ib-ruby, and is NOT part of the
+# Note that the :description field is particular to ib, and is NOT part of the
 # standard TWS API. It is never transmitted to IB. It's purely used clientside, and
 # you can store any arbitrary string that you may find useful there.
 

data/lib/ib/symbols.rb

@@ -0,0 +1,9 @@
+module IB
+  module Symbols
+  end
+end
+
+require 'ib/symbols/forex'
+require 'ib/symbols/futures'
+require 'ib/symbols/stocks'
+require 'ib/symbols/options'

data/lib/ib-ruby.rb

@@ -1,24 +1,2 @@
-module IB
-  # IB Models can be either database-backed, or not
-  # By default there is no DB backend, unless specifically requested
-  # require 'ib-ruby/db' # to make all IB models database-backed
-  DB ||= false
-
-  require 'ib-ruby/version'
-  require 'ib-ruby/extensions'
-  require 'ib-ruby/errors'
-  require 'ib-ruby/constants'
-  require 'ib-ruby/connection'
-
-  require 'ib-ruby/models'
-  Datatypes = Models # Flatten namespace (IB::Contract instead of IB::Models::Contract)
-  include Models # Legacy alias
-
-  require 'ib-ruby/messages'
-  IncomingMessages = Messages::Incoming # Legacy alias
-  OutgoingMessages = Messages::Outgoing # Legacy alias
-
-  require 'ib-ruby/symbols'
-end
-IbRuby = IB
-
+require 'ib'
+ 

data/lib/ib.rb

@@ -0,0 +1,23 @@
+module IB
+  def self.db_backed?
+    !!defined?(IB::DB)
+  end
+ 
+  def self.rails?
+    !!defined?(Rails) && Rails.respond_to?('env')
+  end
+
+end # module IB
+
+IbRuby = IB
+Ib = IB
+
+# IB Models can be either lightweight (tableless) or database-backed.
+# By default there is no DB backend, unless specifically requested
+# require 'ib/db' # to make all IB models database-backed
+
+if IB.rails?
+  require 'ib/engine'
+else
+  require 'ib/requires'
+end

data/lib/models/ib/bag.rb

@@ -0,0 +1,51 @@
+require 'models/ib/contract'
+
+module IB
+
+  # "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"
+
+    def default_attributes
+      super.merge :sec_type => :bag #,:legs => Array.new,
+    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 # IB

data/lib/models/ib/bar.rb

@@ -0,0 +1,41 @@
+module IB
+  # 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 < IB::Model
+    include BaseProperties
+
+    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, # Volume
+      :wap, #    Weighted average price during the time covered by the bar.
+      :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.
+
+    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 IB

data/lib/models/ib/combo_leg.rb

@@ -0,0 +1,102 @@
+module IB
+
+  # ComboLeg is essentially a join Model between Combo (BAG) Contract and
+  # individual Contracts (securities) that this BAG contains.
+  class ComboLeg < IB::Model
+    include BaseProperties
+
+    # BAG Combo Contract that contains this Leg
+    belongs_to :combo, :class_name => 'Contract'
+    # Contract that constitutes this Leg
+    belongs_to :leg_contract, :class_name => 'Contract', :foreign_key => :leg_contract_id
+
+    # 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.
+
+    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.
+
+      :exchange, # String: exchange to which the complete combo order will be routed.
+      # For institutional customers only! For stock legs when doing short sale
+      :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: ?
+      [: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"
+
+    def default_attributes
+      super.merge :con_id => 0,
+        :ratio => 1,
+        :side => :buy,
+        :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
+    end
+
+    #  Leg's weight is a combination of action and ratio
+    def weight
+      side == :buy ? ratio : -ratio
+    end
+
+    def weight= value
+      value = value.to_i
+      if value > 0
+        self.side = :buy
+        self.ratio = value
+      else
+        self.side = :sell
+        self.ratio = -value
+      end
+    end
+
+    # Some messages include open_close, some don't. wtf.
+    def serialize *fields
+      [con_id,
+       ratio,
+       side.to_sup,
+       exchange,
+       (fields.include?(:extended) ?
+        [self[:open_close],
+         self[:short_sale_slot],
+         designated_location,
+         exempt_code] :
+        [])
+       ].flatten
+    end
+
+    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 IB

data/lib/models/ib/contract.rb

@@ -0,0 +1,287 @@
+require 'models/ib/contract_detail'
+require 'models/ib/underlying'
+
+module IB
+  class Contract < IB::Model
+    include BaseProperties
+
+    # Fields are Strings unless noted otherwise
+    prop :con_id, # int: The unique contract identifier.
+      :currency, # Only needed if there is an ambiguity, e.g. when SMART exchange
+      #            and IBM is being requested (IBM can trade in GBP or USD).
+
+      :legs_description, # received in OpenOrder for all combos
+
+      :sec_type, # Security type. Valid values are: SECURITY_TYPES
+
+      :sec_id, # Unique identifier of the given secIdType.
+
+      :sec_id_type => :sup, # Security identifier, when querying contract details or
+      #               when placing orders. Supported identifiers are:
+      #               -  ISIN (Example: Apple: US0378331005)
+      #               -  CUSIP (Example: Apple: 037833100)
+      #               -  SEDOL (6-AN + check digit. Example: BAE: 0263494)
+      #               -  RIC (exchange-independent RIC Root and exchange-
+      #                  identifying suffix. Ex: AAPL.O for Apple on NASDAQ.)
+
+      :symbol => :s, # This is the symbol of the underlying asset.
+
+      :local_symbol => :s, # Local exchange symbol of the underlying asset
+
+      # Future/option contract multiplier (only needed when multiple possibilities exist)
+      :multiplier => {:set => :i},
+
+      :strike => :f, # double: The strike price.
+      :expiry => :s, # The expiration date. Use the format YYYYMM or YYYYMMDD
+      :exchange => :sup, # The order destination, such as Smart.
+      :primary_exchange => :sup, # Non-SMART exchange where the contract trades.
+      :include_expired => :bool, # When true, contract details requests and historical
+      #         data queries can be performed pertaining to expired contracts.
+      #         Note: Historical data queries on expired contracts are
+      #         limited to the last year of the contracts life, and are
+      #         only supported for expired futures contracts.
+      #         This field can NOT be set to true for orders.
+
+
+      # Specifies a Put or Call. Valid input values are: P, PUT, C, CALL
+    :right => {
+      :set => proc { |val|
+        self[:right] =
+        case val.to_s.upcase
+        when 'NONE', '', '0', '?'
+          ''
+        when 'PUT', 'P'
+          'P'
+        when 'CALL', 'C'
+          'C'
+        else
+          val
+        end
+      },
+      :validate => {:format => {:with => /^put$|^call$|^none$/,
+                                :message => "should be put, call or none"}}
+    }
+
+    attr_accessor :description # NB: local to ib, not part of TWS.
+
+    ### Associations
+
+    has_many :orders # Placed for this Contract
+
+    has_one :contract_detail # Volatile info about this Contract
+
+    # For Contracts that are part of BAG
+    has_one :leg, :class_name => 'ComboLeg', :foreign_key => :leg_contract_id
+    has_one :combo, :class_name => 'Contract', :through => :leg
+
+    # for Combo/BAG Contracts that contain ComboLegs
+    has_many :combo_legs, :foreign_key => :combo_id
+    has_many :leg_contracts, :class_name => 'Contract', :through => :combo_legs
+    alias legs combo_legs
+    alias legs= combo_legs=
+
+    alias combo_legs_description legs_description
+    alias combo_legs_description= legs_description=
+
+    # for Delta-Neutral Combo Contracts
+    has_one :underlying
+    alias under_comp underlying
+    alias under_comp= underlying=
+
+
+      ### Extra validations
+    validates_inclusion_of :sec_type, :in => CODES[:sec_type].keys,
+      :message => "should be valid security type"
+
+    validates_format_of :expiry, :with => /^\d{6}$|^\d{8}$|^$/,
+      :message => "should be YYYYMM or YYYYMMDD"
+
+    validates_format_of :primary_exchange, :without => /SMART/,
+      :message => "should not be SMART"
+
+    validates_format_of :sec_id_type, :with => /ISIN|SEDOL|CUSIP|RIC|^$/,
+      :message => "should be valid security identifier"
+
+    validates_numericality_of :multiplier, :strike, :allow_nil => true
+
+    def default_attributes
+      super.merge :con_id => 0,
+        :strike => 0.0,
+        :right => :none, # Not an option
+        :exchange => 'SMART',
+        :include_expired => false
+    end
+
+    # This returns an Array of data from the given contract.
+    # Different messages serialize contracts differently. Go figure.
+    # Note that it does NOT include the combo legs.
+    # serialize [:option, :con_id, :include_expired, :sec_id]
+    def serialize *fields
+      [(fields.include?(:con_id) ? [con_id] : []),
+       symbol,
+       self[:sec_type],
+       (fields.include?(:option) ?
+        [expiry,
+         strike,
+         self[:right],
+         multiplier] : []),
+       exchange,
+       (fields.include?(:primary_exchange) ? [primary_exchange] : []),
+       currency,
+       local_symbol,
+       (fields.include?(:sec_id) ? [sec_id_type, sec_id] : []),
+       (fields.include?(:include_expired) ? [include_expired] : []),
+       ].flatten
+    end
+
+    def serialize_long *fields
+      serialize :option, :primary_exchange, *fields
+    end
+
+    def serialize_short *fields
+      serialize :option, *fields
+    end
+
+    # Serialize under_comp parameters: EClientSocket.java, line 471
+    def serialize_under_comp *args
+      under_comp ? under_comp.serialize : [false]
+    end
+
+    # Defined in Contract, not BAG subclass to keep code DRY
+    def serialize_legs *fields
+      case
+      when !bag?
+        []
+      when legs.empty?
+        [0]
+      else
+        [legs.size, legs.map { |leg| leg.serialize *fields }].flatten
+      end
+    end
+
+    # This produces a string uniquely identifying this contract, in the format used
+    # for command line arguments in the IB-Ruby examples. The format is:
+    #
+    #    symbol:sec_type:expiry:strike:right:multiplier:exchange:primary_exchange:currency:local_symbol
+    #
+    # Fields not needed for a particular security should be left blank
+    # (e.g. strike and right are only relevant for options.)
+    #
+    # For example, to query the British pound futures contract trading on Globex
+    # expiring in September, 2008, the string is:
+    #
+    #    GBP:FUT:200809:::62500:GLOBEX::USD:
+    def serialize_ib_ruby
+      serialize_long.join(":")
+    end
+
+    # Contract comparison
+    def == other
+      return false unless other.is_a?(self.class)
+
+      # Different sec_id_type
+      return false if sec_id_type && other.sec_id_type && sec_id_type != other.sec_id_type
+
+      # Different sec_id
+      return false if sec_id && other.sec_id && sec_id != other.sec_id
+
+      # Different symbols
+      return false if symbol && other.symbol && symbol != other.symbol
+
+      # Different currency
+      return false if currency && other.currency && currency != other.currency
+
+      # Same con_id for all Bags, but unknown for new Contracts...
+      # 0 or nil con_id  matches any
+      return false if con_id != 0 && other.con_id != 0 &&
+        con_id && other.con_id && con_id != other.con_id
+
+      # SMART or nil exchange matches any
+      return false if exchange != 'SMART' && other.exchange != 'SMART' &&
+        exchange && other.exchange && exchange != other.exchange
+
+      # Comparison for Bonds and Options
+      if bond? || option?
+        return false if right != other.right || strike != other.strike
+        return false if multiplier && other.multiplier &&
+          multiplier != other.multiplier
+        return false if expiry && expiry[0..5] != other.expiry[0..5]
+        return false unless expiry && (expiry[6..7] == other.expiry[6..7] ||
+                                       expiry[6..7].empty? || other.expiry[6..7].empty?)
+      end
+
+      # All else being equal...
+      sec_type == other.sec_type
+    end
+
+    def to_s
+      "<Contract: " + instance_variables.map do |key|
+        value = send(key[1..-1])
+        " #{key}=#{value}" unless value.nil? || value == '' || value == 0
+      end.compact.join(',') + " >"
+    end
+
+    def to_human
+      "<Contract: " +
+        [symbol,
+         sec_type,
+         (expiry == '' ? nil : expiry),
+         (right == :none ? nil : right),
+         (strike == 0 ? nil : strike),
+         exchange,
+         currency
+         ].compact.join(" ") + ">"
+    end
+
+    def to_short
+      "#{symbol}#{expiry}#{strike}#{right}#{exchange}#{currency}"
+    end
+
+    # Testing for type of contract:
+
+    def bag?
+      self[:sec_type] == 'BAG'
+    end
+
+    def bond?
+      self[:sec_type] == 'BOND'
+    end
+
+    def stock?
+      self[:sec_type] == 'STK'
+    end
+
+    def option?
+      self[:sec_type] == 'OPT'
+    end
+
+  end # class Contract
+
+
+  ### Now let's deal with Contract subclasses
+
+  require 'models/ib/option'
+  require 'models/ib/bag'
+
+  class Contract
+    # Specialized Contract subclasses representing different security types
+    Subclasses = Hash.new(Contract)
+    Subclasses[:bag] = IB::Bag
+    Subclasses[:option] = IB::Option
+
+    # This returns a Contract initialized from the serialize_ib_ruby format string.
+    def self.build opts = {}
+      subclass = VALUES[:sec_type][opts[:sec_type]] || opts[:sec_type].to_sym
+      Contract::Subclasses[subclass].new opts
+    end
+
+    # This returns a Contract initialized from the serialize_ib_ruby format string.
+    def self.from_ib_ruby string
+      keys = [:symbol, :sec_type, :expiry, :strike, :right, :multiplier,
+              :exchange, :primary_exchange, :currency, :local_symbol]
+      props = Hash[keys.zip(string.split(":"))]
+      props.delete_if { |k, v| v.nil? || v.empty? }
+      Contract.build props
+    end
+  end # class Contract
+end # module IB