ib-ruby 0.5.21 → 0.6.1

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

@@ -27,179 +27,154 @@ module IB
       end
 
       # Fields are Strings unless noted otherwise
-      attr_accessor :con_id, # int: The unique contract identifier.
-                    :symbol, # This is the symbol of the underlying asset.
-                    :sec_type, # Security type. Valid values are: SECURITY_TYPES
-                    :expiry, # The expiration date. Use the format YYYYMM.
-                    :strike, # double: The strike price.
-                    :right, # Specifies a Put or Call. Valid values are: P, PUT, C, CALL
-                    :multiplier, # Specifies a future or option contract multiplier
-                    #  String?    (only necessary when multiple possibilities exist)
-
-                    :exchange, # The order destination, such as Smart.
-                    :currency, # Ambiguities MAY require that currency field be specified,
-                    #            for example, when SMART is the exchange and IBM is being
-                    #            requested (IBM can trade in GBP or USD).
-
-                    :local_symbol, # Local exchange symbol of the underlying asset
-                    :primary_exchange, # pick a non-aggregate (ie not the SMART) exchange
-                    #                    that the contract trades on.  DO NOT SET TO SMART.
-
-                    :include_expired, # 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.
-
-                    :sec_id_type, # 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.)
-                    :sec_id, # Unique identifier of the given secIdType.
-
-                    # COMBOS
-                    :legs_description, # received in open order for all combos
-                    :legs # Dynamic memory structure used to store the leg
-      #              definitions for this contract.
+      prop :con_id, # int: The unique contract identifier.
+           :symbol, # This is the symbol of the underlying asset.
+           :sec_type, # Security type. Valid values are: SECURITY_TYPES
+           :strike, # double: The strike price.
+           :exchange, # The order destination, such as Smart.
+           :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).
+
+           :local_symbol, # Local exchange symbol of the underlying asset
+           :include_expired, # 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.
+
+           :sec_id_type, # 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.)
+           :sec_id, # Unique identifier of the given secIdType.
+
+           # COMBOS
+           :legs_description, # received in OpenOrder for all combos
+
+           :multiplier => :i,
+           # Future/option contract multiplier (only needed when multiple possibilities exist)
+
+           :primary_exchange =>
+               # non-aggregate (ie not the SMART) exchange that the contract trades on.
+               proc { |val|
+                 val.upcase! if val.is_a?(String)
+                 raise(ArgumentError.new("Don't set primary_exchange to smart")) if val == 'SMART'
+                 self[:primary_exchange] = val
+               },
+
+           :right => # Specifies a Put or Call. Valid input values are: P, PUT, C, CALL
+               proc { |val|
+                 self[:right] =
+                     case val.to_s.upcase
+                       when '', '0', '?'
+                         nil
+                       when 'PUT', 'P'
+                         'PUT'
+                       when 'CALL', 'C'
+                         'CALL'
+                       else
+                         raise ArgumentError.new("Invalid right '#{val}' (must be one of PUT, CALL, P, C)")
+                     end
+               },
+
+           :expiry => # The expiration date. Use the format YYYYMM.
+               proc { |val|
+                 self[:expiry] =
+                     case val.to_s
+                       when /\d{6,8}/
+                         val.to_s
+                       when nil, ''
+                         nil
+                       else
+                         raise ArgumentError.new("Invalid expiry '#{val}' (must be in format YYYYMM or YYYYMMDD)")
+                     end
+               },
+
+           :sec_type => # Security type. Valid values are: SECURITY_TYPES
+               proc { |val|
+                 val = nil if !val.nil? && val.empty?
+                 unless val.nil? || SECURITY_TYPES.values.include?(val)
+                   raise(ArgumentError.new("Invalid security type '#{val}' (must be one of #{SECURITY_TYPES.values}"))
+                 end
+                 self[:sec_type] = val
+               }
 
       # ContractDetails fields are bundled into Contract proper, as it should be
       # All fields Strings, unless specified otherwise:
