ib-ruby 0.8.1 → 0.8.3

data/lib/ib-ruby/messages.rb

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

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

@@ -1,54 +0,0 @@
-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"
-
-      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 # Models
-end # IB

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

@@ -1,43 +0,0 @@
-module IB
-  module Models
-    # 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.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, # 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 Models
-end # module IB

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

@@ -1,104 +0,0 @@
-module IB
-  module Models
-
-    # ComboLeg is essentially a join Model between Combo (BAG) Contract and
-    # individual Contracts (securities) that this BAG contains.
-    class ComboLeg < Model.for(:combo_leg)
-      include ModelProperties
-
-      # 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 Models
-end # module IB

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

@@ -1,287 +0,0 @@
-require 'ib-ruby/models/contract_detail'
-require 'ib-ruby/models/underlying'
-
-module IB
-  module Models
-    class Contract < Model.for(:contract)
-      include ModelProperties
-
-      # 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-ruby, 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 'ib-ruby/models/option'
-    require 'ib-ruby/models/bag'
-
-    class Contract
-      # Specialized Contract subclasses representing different security types
-      Subclasses = Hash.new(Contract)
-      Subclasses[:bag] = IB::Models::Bag
-      Subclasses[:option] = IB::Models::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 Models
-end # module IB

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

@@ -1,70 +0,0 @@
-module IB
-  module Models
-
-    # Additional Contract properties (volatile, therefore extracted)
-    class ContractDetail < Model.for(:contract_detail)
-      include ModelProperties
-
-      belongs_to :contract
-      alias summary contract
-      alias summary= contract=
-
-      # All fields Strings, unless specified otherwise:
-      prop :market_name, # The market name for this contract.
-           :trading_class, # The trading class name for this contract.
-           :min_tick, # double: The minimum price tick.
-           :price_magnifier, # int: Allows execution and strike prices to be
-           #     reported consistently with market data, historical data and the
-           #     order price: Z on LIFFE is reported in index points, not GBP.
-
-           :order_types, #       The list of valid order types for this contract.
-           :valid_exchanges, #   The list of exchanges this contract is traded on.
-           :under_con_id, # int: The underlying contract ID.
-           :long_name, #         Descriptive name of the asset.
-           :contract_month, #    The contract month of the underlying futures contract.
-
-           # The industry classification of the underlying/product:
-           :industry, #    Wide industry. For example, Financial.
-           :category, #    Industry category. For example, InvestmentSvc.
-           :subcategory, # Subcategory. For example, Brokerage.
-           [:time_zone, :time_zone_id], # Time zone for the trading hours (e.g. EST)
-           :trading_hours, # The trading hours of the product. For example:
-           #                 20090507:0700-1830,1830-2330;20090508:CLOSED.
-           :liquid_hours, #  The liquid trading hours of the product. For example,
-           #                 20090507:0930-1600;20090508:CLOSED.
-
-           # BOND values:
-           :cusip, # The nine-character bond CUSIP or the 12-character SEDOL.
-           :ratings, # Credit rating of the issuer. Higher rating is less risky investment.
-           #           Bond ratings are from Moody's and S&P respectively.
-           :desc_append, # Additional descriptive information about the bond.
-           :bond_type, #   The type of bond, such as "CORP."
-           :coupon_type, # The type of bond coupon.
-           :coupon, # double: The interest rate used to calculate the amount you
-           #          will receive in interest payments over the year. default 0
-           :maturity, # The date on which the issuer must repay bond face value
-           :issue_date, # The date the bond was issued.
-           :next_option_date, # only if bond has embedded options.
-           :next_option_type, # only if bond has embedded options.
-           :notes, # Additional notes, if populated for the bond in IB's database
-           :callable => :bool, # Can be called by the issuer under certain conditions.
-           :puttable => :bool, # Can be sold back to the issuer under certain conditions
-           :convertible => :bool, # Can be converted to stock under certain conditions.
-           :next_option_partial => :bool # # only if bond has embedded options.
-
-      # Extra validations
-      validates_format_of :time_zone, :with => /^\w{3}$/, :message => 'should be XXX'
-
-      def default_attributes
-        super.merge :coupon => 0.0,
-                    :under_con_id => 0,
-                    :min_tick => 0,
-                    :callable => false,
-                    :puttable => false,
-                    :convertible => false,
-                    :next_option_partial => false
-      end
-
-    end # class ContractDetail
-  end # module Models
-end # module IB

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

@@ -1,64 +0,0 @@
-module IB
-  module Models
-    # This is IB Order execution report.
-    # Instantiate with a Hash of attributes, to be auto-set via initialize in Model.
-    class Execution < Model.for(:execution)
-      include ModelProperties
-
-      belongs_to :order
-
-      prop :local_id, #     int: order id. TWS orders have a fixed order id of 0.
-           :client_id, #    int: client id. TWS orders have a fixed client id of 0.
-           :perm_id, #      int: TWS id used to identify orders over TWS sessions
-           :exec_id, #      String: Unique order execution id over TWS sessions.
-           :time, #         # TODO: convert into Time object?
-           #                String: The order execution time.
-           :exchange, #     String: Exchange that executed the order.
-           :order_ref, #  int: Same order_ref as in corresponding Order
-           :price, #        double: The order execution price.
-           :average_price, # double: Average price. Used in regular trades, combo
-           #                         trades and legs of the combo.
-           [:quantity, :shares], #       int: The number of shares filled.
-           :cumulative_quantity, # int: Cumulative quantity. Used in regular
-           #                            trades, combo trades and legs of the combo
-           :liquidation => :bool, # This position is liquidated last should the need arise.
-           [:account_name, :account_number] => :s, # The customer account number.
-           [:side, :action] => PROPS[:side] # Was the transaction a buy or a sale: BOT|SLD
-
-      # Extra validations
-      validates_numericality_of :quantity, :cumulative_quantity, :price, :average_price
-      validates_numericality_of :local_id, :client_id, :perm_id, :only_integer => true
-
-      def default_attributes
-        super.merge :local_id => 0,
-                    :client_id => 0,
-                    :quantity => 0,
-                    :price => 0,
-                    :perm_id => 0,
-                    :liquidation => false
-      end
-
-      # Comparison
-      def == other
-        perm_id == other.perm_id &&
-            local_id == other.local_id && # ((p __LINE__)||true) &&
-            client_id == other.client_id &&
-            exec_id == other.exec_id &&
-            time == other.time &&
-            exchange == other.exchange &&
-            order_ref == other.order_ref &&
-            side == other.side
-        # TODO: || compare all attributes!
-      end
-
-      def to_human
-        "<Execution: #{time} #{side} #{quantity} at #{price} on #{exchange}, " +
-            "cumulative #{cumulative_quantity} at #{average_price}, " +
-            "ids #{local_id}/#{perm_id}/#{exec_id}>"
-      end
-
-      alias to_s to_human
-
-    end # Execution
-  end # module Models
-end # module IB