ib-api 972.0

data/example/scanner_data

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+#  This Script needs testing.  remove this line after sucessfully using the scanner facility
+#
+# This script setups a scan request and retreives the results.
+
+require 'rubygems'
+require 'bundler/setup'
+require 'ib-api'
+
+
+
+# Connect to IB TWS.
+ib = IB::Connection.new :client_id => 1112 , port: 7496 do | gw | #, :port => 7497 # TWS
+
+
+	# Subscribe to TWS alerts/errors
+	gw.subscribe(:Alert) { |msg| puts msg.to_human }
+
+
+	# Subscribe to ScannerData incoming events.  The code passed in the block
+	# will be executed when a message of that type is received, with the received
+	# message as its argument. In this case, we just print out the data.
+	#
+	gw.subscribe(IB::Messages::Incoming::ScannerData) do |msg|
+		puts "ID: #{msg.request_id} : #{msg.count} items:"
+		msg.results.each { |entry| puts "  #{entry}" }
+	end
+end
+id = 42
+# Now we actually request scanner data for the type of scan we are interested.
+# Some scan types can be found here:  http://www.interactivebrokers.com/php/apiUsersGuide/apiguide/tables/available_market_scanners.htm
+mess = IB::Messages::Outgoing::RequestScannerSubscription.new(
+                    :request_id => id,
+                    :number_of_rows => 20,
+                    :instrument => "STK",
+                    :location_code => 'STK.US.MAJOR',
+                    :scan_code  => 'TOP_PERC_GAIN',
+                    :above_price => 4.0,
+                    :below_price => Float::MAX,
+                    :above_volume => 5000,
+                    :market_cap_above => 100000000,
+                    :market_cap_below =>  Float::MAX,
+                    :moody_rating_above => "",
+                    :moody_rating_below => "",
+                    :sp_rating_above => "",
+                    :sp_rating_below => "",
+                    :maturity_date_above => "",
+                    :maturity_date_below => "",
+                    :coupon_rate_above => Float::MAX,
+                    :coupon_rate_below => Float::MAX,
+                    :exclude_convertible => "",
+                    :average_option_volume_above => "", # ?
+                    :scanner_setting_pairs => "Annual,true",
+                    :stock_type_filter => "Stock"
+                    )
+                    
+ib.send_message( mess )   
+
+# IB does not send any indication when all  data is done being delivered.
+# So we need to interrupt manually when our request is answered.
+puts "\n******** Press <Enter> to exit... *********\n\n"
+STDIN.gets

data/example/template

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+#
+# Your script description here...
+
+require 'bundler/setup'
+require 'ib-api'
+
+# First, connect to IB TWS and subscribe for events. 
+ib = IB::Connection.new :client_id => 1112  do | gw | #, :port => 7497 # TWS
+
+	# Subscribe to TWS alerts/errors
+	gw.subscribe(:Alert, :ManagedAccounts) { |msg| puts msg.to_human }
+	# Set log level
+	gw.logger.level = Logger::FATAL # DEBUG  -- INFO -- WARN -- ERROR  -- FATAL
+
+end
+# Put your code here
+# ...
+

data/example/tick_data

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+# This script reproduces https://github.com/ib-ruby/ib-ruby/issues/12
+
+require 'bundler/setup'
+require 'ib-api'
+
+contract = IB::Stock.new :symbol=> 'AAPL'
+
+# First, connect to IB Gateway.
+ib = IB::Connection.new :client_id => 1112 # id to identify your script
+#                       :port => 7497     # TWS connection (instead of default Gateway)
+#                        :received => false  # Do not keep all received messages in memory
+
+ib.subscribe(:Alert) { |msg| puts msg.to_human }
+ib.subscribe(:MarketDataType) { |msg| puts msg.to_human }
+ib.subscribe(:TickGeneric, :TickString, :TickPrice, :TickSize) { |msg| puts msg.inspect }
+ib.send_message :RequestMarketDataType, :market_data_type => :delayed
+ib.send_message :RequestMarketData, id: 123, contract:  contract
+
+puts "\nSubscribed to market data"
+puts "\n******** Press <Enter> to cancel... *********\n\n"
+gets
+puts "Cancelling market data subscription.."
+
+ib.send_message :CancelMarketData, id: 123
+sleep 1
+puts "Done."

data/lib/extensions/class-extensions.rb