-      attr_accessor :summary, # NB: ContractDetails reference - to self!
-                    :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, # Typically the contract month of the underlying for
-                    #                  a 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, # The ID of the time zone for the trading hours of the
-                    #             product. For example, 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 credit rating generally
-                    #           indicates a 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.
-                    :callable, # bool: Can be called by the issuer under certain conditions.
-                    :puttable, # bool: Can be sold back to the issuer under certain conditions
-                    :coupon, # double: The interest rate used to calculate the amount you
-                    #          will receive in interest payments over the year. default 0
-                    :convertible, # bool: Can be converted to stock under certain conditions.
-                    :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.
-                    :next_option_partial, # bool: # only if bond has embedded options.
-                    :notes # Additional notes, if populated for the bond in IB's database
+      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 for a 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 for the trading hours of the product. For example, 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.
+           :callable, # bool: Can be called by the issuer under certain conditions.
+           :puttable, # bool: Can be sold back to the issuer under certain conditions
+           :coupon, # double: The interest rate used to calculate the amount you
+           #          will receive in interest payments over the year. default 0
+           :convertible, # bool: Can be converted to stock under certain conditions.
+           :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.
+           :next_option_partial, # bool: # only if bond has embedded options.
+           :notes # Additional notes, if populated for the bond in IB's database
 
       # Used for Delta-Neutral Combo contracts only!
       # UnderComp fields are bundled into Contract proper, as it should be.
-      attr_accessor :under_comp, # if not nil, attributes below are sent to server
-                    #:under_con_id is is already defined in ContractDetails section
-                    :under_delta, # double: The underlying stock or future delta.
-                    :under_price #  double: The price of the underlying.
+      prop :under_comp, # if not nil, attributes below are sent to server
+           #:under_con_id is is already defined in ContractDetails section
+           :under_delta, # double: The underlying stock or future delta.
+           :under_price #  double: The price of the underlying.
 
       attr_accessor :description # NB: local to ib-ruby, not part of TWS.
 
-      alias combo_legs legs
-      alias combo_legs= legs=
-      alias combo_legs_description legs_description
-      alias combo_legs_description= legs_description=
-
-      def initialize opts = {}
-        # Assign defaults to properties first!
-        @con_id = 0
-        @strike = 0
-        @sec_type = ''
-        @exchange = 'SMART'
-        @include_expired = false
-        @legs = Array.new
-
-        # These properties are from ContractDetails
-        @under_con_id = 0
-        @min_tick = 0
-        @callable = false
-        @puttable = false
-        @coupon = 0
-        @convertible = false
-        @next_option_partial = false
-
-        super opts
-      end
-
-      # This property is from ContractDetails
+      DEFAULT_PROPS = {:con_id => 0,
+                       :strike => 0,
+                       :exchange => 'SMART',
+                       :include_expired => false,
+
+                       # These properties are from ContractDetails
+                       :under_con_id => 0,
+                       :min_tick => 0,
+                       :callable => false,
+                       :puttable => false,
+                       :coupon => 0,
+                       :convertible => false,
+                       :next_option_partial => false, }
+
+      # NB: ContractDetails reference - to self!
       def summary
         self
       end
 
-      # some protective filters
-      def primary_exchange= x
-        x.upcase! if x.is_a?(String)
-
-        # per http://chuckcaplan.com/twsapi/index.php/Class%20Contract
-        raise(ArgumentError.new("Don't set primary_exchange to smart")) if x == 'SMART'
-
-        @primary_exchange = x
-      end
-
-      def right= x
-        @right =
-            case x.to_s.upcase
-              when '', '0', '?'
-                nil
-              when 'PUT', 'P'
-                'PUT'
-              when 'CALL', 'C'
-                'CALL'
-              else
-                raise ArgumentError.new("Invalid right '#{x}' (must be one of PUT, CALL, P, C)")
-            end
-      end
-
-      def expiry= x
-        @expiry =
-            case x.to_s
-              when /\d{6,8}/
-                x.to_s
-              when ''
-                nil
-              else
-                raise ArgumentError.new("Invalid expiry '#{x}' (must be in format YYYYMM or YYYYMMDD)")
-            end
-      end
-
-      def sec_type= x
-        x = nil if !x.nil? && x.empty?
-        raise(ArgumentError.new("Invalid security type '#{x}' (must be one of #{SECURITY_TYPES.values}")) unless x.nil? || SECURITY_TYPES.values.include?(x)
-        @sec_type = x
-      end
-
-      def multiplier= x
-        @multiplier = x.to_i
-      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.
@@ -225,22 +200,6 @@ module IB
         serialize :option, *fields
       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:security_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 version
