ib-ruby 0.7.6 → 0.7.8

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

@@ -0,0 +1,278 @@
+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_one :contract_detail
+
+      has_one :underlying # for Delta-Neutral Combo contracts only!
+      alias under_comp underlying
+      alias under_comp= underlying=
+
+      has_many :combo_legs
+      alias legs combo_legs
+      alias legs= combo_legs=
+      alias combo_legs_description legs_description
+      alias combo_legs_description= legs_description=
+
+
+      ### 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
+        {:con_id => 0,
+         :strike => 0.0,
+         :right => :none, # Not an option
+         :exchange => 'SMART',
+         :include_expired => false, }.merge super
+      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

@@ -0,0 +1,70 @@
+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
+        {:coupon => 0.0,
+         :under_con_id => 0,
+         :min_tick => 0,
+         :callable => false,
+         :puttable => false,
+         :convertible => false,
+         :next_option_partial => false, }.merge super
+      end
+
+    end # class ContractDetail
+  end # module Models
+end # module IB

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

@@ -5,7 +5,9 @@ module IB
     class Execution < Model.for(:execution)
       include ModelProperties
 
-      prop :order_id, #     int: order id. TWS orders have a fixed order id of 0.
+      belongs_to :order
+
+      prop [:local_id, :order_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.
@@ -13,29 +15,33 @@ module IB
            #                String: The order execution time.
            :exchange, #     String: Exchange that executed the order.
            :order_ref, #  int: Same order_ref as in corresponding Order
-           [:account_name, :account_number], # String: The customer account number.
            :price, #        double: The order execution price.
            :average_price, # double: Average price. Used in regular trades, combo
            #                         trades and legs of the combo.
-           :shares, #       int: The number of shares filled.
+           [: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, #  int: This position is liquidated last should the need arise.
-           [:side, :action] => PROPS[:side] # String: Was the transaction a buy or a sale: BOT|SLD
+           :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 :shares, :cumulative_quantity, :price, :average_price
-
-      DEFAULT_PROPS = {:order_id => 0,
-                       :client_id => 0,
-                       :shares => 0,
-                       :price => 0,
-                       :perm_id => 0,
-                       :liquidation => 0, }
+      validates_numericality_of :quantity, :cumulative_quantity, :price, :average_price
+      validates_numericality_of :local_id, :client_id, :perm_id, :only_integer => true
+
+      def default_attributes
+        {:local_id => 0,
+         :client_id => 0,
+         :quantity => 0,
+         :price => 0,
+         :perm_id => 0,
+         :liquidation => false, }.merge super
+      end
+
       # Comparison
       def == other
         perm_id == other.perm_id &&
-            order_id == other.order_id && # ((p __LINE__)||true) &&
+            local_id == other.local_id && # ((p __LINE__)||true) &&
             client_id == other.client_id &&
             exec_id == other.exec_id &&
             time == other.time &&
@@ -46,9 +52,9 @@ module IB
       end
 
       def to_human
-        "<Execution: #{time} #{side} #{shares} at #{price} on #{exchange}, " +
+        "<Execution: #{time} #{side} #{quantity} at #{price} on #{exchange}, " +
             "cumulative #{cumulative_quantity} at #{average_price}, " +
-            "ids #{order_id}/#{perm_id}/#{exec_id}>"
+            "ids #{local_id}/#{perm_id}/#{exec_id}>"
       end
 
       alias to_s to_human

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

@@ -1,43 +1,101 @@
 module IB
   module Models
 
-    # Base IB data Model class, in future it will be developed into ActiveModel
+    # Base class for tableless IB data Models extends ActiveModel API
     class Model
+      extend ActiveModel::Naming
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations
+      include ActiveModel::Serialization
+      include ActiveModel::Serializers::Xml
+      include ActiveModel::Serializers::JSON
 
       # IB Models can be either database-backed, or not
-      # require 'ib-ruby/db' # to make IB models database-backed
+      # require 'ib-ruby/db' # to make all IB models database-backed
+      # If you plan to persist only specific Models, select those subclasses here:
       def self.for subclass
-        if DB
-          case subclass
-            when :execution, :bar, :order_state
-              # Just a couple of AR models introduced for now...
-              ActiveRecord::Base
-            else
-              Model
-          end
+        if DB # && [:contract, :order, :order_state].include? subclass
+          ActiveRecord::Base
         else
           Model
         end
       end
 
+      attr_accessor :created_at, :updated_at, :attributes
+
       # If a opts hash is given, keys are taken as attribute names, values as data.
       # The model instance fields are then set automatically from the opts Hash.
-      def initialize(opts={})
-        error "Argument must be a Hash", :args unless opts.is_a?(Hash)
+      def initialize opts={}
+        run_callbacks :initialize do
+          error "Argument must be a Hash", :args unless opts.is_a?(Hash)
+
+          attrs = default_attributes.merge(opts)
+          attrs.keys.each { |key| self.send("#{key}=", attrs[key]) }
+        end
+      end
 
-        props = self.class::DEFAULT_PROPS.merge(opts)
-        props.keys.each { |key| self.send("#{key}=", props[key]) }
+      # ActiveModel API (for serialization)
+
+      def attributes
+        @attributes ||= HashWithIndifferentAccess.new
       end
 
-      # ActiveModel-style attribute accessors
+      # ActiveModel-style read/write_attribute accessors
       def [] key
-        instance_variable_get "@#{key}".to_sym
+        attributes[key.to_sym]
       end
 
       def []= key, val
-        instance_variable_set "@#{key}".to_sym, val
+        attributes[key.to_sym] = val
+      end
+
+      def to_model
+        self
+      end
+
+      def new_record?
+        true
+      end
+
+      def save
+        valid?
+      end
+
+      alias save! save
+
+      ### ActiveRecord::Base association API mocks
+
+      def self.belongs_to model, *args
+        attr_accessor model
       end
 
+      def self.has_one model, *args
+        attr_accessor model
+      end
+
+      def self.has_many models, *args
+        attr_accessor models
+
+        define_method(models) do
+          self.instance_variable_get("@#{models}") ||
+              self.instance_variable_set("@#{models}", [])
+        end
+      end
+
+      def self.find *args
+        []
+      end
+
+      ### ActiveRecord::Base callback API mocks
+
+      define_model_callbacks :initialize, :only => :after
+
+      ### ActiveRecord::Base misc
+
+      def self.serialize *properties
+      end
+
+
     end # Model
   end # module Models
 end # module IB

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

@@ -1,5 +1,6 @@
 require 'active_model'
 require 'active_support/concern'
+require 'active_support/hash_with_indifferent_access'
 
 module IB
   module Models
@@ -8,25 +9,50 @@ module IB
     module ModelProperties
       extend ActiveSupport::Concern
 
-      DEFAULT_PROPS = {}
+      def default_attributes
+        {:created_at => Time.now,
+         :updated_at => Time.now,
+        }
+      end
 
       ### Instance methods
 
-      attr_accessor :created_at
+      # Default presentation
+      def to_human
+        "<#{self.class.to_s.demodulize}: " + attributes.map do |attr, value|
+          "#{attr}: #{value}" unless value.nil?
+        end.compact.sort.join(' ') + ">"
+      end
+
+      # Comparison support
+      def content_attributes
+        HashWithIndifferentAccess[attributes.reject do |(attr, _)|
+          attr.to_s =~ /(_id|_count)$/ ||
+              [:created_at, :updated_at, :type, :id].include?(attr.to_sym)
+        end]
+      end
 
-      def initialize opts={}
-        @created_at = Time.now
-        super self.class::DEFAULT_PROPS.merge(opts)
+      # Default Model comparison
+      def == other
+        content_attributes.inject(true) { |res, (attr, value)| res && other.send(attr) == value } &&
+            other.content_attributes.inject(true) { |res, (attr, value)| res && send(attr) == value }
       end
 
       included do
 
+        # Extending AR-backed Model class with attribute defaults
+        if defined?(ActiveRecord::Base) && ancestors.include?(ActiveRecord::Base)
+          def initialize opts={}
+            super default_attributes.merge(opts)
+          end
+        end
+
         ### Class macros
 
         def self.prop *properties
           prop_hash = properties.last.is_a?(Hash) ? properties.pop : {}
 
-          properties.each { |names| define_property names, '' }
+          properties.each { |names| define_property names, nil }
           prop_hash.each { |names, type| define_property names, type }
         end
 
@@ -57,7 +83,6 @@ module IB
                                       :validate => body[2]
 
             when Hash # recursion base case
-
               getter = case # Define getter
                          when body[:get].respond_to?(:call)
                            body[:get]
@@ -65,10 +90,14 @@ module IB
                            proc { self[name].send "to_#{body[:get]}" }
                          when VALUES[name] # property is encoded
                            proc { VALUES[name][self[name]] }
+                            #when respond_to?(:column_names) && column_names.include?(name.to_s)
+                            #  # noop, ActiveRecord will take care of it...
+                            #  p "#{name} => get noop"
+                            #  p respond_to?(:column_names) && column_names
                          else
                            proc { self[name] }
                        end
-              define_method name, &getter
+              define_method name, &getter if getter
 
               setter = case # Define setter
                          when body[:set].respond_to?(:call)
@@ -78,9 +107,9 @@ module IB
                          when CODES[name] # property is encoded
                            proc { |value| self[name] = CODES[name][value] || value }
                          else
-                           proc { |value| self[name] = value }
+                           proc { |value| self[name] = value } # p name, value;
                        end
-              define_method "#{name}=", &setter
+              define_method "#{name}=", &setter if setter
 
               # Define validator(s)
               [body[:validate]].flatten.compact.each do |validator|
@@ -95,22 +124,7 @@ module IB
             # TODO define self[:name] accessors for :virtual and :flag properties
 
             else # setter given
-              define_property_methods name, :set => body
-          end
-        end
-
-        # Extending lighweight (not DB-backed) Model class to mimic AR::Base
-        unless ancestors.include? ActiveModel::Validations
-          include ActiveModel::Validations
-
-          def save
-            false
-          end
-
-          alias save! save
-
-          def self.find *args
-            []
+              define_property_methods name, :set => body, :get => body
           end
         end