ib-ruby 0.7.8 → 0.7.9

data/HISTORY

@@ -169,3 +169,7 @@
 == 0.7.8 / 2012-04-23
 
 * Models are now fully DB-backed
+
+== 0.7.9 / 2012-04-24
+
+* Order and OrderState API extended

data/VERSION

@@ -1 +1 @@
-0.7.8
+0.7.9

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

@@ -27,11 +27,20 @@ module IB
       # 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)
+          attr.to_s =~ /(_count)$/ ||
+              [:created_at, :updated_at, :type,
+               :id, :order_id, :contract_id].include?(attr.to_sym)
         end]
       end
 
+      # Update nil attributes from given Hash or model
+      def update_missing attrs
+        attrs = attrs.content_attributes unless attrs.kind_of?(Hash)
+
+        attrs.each { |attr, val| send "#{attr}=", val if send(attr).blank? }
+        self # for chaining
+      end
+
       # Default Model comparison
       def == other
         content_attributes.inject(true) { |res, (attr, value)| res && other.send(attr) == value } &&
@@ -73,58 +82,58 @@ 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
 

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

@@ -264,7 +264,13 @@ module IB
        :last_fill_price, #    double
        :average_price, # double
        :average_fill_price, # double
-       :why_held # String: comma-separated list of reasons for order to be held.
+       :why_held, # String: comma-separated list of reasons for order to be held.
+       # Testing Order state:
+       :new?,
+       :pending?,
+       :active?,
+       :inactive?,
+       :complete_fill?,
       ].each { |property| define_method(property) { order_state.send(property) } }
 
       # Order is not valid without correct :local_id (:order_id)

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

@@ -63,6 +63,31 @@ module IB
       validates_numericality_of :local_id, :perm_id, :client_id, :parent_id, :filled,
                                 :remaining, :only_integer => true, :allow_nil => true
 
+      ## Testing Order state:
+
+      def new?
+        status.empty? || status == 'New'
+      end
+
+      # Order is in a valid, working state on TWS side
+      def pending?
+        status == 'PendingSubmit' || status == 'PreSubmitted' || status == 'Submitted'
+      end
+
+      # Order is in invalid state
+      def active?
+        new? || pending?
+      end
+
+      # Order is in invalid state
+      def inactive?
+        !active? # status == 'Inactive'
+      end
+
+      def complete_fill?
+        status == 'Filled' && remaining == 0 # filled >= total_quantity # Manually corrected
+      end
+
       # Comparison
       def == other
         other && other.is_a?(OrderState) &&

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

@@ -117,7 +117,30 @@ describe IB::Models::Order do
 
     it 'has extra accessors to OrderState properties' do
       subject.order_state.should_not be_nil
+
       subject.status.should == 'New'
+      subject.commission.should be_nil
+      subject.commission_currency.should be_nil
+      subject.min_commission.should be_nil
+      subject.max_commission.should be_nil
+      subject.warning_text.should be_nil
+      subject.init_margin.should be_nil
+      subject.maint_margin.should be_nil
+      subject.equity_with_loan.should be_nil
+      # Properties arriving via OrderStatus messagesubject.
+      subject.filled.should be_nil
+      subject.remaining.should be_nil
+      subject.price.should be_nil
+      subject.last_fill_price.should be_nil
+      subject.average_price.should be_nil
+      subject.average_fill_price.should be_nil
+      subject.why_held.should be_nil
+      # Testing Order statesubject.
+      subject.should be_new
+      subject.should_not be_pending
+      subject.should be_active
+      subject.should_not be_inactive
+      subject.should_not be_complete_fill
     end
 
     context 'update Order state by ' do

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

@@ -38,7 +38,7 @@ describe IB::Models::OrderState do
   let(:assigns) do
     {[:status] =>
          {[nil, ''] => /must not be empty/,
-          ['Zorro', :Zorro] => 'Zorro' }
+          ['Zorro', :Zorro] => 'Zorro'}
     }
   end
 
@@ -52,4 +52,64 @@ describe IB::Models::OrderState do
   it_behaves_like 'Model'
   it_behaves_like 'Self-equal Model'
 
+  context '#update_missing' do
+    context 'updating with Hash' do
+
+      subject { IB::OrderState.new.update_missing(props) }
+
+      it_behaves_like 'Model instantiated with properties'
+
+    end
+
+    context 'updating with Model' do
+
+      subject { IB::OrderState.new.update_missing(IB::OrderState.new(props)) }
+
+      it_behaves_like 'Model instantiated with properties'
+
+    end
+
+  end
+
+  it 'has extra test methods' do
+    empty_state = IB::OrderState.new
+    empty_state.should be_new
+    empty_state.should be_active
+    empty_state.should_not be_inactive
+    empty_state.should_not be_complete_fill
+
+    state = IB::OrderState.new(props)
+    ['PendingSubmit', 'PreSubmitted', 'Submitted'].each do |status|
+      state.status = status
+      state.should_not be_new
+      state.should be_active
+      state.should_not be_inactive
+      state.should_not be_complete_fill
+      state.should be_pending
+    end
+
+    ['PendingCancel', 'Cancelled', 'ApiCancelled', 'Inactive'].each do |status|
+      state.status = status
+      state.should_not be_new
+      state.should_not be_active
+      state.should be_inactive
+      state.should_not be_complete_fill
+      state.should_not be_pending
+    end
+
+    state.status = 'Filled'
+    state.should_not be_new
+    state.should_not be_active
+    state.should be_inactive
+    state.should_not be_complete_fill
+    state.should_not be_pending
+
+    state.remaining = 0
+    state.should_not be_new
+    state.should_not be_active
+    state.should be_inactive
+    state.should be_complete_fill
+    state.should_not be_pending
+  end
+
 end # describe IB::Order

metadata

@@ -2,7 +2,7 @@
 name: ib-ruby
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.7.8
+  version: 0.7.9
 platform: ruby
 authors: 
   - Paul Legato
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-23 00:00:00 Z
+date: 2012-04-24 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: bundler