-        serialize.join(":")
-      end
-
       # Serialize under_comp parameters
       def serialize_under_comp *args
         # EClientSocket.java, line 471:
@@ -254,27 +213,25 @@ module IB
         end
       end
 
-      ### Leg-related methods (better suited to BAG subclass?)
-
-      # Some messages send open_close too, some don't. WTF.
-      # "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.
+      # Redefined in BAG subclass
       def serialize_legs *fields
-        return [] unless sec_type.upcase == "BAG"
-        return [0] if legs.empty? || legs.nil?
-        [legs.size, legs.map { |leg| leg.serialize *fields }]
-      end
-
-      # Check if two Contracts have same legs (maybe in different order)
-      def same_legs? other
-        legs == other.legs ||
-            legs_description.split(',').sort == other.legs_description.split(',').sort
+        []
       end
 
-      # IB-equivalent leg description. TODO: Rewrite with self[:legs_description]
-      def legs_description
-        @legs_description || legs.map { |leg| "#{leg.con_id}|#{leg.weight}" }.join(',')
+      # 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:security_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 version
+        serialize.join(":")
       end
 
       # Contract comparison
@@ -296,9 +253,6 @@ module IB
         # Different currency
         return false if currency && other.currency && currency != other.currency
 
-        # Different legs
-        return false unless same_legs? other
-
         # 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 &&

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

@@ -5,54 +5,36 @@ module IB
     # This is IB Order execution report.
     # Instantiate with a Hash of attributes, to be auto-set via initialize in Model.
     class Execution < Model
-      attr_accessor :order_id, #      int: order id. TWS orders have a fixed order id of 0.
-                    :client_id, #     int: id of the client that placed the order.
-                    #                      TWS orders have a fixed client id of 0.
-                    :exec_id, #       String: Unique order execution id.
-                    :time, #          String: The order execution time.
-                    :account_name, #String: The customer account number.
-                    :exchange, #      String: Exchange that executed the order.
-                    :side, #          String: Was the transaction a buy or a sale: BOT|SLD
-                    :shares, #        int: The number of shares filled.
-                    :price, #         double: The order execution price.
-                    :perm_id, #       int: TWS id used to identify orders, remains
-                    #                      the same over TWS sessions.
-                    :liquidation, #   int: Identifies the position as one to be liquidated
-                    #                      last should the need arise.
-                    :cumulative_quantity, # int: Cumulative quantity. Used in regular
-                    #                           trades, combo trades and legs of the combo
-                    :average_price #  double: Average price. Used in regular trades, combo
-                                   #          trades and legs of the combo.
-      # Legacy
-      alias account_number account_name
-      alias account_number= account_name=
+      prop :order_id, #     int: order id. TWS orders have a fixed order id of 0.
+           :client_id, #    int: id of the client that placed the order.
+           #                     TWS orders have a fixed client id of 0.
+           :perm_id, #      int: TWS id used to identify orders, remains
+           :exec_id, #      String: Unique order execution id.
+           #                      the same over TWS sessions.
+           :time, #         String: The order execution time.
+           :exchange, #     String: Exchange that executed the order.
+           :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.
+           :cumulative_quantity, # int: Cumulative quantity. Used in regular
+           #                            trades, combo trades and legs of the combo
+           :liquidation, #  int: This position is liquidated last should the need arise.
+           [:account_name, :account_number], # String: The customer account number.
+           :side => #     String: Was the transaction a buy or a sale: BOT|SLD
+               {:set => proc { |val| self[:side] = val.to_s.upcase[0..0] == 'B' ? :buy : :sell }}
 
