ib-ruby 0.7.11 → 0.7.12

data/HISTORY

@@ -181,3 +181,7 @@
 == 0.7.11 / 2012-04-25
 
 * DB schema extended
+
+== 0.7.12 / 2012-04-27
+
+* ComboLeg is a join Model

data/VERSION

@@ -1 +1 @@
-0.7.11
+0.7.12

data/db/migrate/121_add_order_states.rb

@@ -13,15 +13,15 @@ class AddOrderStates < ActiveRecord::Migration
       t.integer :remaining
       t.float :price #     double
       t.float :average_price #  double
-      t.float :init_margin # Float: The impact the order would have on your initial margin.
-      t.float :maint_margin # Float: The impact the order would have on your maintenance margin.
-      t.float :equity_with_loan # Float: The impact the order would have on your equity
+      t.string :why_held # String: comma-separated list of reasons for order to be held.
+      t.string :warning_text # String: Displays a warning message if warranted.
+      t.string :commission_currency, :limit => 4 # String: Shows the currency of the commission.
       t.float :commission # double: Shows the commission amount on the order.
       t.float :min_commission # The possible min range of the actual order commission.
       t.float :max_commission # The possible max range of the actual order commission.
-      t.string :commission_currency, :limit => 4 # String: Shows the currency of the commission.
-      t.string :why_held # String: comma-separated list of reasons for order to be held.
-      t.string :warning_text # String: Displays a warning message if warranted.
+      t.float :init_margin # Float: The impact the order would have on your initial margin.
+      t.float :maint_margin # Float: The impact the order would have on your maintenance margin.
+      t.float :equity_with_loan # Float: The impact the order would have on your equity
       t.timestamps
     end
   end

data/db/migrate/141_add_combo_legs.rb

@@ -3,15 +3,16 @@ class AddComboLegs < ActiveRecord::Migration
   def change
     # ComboLeg objects represent individual security legs in a "BAG"
     create_table(:combo_legs) do |t|
-      t.references :contract
+      t.references :combo
+      t.references :leg_contract
       t.integer :con_id #  # int: The unique contract identifier specifying the security.
-      t.integer :ratio # int: Select the relative number of contracts for the leg you
-      t.string :exchange # String: exchange to which the complete combo order will be routed.
       t.string :side, :limit => 1 # Action/side: BUY/SELL/SSHORT/SSHORTX
-      t.integer :exempt_code # int:
-      t.integer :short_sale_slot # int: 0 - retail(default), 1 = clearing broker, 2 = third party
+      t.integer :ratio, :limit => 2 # int: Select the relative number of contracts for the leg you
+      t.string :exchange # String: exchange to which the complete combo order will be routed.
+      t.integer :exempt_code, :limit => 2 # int:
+      t.integer :short_sale_slot, :limit => 2 # int: 0 - retail(default), 1 = clearing broker, 2 = third party
+      t.integer :open_close, :limit => 2 #  SAME = 0; OPEN = 1; CLOSE = 2; UNKNOWN = 3
       t.string :designated_location # Otherwise leave blank or orders will be rejected.:status # String: Displays the order status.Possible values include:
-      t.integer :open_close #  SAME = 0; OPEN = 1; CLOSE = 2; UNKNOWN = 3
       t.timestamps
     end
   end

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

@@ -15,15 +15,10 @@ module IB
       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"
-      validate :legs_cannot_be_empty
-
-      def legs_cannot_be_empty
-        errors.add(:legs, "legs cannot be empty") if legs.empty?
-      end
 
       def default_attributes
-        super.merge :legs => Array.new,
-                    :sec_type => :bag
+        super.merge :sec_type => :bag #,:legs => Array.new,
+
       end
 
       def description

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

@@ -1,13 +1,15 @@
 module IB
   module Models
 
-    # ComboLeg objects represent individual securities in a "BAG" contract - which
-    # is not really a contract, but a combination (combo) of securities. AKA basket
-    # or bag of securities.
+    # 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
 
