ib-ruby 0.7.4 → 0.7.6

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

@@ -1,13 +1,12 @@
-require 'ib-ruby/models/model'
-
 module IB
   module Models
     module Contracts
-      class Contract < Model
+      class Contract < Model.for(:contract)
+        include ModelProperties
 
         # This returns a Contract initialized from the serialize_ib_ruby format string.
         def self.build opts = {}
-          Contracts::TYPES[opts[:sec_type]].new opts
+          Contracts::TYPES[VALUES[:sec_type][opts[:sec_type]]].new opts
         end
 
         # This returns a Contract initialized from the serialize_ib_ruby format string.
@@ -21,14 +20,11 @@ module IB
 
         # Fields are Strings unless noted otherwise
         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
+             :sec_type,
              :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
@@ -45,57 +41,39 @@ module IB
              #                  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,
+             :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 => :i,
 
-             :primary_exchange =>
-                 # non-aggregate (ie not the SMART) exchange that the contract trades on.
-                 proc { |val|
-                   val.upcase! if val.is_a?(String)
-                   error "Don't set primary_exchange to smart", :args if val == 'SMART'
-                   self[:primary_exchange] = val
-                 },
+             :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.
 
-             :right => # Specifies a Put or Call. Valid input values are: P, PUT, C, CALL
-                 proc { |val|
+             # 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 '', '0', '?'
-                           nil
+                         when 'NONE', '', '0', '?'
+                           ''
                          when 'PUT', 'P'
-                           'PUT'
+                           'P'
                          when 'CALL', 'C'
-                           'CALL'
-                         else
-                           error "Right must be one of PUT, CALL, P, C - not '#{val}'", :args
-                       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
+                           'C'
                          else
-                           error "Invalid expiry '#{val}' (must be in format YYYYMM or YYYYMMDD)", :args
-                       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)
-                     error "Invalid security type '#{val}' (must be one of #{SECURITY_TYPES.values}", :args
-                   end
-                   self[:sec_type] = val
+                           val
+                       end },
+                  :validate => {:format => {:with => /^put$|^call$|^none$/,
+                                            :message => "should be put, call or none"}}
                  }
 
+        # Security type. Valid values are: SECURITY_TYPES
+
         # ContractDetails fields are bundled into Contract proper, as it should be
         # All fields Strings, unless specified otherwise:
         prop :market_name, # The market name for this contract.
@@ -128,17 +106,17 @@ module IB
              :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
+             :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.
 
         # Used for Delta-Neutral Combo contracts only!
         # UnderComp fields are bundled into Contract proper, as it should be.
@@ -156,18 +134,27 @@ module IB
 
         attr_accessor :description # NB: local to ib-ruby, not part of TWS.
 
+        # 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"
+
         DEFAULT_PROPS = {:con_id => 0,
-                         :strike => 0,
+                         :strike => 0.0,
+                         :right => :none, # Not an option
                          :exchange => 'SMART',
-                         :include_expired => false,
-
-                         # These properties are from ContractDetails
                          :under_con_id => 0,
                          :min_tick => 0,
+                         :coupon => 0,
                          :callable => false,
                          :puttable => false,
-                         :coupon => 0,
                          :convertible => false,
+                         :include_expired => false,
                          :next_option_partial => false, }
 
         # NB: ContractDetails reference - to self!