-      def side= value
-        @side = case value
-                  when 'BOT'
-                    :BUY
-                  when 'SLD'
-                    :SELL
-                  else
-                    value
-                end
-      end
-
-      def initialize opts = {}
-        @order_id = 0
-        @client_id = 0
-        @shares = 0
-        @price = 0
-        @perm_id = 0
-        @liquidation = 0
-
-        super opts
-      end
+      DEFAULT_PROPS = {:order_id => 0,
+                       :client_id => 0,
+                       :shares => 0,
+                       :price => 0,
+                       :perm_id => 0,
+                       :liquidation => 0, }
 
       def to_s
-        "<Execution #{@time}: #{@side} #{@shares} @ #{@price} on #{@exchange}, " +
-            "cumulative: #{@cumulative_quantity} @ #{@average_price}, " +
-            "ids: #{@order_id} order, #{@perm_id} perm, #{@exec_id} exec>"
+        "<Execution #{time}: #{side} #{shares} @ #{price} on #{exchange}, " +
+            "cumulative: #{cumulative_quantity} @ #{average_price}, " +
+            "ids: #{order_id} order, #{perm_id} perm, #{exec_id} exec>"
       end
     end # Execution
   end # module Models

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

@@ -1,27 +1,33 @@
+require 'ib-ruby/models/model_properties'
+
 module IB
   module Models
 
     # Base IB data Model class, in future it will be developed into ActiveModel
     class Model
+      extend ModelProperties
+
       attr_reader :created_at
 
+      DEFAULT_PROPS = {}
+
       # 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={})
         raise ArgumentError.new("Argument must be a Hash") unless opts.is_a?(Hash)
         @created_at = Time.now
 
-        opts.keys.each { |key| self.send("#{key}=", opts[key]) }
+        props = self.class::DEFAULT_PROPS.merge(opts)
+        props.keys.each { |key| self.send("#{key}=", props[key]) }
       end
 
       # ActiveModel-style attribute accessors
       def [] key
-        self.send key
+        instance_variable_get "@#{key}".to_sym
       end
 
       def []= key, val
-        self.send "#{key}=", val
+        instance_variable_set "@#{key}".to_sym, val
       end
 
     end # Model

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

@@ -0,0 +1,63 @@
+module IB
+  module Models
+
+    # Module adding prop macro
+    module ModelProperties
+
+      def prop *properties
+        prop_hash = properties.last.is_a?(Hash) ? properties.pop : {}
+
+        properties.each { |names| define_property names, '' }
+        prop_hash.each { |names, type| define_property names, type }
+      end
+
+      def define_property names, body
+        aliases = [names].flatten
+        name = aliases.shift
+        instance_eval do
+
+          define_property_methods name, body
+
+          aliases.each do |ali|
+            alias_method "#{ali}", name
+            alias_method "#{ali}=", "#{name}="
+          end
+        end
+      end
+
+      def define_property_methods name, body={}
+        #p name, body
+        case body
+          when '' # default getter and setter
+            define_property_methods name
+          when Proc # setter
+            define_property_methods name, :set => body
+          when Array # [setter, getter, validators]
+            define_property_methods name,
+                                    :get => body[0],
+                                    :set => body[1],
+                                    :validate => body[2]
+          when Hash # recursion ends HERE!
+            define_method(name, &body[:get] || proc { self[name] })
+
+            define_method("#{name}=", &body[:set] || proc { |value| self[name] = value })
+
+            [body[:validate]].flatten.compact.each do |validator|
+              case validator
+                when Proc
+                  validates_each name, &validator
+                when Hash
+                  validates name, validator
+              end
+
+            end
+          else
+            define_property_methods name, :set =>
+                proc { |value| self[name] = value.send "to_#{body}" }
+        end
+      end
+
+    end # module ModelProperties
+  end
+end
+