-      belongs_to :contract
+      # 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.
@@ -40,6 +42,8 @@ module IB
 
       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 => '',

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

@@ -49,14 +49,14 @@ module IB
                {:set => proc { |val|
                  self[:right] =
                      case val.to_s.upcase
-                       when 'NONE', '', '0', '?'
-                         ''
-                       when 'PUT', 'P'
-                         'P'
-                       when 'CALL', 'C'
-                         'C'
-                       else
-                         val
+                     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"}}
@@ -70,13 +70,20 @@ module IB
 
       has_one :contract_detail # Volatile info about this Contract
 
-      has_many :combo_legs # for Combo/BAG Contracts only
+      # 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=
 
-      has_one :underlying # for Delta-Neutral Combo Contracts only
+      # for Delta-Neutral Combo Contracts
+      has_one :underlying
       alias under_comp underlying
       alias under_comp= underlying=
 
@@ -142,12 +149,12 @@ module IB
       # 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
+        when !bag?
+          []
+        when legs.empty?
+          [0]
+        else
+          [legs.size, legs.map { |leg| leg.serialize *fields }].flatten
         end
       end
 

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

@@ -25,11 +25,11 @@ module IB
 
       # 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={}
+      def initialize attributes={}, opts={}
         run_callbacks :initialize do
-          error "Argument must be a Hash", :args unless opts.is_a?(Hash)
+          error "Argument must be a Hash", :args unless attributes.is_a?(Hash)
 
-          self.attributes = default_attributes.merge(opts)
+          self.attributes = default_attributes.merge(attributes)
         end
       end
 

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

@@ -75,65 +75,65 @@ module IB
         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]] }
-                            #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 if 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 } # p name, value;
-                       end
-              define_method "#{name}=", &setter if 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
+          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]] }
+                          #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 if 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 } # p name, value;
+                     end
+            define_method "#{name}=", &setter if 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
 
             # TODO define self[:name] accessors for :virtual and :flag properties
 
-            else # setter given
-              define_property_methods name, :set => body, :get => body
+          else # setter given
+            define_property_methods name, :set => body, :get => body
           end
         end
 
         # Extending AR-backed Model class with attribute defaults
         if defined?(ActiveRecord::Base) && ancestors.include?(ActiveRecord::Base)
-          def initialize opts={}
-            super default_attributes.merge(opts)
+          def initialize attributes={}, opts={}
+            super default_attributes.merge(attributes), opts
           end
         else
           # Timestamps

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

@@ -7,7 +7,7 @@ module IB
       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}$|^$/,
+      validates_format_of :local_symbol, :with => /^\w+\s*\d{6}[pcPC]\d{8}$|^$/,
                           :message => "invalid OSI code"
       validates_format_of :right, :with => /^put$|^call$/,
                           :message => "should be put or call"

data/spec/db_helper.rb

@@ -32,11 +32,13 @@ shared_examples_for 'Valid DB-backed Model' do
     end
 
     it 'and with the same properties' do
-      model = described_class.find(:first)
-      #p model.attributes
-      #p model.content_attributes
-      props.each do |name, value|
-        model.send(name).should == value
+      if init_with_props?
+        model = described_class.find(:first)
+        #p model.attributes
+        #p model.content_attributes
+        props.each do |name, value|
+          model.send(name).should == value
+        end
       end
     end
 
@@ -75,79 +77,80 @@ end
 shared_examples_for 'Model with associations' do
 
   it 'works with associations, if any' do
-    if defined? associations
 
-      subject_name_plural = described_class.to_s.demodulize.tableize
+    subject_name_plural = described_class.to_s.demodulize.tableize
 