@@ -0,0 +1,87 @@
+module CoreExtensions
+  module Array
+    module DuplicatesCounter
+      def count_duplicates
+        self.each_with_object(Hash.new(0)) { |element, counter| counter[element] += 1 }.sort_by{|k,v| -v}.to_h
+      end
+    end
+  end
+end
+
+Array.include CoreExtensions::Array::DuplicatesCounter
+
+
+
+
+class Time
+  # Render datetime in IB format (zero padded "yyyymmdd HH:mm:ss")
+  def to_ib
+    "#{year}#{sprintf("%02d", month)}#{sprintf("%02d", day)} " +
+        "#{sprintf("%02d", hour)}:#{sprintf("%02d", min)}:#{sprintf("%02d", sec)}"
+  end
+end # Time
+
+class Numeric
+  # Conversion 0/1 into true/false
+  def to_bool
+    self == 0 ? false : true
+  end
+end
+
+class TrueClass
+  def to_bool
+    self
+  end
+end
+
+class FalseClass
+  def to_bool
+    self
+  end
+end
+
+class String
+  def to_bool
+    case self.chomp.upcase
+      when 'TRUE', 'T', '1'
+        true
+      when 'FALSE', 'F', '0', ''
+        false
+      else
+        error "Unable to convert #{self} to bool"
+    end
+  end
+end
+
+class NilClass
+  # We still need to pass on nil, meaning: no value
+  def to_bool
+    self
+  end
+end
+
+class Symbol
+  def to_f
+    0
+  end
+
+  # ActiveModel serialization depends on this method
+  def <=> other
+    to_s <=> other.to_s
+  end
+end
+
+class Object
+  # We still need to pass on nil, meaning: no value
+  def to_sup
+    self.to_s.upcase unless self.nil?
+  end
+end
+
+### Patching Object#error in ib/errors
+#  def error message, type=:standard
+
+### Patching Object#log, #default_logger= in ib/logger
+#  def default_logger
+#  def default_logger= logger
+#  def log *args

data/lib/ib-api.rb

@@ -0,0 +1,7 @@
+module IB
+
+end
+IbRuby = IB
+Ib = IB
+
+require 'requires'

data/lib/ib/base.rb

@@ -0,0 +1,103 @@
+module IB
+
+  # Base class for tableless IB data Models, extends ActiveModel API
+  class Base
+    extend ActiveModel::Naming
+    extend ActiveModel::Callbacks
+    include ActiveModel::Validations
+    include ActiveModel::Serialization
+    #include ActiveModel::Serializers::Xml
+    include ActiveModel::Serializers::JSON
+
+    define_model_callbacks :initialize
+
+    # 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 attributes={}, opts={}
+      run_callbacks :initialize do
+        error "Argument must be a Hash", :args unless attributes.is_a?(Hash)
+
+        self.attributes = attributes # set_attribute_defaults is now after_init callback
+      end
+    end
+
+    # ActiveModel API (for serialization)
+
+    def attributes
+      @attributes ||= Hash.new #HashWithIndifferentAccess.new
+    end
+
+    def attributes= attrs
+      attrs.keys.each { |key| self.send("#{key}=", attrs[key]) }
+    end
+
+    # ActiveModel-style read/write_attribute accessors
+    def [] key
+      attributes[key.to_sym]
+    end
+
+    def update_attribute key, value
+      @attributes[key.to_sym] = value
+    end
+
+    def []= key, val
+      # p key, val
+      attributes[key.to_sym] = val
+    end
+
+    def to_model
+      self
+    end
+
+    def new_record?
+      true
+    end
+
+    def save
+      valid?
+    end
+
+    alias save! save
+
+    ### Noop methods mocking ActiveRecord::Base macros
+    
+    def self.attr_protected *args
+    end
+
+    def self.attr_accessible *args
+    end
+
+    ### 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 IB

data/lib/ib/base_properties.rb

@@ -0,0 +1,160 @@
+require 'active_model'
+require 'active_support/concern'
+#require 'active_support/hash_with_indifferent_access'
+
+module IB
+
+  # Module adds prop Macro and
+  module BaseProperties
+    extend ActiveSupport::Concern
+
+    ### Instance methods
+
+    # 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, _)|
+			#NoMethodError if a Hash is assigned to an attribute
+      Hash[attributes.reject do |(attr, _)|
+                                  attr.to_s =~ /(_count)\z/ ||
+                                    [:created_at, :updated_at, :type,
+                                     :id, :order_id, :contract_id].include?(attr.to_sym)
+      end]
+    end
+
+=begin
+Remove all Time-Stamps from the list of Attributes
+=end
+		def invariant_attributes
+				attributes.reject{|x| x =~ /_at/}
+		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
+      case other
+      when String # Probably a Rails URI, delegate to AR::Base
+        super(other)
+      else
+        content_attributes.keys.inject(true) { |res, key|
+          res && other.respond_to?(key) && (send(key) == other.send(key)) }
+      end
+    end
+
+    ### Default attributes support
+
+    def default_attributes
+      {:created_at => Time.now
+     #  :updated_at => Time.now,
+       }
+    end
+
+    def set_attribute_defaults
+      default_attributes.each do |key, val|
+        self.send("#{key}=", val) if self.send(key).nil?
+        # self.send("#{key}=", val) if self[key].nil? # Problems with association defaults
+      end
+    end
+
+    included do
+
+      after_initialize :set_attribute_defaults
+
+      ### Class macros
+
+      def self.prop *properties
+        prop_hash = properties.last.is_a?(Hash) ? properties.pop : {}
+
+        properties.each { |names| define_property names, nil }
+        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
+
+          aliases.each do |ali|
+            alias_method "#{ali}", name
+            alias_method "#{ali}=", "#{name}="
+          end
+        end
+      end
+
+      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 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
+        end
+      end
+
+      # Timestamps in lightweight models
+      unless defined?(ActiveRecord::Base) && ancestors.include?(ActiveRecord::Base)
+        prop :created_at #, :updated_at
+      end
+
+    end # included
+  end # module BaseProperties
+end