@@ -181,8 +168,12 @@ module IB
         def serialize *fields
           [(fields.include?(:con_id) ? [con_id] : []),
            symbol,
-           sec_type,
-           (fields.include?(:option) ? [expiry, strike, right, multiplier] : []),
+           self[:sec_type],
+           (fields.include?(:option) ?
+               [expiry,
+                strike,
+                self[:right],
+                multiplier] : []),
            exchange,
            (fields.include?(:primary_exchange) ? [primary_exchange] : []),
            currency,
@@ -213,9 +204,16 @@ module IB
           end
         end
 
-        # Redefined in BAG subclass
+        # 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
@@ -263,12 +261,12 @@ module IB
               exchange && other.exchange && exchange != other.exchange
 
           # Comparison for Bonds and Options
-          if sec_type == SECURITY_TYPES[:bond] || sec_type == SECURITY_TYPES[:option]
+          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[0..5] != other.expiry[0..5]
-            return false unless expiry[6..7] == other.expiry[6..7] ||
-                expiry[6..7].empty? || other.expiry[6..7].empty?
+            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...
@@ -283,13 +281,39 @@ module IB
         end
 
         def to_human
-          "<Contract: " + [symbol, sec_type, expiry, strike, right, exchange, currency].join("-") + ">"
+          "<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
     end # module Contracts
   end # module Models

data/lib/ib-ruby/models/contracts/option.rb

@@ -5,6 +5,14 @@ module IB
     module Contracts
       class Option < Contract
 
+        validates_numericality_of :strike, :greater_than => 0
+        validates_format_of :sec_type, :with => /^option$/,
+                            :message => "should be an option"
+        validates_format_of :local_symbol, :with => /^\w+\s*\d{15}$|^$/,
+                            :message => "invalid OSI code"
+        validates_format_of :right, :with => /^put$|^call$/,
+                            :message => "should be put or call"
+
         # For Options, this is contract's OSI (Option Symbology Initiative) name/code
         alias osi local_symbol
 
@@ -16,8 +24,8 @@ module IB
         # Make valid IB Contract definition from OSI (Option Symbology Initiative) code.
         # NB: Simply making a new Contract with *local_symbol* (osi) property set to a
         # valid OSI code works just as well, just do NOT set *expiry*, *right* or
-        # *strike* properties at the same time.
-        # This class method provided as a backup, to show how to analyse OSI codes.
+        # *strike* properties in this case.
+        # This class method provided as a backup and shows how to analyse OSI codes.
         def self.from_osi osi
 
           # Parse contract's OSI (OCC Option Symbology Initiative) code
@@ -32,25 +40,26 @@ module IB
 
           # Set correct expiry date - IB expiry date differs from OSI if expiry date
           # falls on Saturday (see https://github.com/arvicco/option_mower/issues/4)
-          expiry_date = Time.new(year, month, day)
-          expiry_date = Time.new(year, month, day-1) if expiry_date.saturday?
+          expiry_date = Time.utc(year, month, day)
+          expiry_date = Time.utc(year, month, day-1) if expiry_date.wday == 6
 
           new :symbol => symbol,
               :exchange => "SMART",
-              :expiry => expiry_date.to_ib,
+              :expiry => expiry_date.to_ib[2..7], # YYMMDD
               :right => right,
               :strike => strike
         end
 
         def initialize opts = {}
           super opts
-          self[:sec_type] = IB::SECURITY_TYPES[:option]
+          self.sec_type = 'OPT'
           self[:description] ||= osi ? osi : "#{symbol} #{strike} #{right} #{expiry}"
         end
 
         def to_human
-          "<Option: " + [symbol, expiry, right, strike, exchange, currency].join("-") + ">"
+          "<Option: " + [symbol, expiry, right, strike, exchange, currency].join(" ") + ">"
         end
+
       end # class Option
     end # class Contract
   end # module Models

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

@@ -1,29 +1,30 @@
-require 'ib-ruby/models/model'
-
 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
+    class Execution < Model.for(:execution)
+      include ModelProperties
+
       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.
+           :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
+           [: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.
            :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.
-           :order_ref, #  int: Same order_ref as in corresponding Order
-           [: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 }}
+           :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
+
+      # Extra validations
+      validates_numericality_of :shares, :cumulative_quantity, :price, :average_price
 
       DEFAULT_PROPS = {:order_id => 0,
                        :client_id => 0,
@@ -31,12 +32,27 @@ module IB
                        :price => 0,
                        :perm_id => 0,
                        :liquidation => 0, }
+      # Comparison
+      def == other
+        perm_id == other.perm_id &&
+            order_id == other.order_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_s
-        "<Execution #{time}: #{side} #{shares} @ #{price} on #{exchange}, " +
-            "cumulative: #{cumulative_quantity} @ #{average_price}, " +
-            "order: #{order_id}/#{perm_id}#{order_ref}, exec: #{exec_id}>"
+      def to_human
+        "<Execution: #{time} #{side} #{shares} at #{price} on #{exchange}, " +
+            "cumulative #{cumulative_quantity} at #{average_price}, " +
+            "ids #{order_id}/#{perm_id}/#{exec_id}>"
       end
+
+      alias to_s to_human
+
     end # Execution
   end # module Models
 end # module IB

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

@@ -1,21 +1,29 @@
-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 = {}
+      # IB Models can be either database-backed, or not
+      # require 'ib-ruby/db' # to make IB models database-backed
+      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
+        else
+          Model
+        end
+      end
 
       # 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)
-        @created_at = Time.now
 
         props = self.class::DEFAULT_PROPS.merge(opts)
         props.keys.each { |key| self.send("#{key}=", props[key]) }

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

@@ -1,63 +1,120 @@
+require 'active_model'
+require 'active_support/concern'
+
 module IB
   module Models
 
-    # Module adding prop macro
+    # Module adds prop Macro and
     module ModelProperties
+      extend ActiveSupport::Concern
+
+      DEFAULT_PROPS = {}
 
-      def prop *properties
-        prop_hash = properties.last.is_a?(Hash) ? properties.pop : {}
+      ### Instance methods
 
-        properties.each { |names| define_property names, '' }
-        prop_hash.each { |names, type| define_property names, type }
+      attr_accessor :created_at
+
+      def initialize opts={}
+        @created_at = Time.now
+        super self.class::DEFAULT_PROPS.merge(opts)
       end
 
-      def define_property names, body
-        aliases = [names].flatten
-        name = aliases.shift
-        instance_eval do
+      included do
+
+        ### Class macros
+
+        def self.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 self.define_property names, body
+          aliases = [names].flatten
+          name = aliases.shift
+          instance_eval do
 
-          define_property_methods name, body
+            define_property_methods name, body
 
-          aliases.each do |ali|
-            alias_method "#{ali}", name
-            alias_method "#{ali}=", "#{name}="
+            aliases.each do |ali|
+              alias_method "#{ali}", name
+              alias_method "#{ali}=", "#{name}="
+            end
           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
+        def self.define_property_methods name, body={}
+          #p name, body
+          case body
+            when '' # default getter and setter
+              define_property_methods name
+
+            when Array # [setter, getter, validators]
+              define_property_methods name,
+                                      :get => body[0],
+                                      :set => body[1],
+                                      :validate => body[2]
+
+            when Hash # recursion base case
+
+              getter = case # Define getter
+                         when body[:get].respond_to?(:call)
+                           body[:get]
+                         when body[:get]
+                           proc { self[name].send "to_#{body[:get]}" }
+                         when VALUES[name] # property is encoded
+                           proc { VALUES[name][self[name]] }
+                         else
+                           proc { self[name] }
+                       end
+              define_method name, &getter
+
+              setter = case # Define setter
+                         when body[:set].respond_to?(:call)
+                           body[:set]
+                         when body[:set]
+                           proc { |value| self[name] = value.send "to_#{body[:set]}" }
+                         when CODES[name] # property is encoded
+                           proc { |value| self[name] = CODES[name][value] || value }
+                         else
+                           proc { |value| self[name] = value }
+                       end
+              define_method "#{name}=", &setter
+
+              # Define validator(s)
+              [body[:validate]].flatten.compact.each do |validator|
+                case validator
+                  when Proc
+                    validates_each name, &validator
+                  when Hash
+                    validates name, validator.dup
+                end
               end
 
-            end
-          else
-            define_property_methods name, :set =>
-                proc { |value| self[name] = value.send "to_#{body}" }
+            # TODO define self[:name] accessors for :virtual and :flag properties
+
+            else # setter given
+              define_property_methods name, :set => body
+          end
         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
+            []
+          end
+        end
+
+      end # included
     end # module ModelProperties
-  end
+  end # module Models
 end
-