-      associations.each do |name, item|
-        puts "Testing single association #{name}"
-        subject.association(name).reflection.should_not be_collection
+    associations.each do |name, item_props|
+      item = "IB::Models::#{name.to_s.classify}".constantize.new item_props
+      #item = const_get("IB::#{name.to_s.classify}").new item_props
+      puts "Testing single association #{name}"
+      subject.association(name).reflection.should_not be_collection
 
-        # Assign item to association
-        expect { subject.send "#{name}=", item }.to_not raise_error
+      # Assign item to association
+      expect { subject.send "#{name}=", item }.to_not raise_error
 
-        association = subject.send name #, :reload
-        association.should == item
-        association.should be_new_record
+      association = subject.send name #, :reload
+      association.should == item
+      association.should be_new_record
 
-        # Reverse association does not include subject
-        reverse_association = association.send(subject_name_plural)
-        reverse_association.should be_empty
+      # Reverse association does not include subject
+      reverse_association = association.send(subject_name_plural)
+      reverse_association.should be_empty
 
-        # Now let's save subject
-        if subject.valid?
-          subject.save
+      # Now let's save subject
+      if subject.valid?
+        subject.save
 
-          association = subject.send name
-          association.should_not be_new_record
+        association = subject.send name
+        association.should_not be_new_record
 
-          # Reverse association now DOES include subject (if reloaded!)
-          reverse_association = association.send(subject_name_plural, :reload)
-          reverse_association.should include subject
-        end
+        # Reverse association now DOES include subject (if reloaded!)
+        reverse_association = association.send(subject_name_plural, :reload)
+        reverse_association.should include subject
       end
     end
   end
 
   it 'works with associated collections, if any' do
-    if defined? collections
-
-      subject_name = described_class.to_s.demodulize.tableize.singularize
+    subject_name = described_class.to_s.demodulize.tableize.singularize
 
-      collections.each do |name, items|
-        puts "Testing associated collection #{name}"
-        subject.association(name).reflection.should be_collection
+    collections.each do |name, items|
+      puts "Testing associated collection #{name}"
+      subject.association(name).reflection.should be_collection
 
-        [items].flatten.each do |item|
-          association = subject.send name #, :reload
+      [items].flatten.each do |item_props|
+        item = "IB::Models::#{name.to_s.classify}".constantize.new item_props
+        #item = item_class.new item_props
+        association = subject.send name #, :reload
 
-          # Add item to collection
-          expect { association << item }.to_not raise_error
-          association.should include item
+        # Add item to collection
+        expect { association << item }.to_not raise_error
+        association.should include item
 
-          # Reverse association does NOT point to subject
-          reverse_association = association.first.send(subject_name)
-          #reverse_association.should be_nil # But not always!
+        # Reverse association does NOT point to subject
+        reverse_association = association.first.send(subject_name)
+        #reverse_association.should be_nil # But not always!
 
-          #association.size.should == items.size # Not for Order, +1 OrderState
-        end
+        #association.size.should == items.size # Not for Order, +1 OrderState
+      end
 
-        # Now let's save subject
-        if subject.valid?
-          subject.save
+      # Now let's save subject
+      if subject.valid?
+        subject.save
 
-          [items].flatten.each do |item|
-            association = subject.send name #, :reload
+        [items].flatten.each do |item_props|
+          item = "IB::Models::#{name.to_s.classify}".constantize.new item_props
+          association = subject.send name #, :reload
 
-            association.should include item
+          association.should include item
 
-            # Reverse association DOES point to subject now
-            reverse_association = association.first.send(subject_name)
-            reverse_association.should == subject
-          end
+          # Reverse association DOES point to subject now
+          reverse_association = association.first.send(subject_name)
+          reverse_association.should == subject
         end
-
       end
     end
   end
+
+
 end

data/spec/ib-ruby/models/bag_spec.rb

@@ -1,69 +1,56 @@
 require 'model_helper'
 
-describe IB::Models::Bag do # AKA IB::Bag
-
-  let(:props) do
-    {:symbol => 'GOOG',
-     :exchange => 'SMART',
-     :currency => 'USD',
-     :legs => [IB::ComboLeg.new(:con_id => 81032967, :weight => 1),
-               IB::ComboLeg.new(:con_id => 81032968, :weight => -2),
-               IB::ComboLeg.new(:con_id => 81032973, :weight => 1)]
-    }
-  end
+describe IB::Models::Bag,
 
-  let(:human) do
-    "<Bag: GOOG SMART USD legs: 81032967|1,81032968|-2,81032973|1 >"
-  end
+         :props =>
+             {:symbol => 'GOOG',
+              :exchange => 'SMART',
+              :currency => 'USD',
+              :legs => [IB::ComboLeg.new(:con_id => 81032967, :weight => 1),
+                        IB::ComboLeg.new(:con_id => 81032968, :weight => -2),
+                        IB::ComboLeg.new(:con_id => 81032973, :weight => 1)]
+             },
 
-  let(:errors) do
-    {:legs => ["legs cannot be empty"],
-    }
-  end
+         :human => "<Bag: GOOG SMART USD legs: 81032967|1,81032968|-2,81032973|1 >",
 
-  let(:assigns) do
-    {:expiry =>
-         {[nil, ''] => '',
-          [20060913, '20060913', 200609, '200609', :foo, 2006, 42, 'bar'] =>
-              /should be blank/},
+         :errors =>
+             {:legs => ["legs cannot be empty"]},
 
-     :sec_type =>
-         {['BAG', :bag] => :bag,
-          IB::CODES[:sec_type].reject { |k, _| k == :bag }.to_a =>
-              /should be a bag/},
+         :assigns =>
+             {:expiry =>
+                  {[nil, ''] => '',
+                   [20060913, '20060913', 200609, '200609', 2006, :foo, 'bar'] =>
+                       /should be blank/},
 
-     :right =>
-         {['?', :none, '', '0'] => :none,
-          ["PUT", :put, "CALL", "C", :call, :foo, 'BAR', 42] =>
-              /should be none/},
+              :sec_type =>
+                  {['BAG', :bag] => :bag,
+                   IB::CODES[:sec_type].reject { |k, _| k == :bag }.to_a =>
+                       /should be a bag/},
 
-     :exchange => string_upcase_assigns.merge(
-         [:smart, 'SMART', 'smArt'] => 'SMART'),
+              :right =>
+                  {['?', :none, '', '0'] => :none,
+                   ["PUT", :put, "CALL", "C", :call, :foo, 'BAR', 42] =>
+                       /should be none/},
 
-     :primary_exchange =>string_upcase_assigns.merge(
-         [:SMART, 'SMART'] => /should not be SMART/),
+              :exchange => string_upcase_assigns.merge(
+                  [:smart, 'SMART', 'smArt'] => 'SMART'),
 
-     [:symbol, :local_symbol] => string_assigns,
+              :primary_exchange =>string_upcase_assigns.merge(
+                  [:SMART, 'SMART'] => /should not be SMART/),
 
-     :multiplier => to_i_assigns,
-    }
-  end
+              [:symbol, :local_symbol] => string_assigns,
 
-  it 'does not allow empty legs' do
-    bag = IB::Bag.new props
-    bag.legs = []
-    bag.should be_invalid
-    bag.errors.messages[:legs].should include "legs cannot be empty"
-  end
+              :multiplier => to_i_assigns,
+             } do # AKA IB::Bag
 
-  context 'using shortest class name without properties' do
-    subject { IB::Bag.new }
-    it_behaves_like 'Model instantiated empty'
-  end
-
-  it_behaves_like 'Model'
+  it_behaves_like 'Model with valid defaults'
   it_behaves_like 'Self-equal Model'
 
+  it 'has class name shortcut' do
+    IB::Bag.should == IB::Models::Bag
+    IB::Bag.new.should == IB::Models::Bag.new
+  end
+
   context 'properly initiated' do
     subject { IB::Bag.new props }