ib-ruby 0.4.3

data/lib/ib-ruby/symbols/forex.rb

@@ -0,0 +1,109 @@
+#
+# Copyright (C) 2009 Wes Devauld 
+# 
+# This library is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of the
+# License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301 USA
+#
+
+#
+# Note that the :description field is particular to ib-ruby, and is NOT part of the standard TWS API.
+# It is never transmitted to IB. It's purely used clientside, and you can store any arbitrary string that
+# you may find useful there.
+#
+
+module IB
+  module Symbols
+    Forex = {
+      :audusd => Datatypes::Contract.new({
+                                           :symbol => "AUD",
+                                           :exchange => "IDEALPRO",
+                                           :currency => "USD",
+                                           :sec_type => Datatypes::Contract::SECURITY_TYPES[:forex],
+                                           :description => "AUDUSD"
+                                         }),
+      :gbpusd => Datatypes::Contract.new({
+                                           :symbol => "GBP",
+                                           :exchange => "IDEALPRO",
+                                           :currency => "USD",
+                                           :sec_type => Datatypes::Contract::SECURITY_TYPES[:forex],
+                                           :description => "GBPUSD"
+                                         }),
+
+      :euraud => Datatypes::Contract.new({
+                                           :symbol => "EUR",
+                                           :exchange => "IDEALPRO",
+                                           :currency => "AUD",
+                                           :sec_type => Datatypes::Contract::SECURITY_TYPES[:forex],
+                                           :description => "EURAUD"
+                                         }),
+
+      :eurgbp => Datatypes::Contract.new({
+                                           :symbol => "EUR",
+                                           :exchange => "IDEALPRO",
+                                           :currency => "GBP",
+                                           :sec_type => Datatypes::Contract::SECURITY_TYPES[:forex],
+                                           :description => "EURGBP"
+                                         }),
+
+      :eurjpy => Datatypes::Contract.new({
+                                           :symbol => "EUR",
+                                           :exchange => "IDEALPRO",
+                                           :currency => "JPY",
+                                           :sec_type => Datatypes::Contract::SECURITY_TYPES[:forex],
+                                           :description => "EURJPY"
+                                         }),
+
+      :eurusd => Datatypes::Contract.new({
+                                           :symbol => "EUR",
+                                           :exchange => "IDEALPRO",
+                                           :currency => "USD",
+                                           :sec_type => Datatypes::Contract::SECURITY_TYPES[:forex],
+                                           :description => "EURUSD"
+                                         }),
+
+      :eurcad => Datatypes::Contract.new({
+                                           :symbol => "EUR",
+                                           :exchange => "IDEALPRO",
+                                           :currency => "CAD",
+                                           :sec_type => Datatypes::Contract::SECURITY_TYPES[:forex],
+                                           :description => "EURCAD"
+                                         }),
+
+      :usdchf => Datatypes::Contract.new({
+                                           :symbol => "USD",
+                                           :exchange => "IDEALPRO",
+                                           :currency => "CHF",
+                                           :sec_type => Datatypes::Contract::SECURITY_TYPES[:forex],
+                                           :description => "USDCHF"
+                                         }),
+
+      :usdcad => Datatypes::Contract.new({
+                                           :symbol => "USD",
+                                           :exchange => "IDEALPRO",
+                                           :currency => "CAD",
+                                           :sec_type => Datatypes::Contract::SECURITY_TYPES[:forex],
+                                           :description => "USDCAD"
+                                         }),
+
+      :usdjpy => Datatypes::Contract.new({
+                                           :symbol => "USD",
+                                           :exchange => "IDEALPRO",
+                                           :currency => "JPY",
+                                           :sec_type => Datatypes::Contract::SECURITY_TYPES[:forex],
+                                           :description => "USDJPY"
+                                         })
+     } 
+  end # Contracts
+end

data/lib/ib-ruby/symbols/futures.rb

@@ -0,0 +1,109 @@
+#
+# Copyright (C) 2009 Wes Devauld 
+#
+# This library is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of the
+# License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301 USA
+#
+
+
+# The Futures constant is currently for testing purposes. It guesses the front month
+# currency future using a crude algorithm that does not take into account expiry/rollover day.
+# This will be valid most of the time, but near/after expiry day the next quarter's contract
+# takes over as the volume leader.
+#
+#
+# Note that the :description field is particular to ib-ruby, and is NOT part of the standard TWS API.
+# It is never transmitted to IB. It's purely used clientside, and you can store any arbitrary string that
+# you may find useful there.
+#
+
+module IB
+  module Symbols
+
+    # Get the next valid quarter month >= today, for finding the
+    # front month of quarterly futures.
+    #
+    # N.B. This will not work as expected near/after expiration during that month, as
+    # volume rolls over to the next quarter even though the current month is still valid!
+    #
+
+
+    def self.next_quarter_month(time)
+      sprintf("%02d", [3, 6, 9, 12].find{|month| month >= time.month })
+    end
+
+    def self.next_quarter_year(time)
+      if self.next_quarter_month(time).to_i < time.month
+        time.year + 1
+      else
+        time.year
+      end
+    end
+
+    def self.next_expiry(time)
+      "#{ self.next_quarter_year(time) }#{ self.next_quarter_month(time) }"
+    end
+
+    Futures =
+     {
+      :es => Datatypes::Contract.new({
+                                       :symbol => "ES",
+                                       :expiry => self.next_expiry(Time.now),
+                                       :exchange => "GLOBEX",
+                                       :currency => "USD",
+                                       :sec_type => Datatypes::Contract::SECURITY_TYPES[:future],
+                                       :multiplier => 50,
+                                       :description => "E-Mini S&P 500"
+                                     }),
+
+      :gbp => Datatypes::Contract.new({
+                                       :symbol => "GBP",
+                                       :expiry => self.next_expiry(Time.now),
+                                       :exchange => "GLOBEX",
+                                       :currency => "USD",
+                                       :sec_type => Datatypes::Contract::SECURITY_TYPES[:future],
+                                       :multiplier => 62500,
+                                       :description => "British Pounds"
+                                     }),
+      :eur => Datatypes::Contract.new({
+                                       :symbol => "EUR",
+                                       :expiry => self.next_expiry(Time.now),
+                                       :exchange => "GLOBEX",
+                                       :currency => "USD",
+                                       :sec_type => Datatypes::Contract::SECURITY_TYPES[:future],
+                                       :multiplier => 12500,
+                                       :description => "Euro FX"
+                                     }),
+      :jpy => Datatypes::Contract.new({
+                                       :symbol => "JPY",
+                                       :expiry => self.next_expiry(Time.now),
+                                       :exchange => "GLOBEX",
+                                       :currency => "USD",
+                                       :sec_type => Datatypes::Contract::SECURITY_TYPES[:future],
+                                       :multiplier => 12500000,
+                                       :description => "Japanese Yen"
+                                     }),
+      :hsi => Datatypes::Contract.new({
+                                       :symbol => "HSI",
+                                       :expiry => self.next_expiry(Time.now),
+                                       :exchange => "HKFE",
+                                       :currency => "HKD",
+                                       :sec_type => Datatypes::Contract::SECURITY_TYPES[:future],
+                                       :multiplier => 50,
+                                       :description => "Hang Seng Index"
+                                     })
+    }
+  end
+end

data/lib/ib-ruby.rb

@@ -0,0 +1,10 @@
+require 'version'
+
+module IbRuby
+end  # module IbRuby
+
+require 'ib-ruby/datatypes'
+require 'ib-ruby/ib'
+require 'ib-ruby/messages'
+require 'ib-ruby/symbols/forex'
+require 'ib-ruby/symbols/futures'

data/lib/version.rb

@@ -0,0 +1,8 @@
+require 'pathname'
+
+module IbRuby
+
+  VERSION_FILE = Pathname.new(__FILE__).dirname + '../VERSION' # :nodoc:
+  VERSION = VERSION_FILE.exist? ? VERSION_FILE.read.strip : nil
+
+end

data/spec/ib-ruby_spec.rb

@@ -0,0 +1,131 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe IB::Datatypes::Contract do
+
+  it 'instantiates without options' do
+    x = IB::Datatypes::Contract.new
+    x.should_not be_nil
+  end
+
+  it 'allows setting attributes' do
+    expect {
+      x = IB::Datatypes::Contract.new
+      x.symbol = "TEST"
+      x.sec_type = IB::Datatypes::Contract::SECURITY_TYPES[:stock]
+      x.expiry = 200609
+      x.strike = 1234
+      x.right = "put"
+      x.multiplier = 123
+      x.exchange = "SMART"
+      x.currency = "USD"
+      x.local_symbol = "baz"
+    }.to_not raise_error
+  end
+
+  it 'raises on wrong security type' do
+    expect {
+      x = IB::Datatypes::Contract.new({:sec_type => "asdf"})
+    }.to raise_error ArgumentError
+
+    expect {
+      x = IB::Datatypes::Contract.new
+      x.sec_type = "asdf"
+    }.to raise_error ArgumentError
+
+  end
+
+  it 'accepts pre-determined security types' do
+    IB::Datatypes::Contract::SECURITY_TYPES.values.each do |type|
+      expect {
+        x = IB::Datatypes::Contract.new({:sec_type => type})
+      }.to_not raise_error
+
+      expect {
+        x = IB::Datatypes::Contract.new
+        x.sec_type = type
+      }.to_not raise_error
+    end
+  end
+
+  it 'raises on wrong expiry' do
+    expect {
+      x = IB::Datatypes::Contract.new({:expiry => "foo"})
+    }.to raise_error ArgumentError
+
+    expect {
+      x = IB::Datatypes::Contract.new
+      x.expiry = "foo"
+    }.to raise_error ArgumentError
+  end
+
+  it 'accepts correct expiry' do
+    expect {
+      x = IB::Datatypes::Contract.new({:expiry => "200607"})
+    }.to_not raise_error
+
+    expect {
+      x = IB::Datatypes::Contract.new
+      x.expiry = "200607"
+    }.to_not raise_error
+
+    expect {
+      x = IB::Datatypes::Contract.new({:expiry => 200607})
+    }.to_not raise_error
+
+    expect {
+      x = IB::Datatypes::Contract.new
+      x.expiry = 200607
+      x.expiry.should == "200607" # converted to a string
+    }.to_not raise_error
+
+  end
+
+  it 'raises on incorrect right (option type)' do
+    expect {
+      x = IB::Datatypes::Contract.new({:right => "foo"})
+    }.to raise_error ArgumentError
+    expect {
+      x = IB::Datatypes::Contract.new
+      x.right = "foo"
+    }.to raise_error ArgumentError
+  end
+
+  it 'accepts all correct values for right (option type)' do
+    ["PUT", "put", "P", "p", "CALL", "call", "C", "c"].each do |right|
+      expect {
+        x = IB::Datatypes::Contract.new({:right => right})
+      }.to_not raise_error
+
+      expect {
+        x = IB::Datatypes::Contract.new
+        x.right = right
+      }.to_not raise_error
+    end
+  end
+
+  context "serialization" do
+    let(:stock) do
+      stock = IB::Datatypes::Contract.new
+      stock.symbol = "TEST"
+      stock.sec_type = IB::Datatypes::Contract::SECURITY_TYPES[:stock]
+      stock.expiry = 200609
+      stock.strike = 1234
+      stock.right = "put"
+      stock.multiplier = 123
+      stock.exchange = "SMART"
+      stock.currency = "USD"
+      stock.local_symbol = "baz"
+      stock
+    end
+
+    it "serializes long" do
+      stock.serialize_long(20).should ==
+          ["TEST", IB::Datatypes::Contract::SECURITY_TYPES[:stock], "200609", 1234, "PUT", 123, "SMART", nil, "USD", "baz"]
+    end
+
+    it "serializes short" do
+      stock.serialize_short(20).should ==
+          ["TEST", IB::Datatypes::Contract::SECURITY_TYPES[:stock], "200609", 1234, "PUT", 123, "SMART", "USD", "baz"]
+    end
+  end #serialization
+end # describe IB::Datatypes::Contract

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib ib-ruby]))
+
+RSpec.configure do |config|
+  # config.exclusion_filter = { :slow => true }
+  # config.filter = { :focus => true }
+  # config.include(UserExampleHelpers)
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end

data/tasks/common.rake

@@ -0,0 +1,18 @@
+#task :default => 'test:run'
+#task 'gem:release' => 'test:run'
+
+task :notes do
+  puts 'Output annotations (TBD)'
+end
+
+#Bundler not ready for prime time just yet
+#desc 'Bundle dependencies'
+#task :bundle do
+#  output = `bundle check 2>&1`
+#
+#  unless $?.to_i == 0
+#    puts output
+#    system "bundle install"
+#    puts
+#  end
+#end

data/tasks/doc.rake

@@ -0,0 +1,14 @@
+desc 'Alias to doc:rdoc'
+task :doc => 'doc:rdoc'
+
+namespace :doc do
+  require 'rake/rdoctask'
+  Rake::RDocTask.new do |rdoc|
+#    Rake::RDocTask.new(:rdoc => "rdoc", :clobber_rdoc => "clobber", :rerdoc => "rerdoc") do |rdoc|
+    rdoc.rdoc_dir = DOC_PATH.basename.to_s
+    rdoc.title = "#{NAME} #{CLASS_NAME::VERSION} Documentation"
+    rdoc.main = "README.doc"
+    rdoc.rdoc_files.include('README*')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  end
+end

data/tasks/gem.rake

@@ -0,0 +1,40 @@
+desc "Alias to gem:release"
+task :release => 'gem:release'
+
+desc "Alias to gem:install"
+task :install => 'gem:install'
+
+desc "Alias to gem:build"
+task :gem => 'gem:build'
+
+namespace :gem do
+  gem_file = "#{NAME}-#{CLASS_NAME::VERSION}.gem"
+
+  desc "(Re-)Build gem"
+  task :build do
+    puts "Remove existing gem package"
+    rm_rf PKG_PATH
+    puts "Build new gem package"
+    system "gem build #{NAME}.gemspec"
+    puts "Move built gem to package dir"
+    mkdir_p PKG_PATH
+    mv gem_file, PKG_PATH
+  end
+
+  desc "Cleanup already installed gem(s)"
+  task :cleanup do
+    puts "Cleaning up installed gem(s)"
+    system "gem cleanup #{NAME}"
+  end
+
+  desc "Build and install gem"
+  task :install => :build do
+    system "gem install #{PKG_PATH}/#{gem_file}"
+  end
+
+  desc "Build and push gem to Gemcutter"
+  task :release => [:build, 'git:tag'] do
+    puts "Pushing gem to Gemcutter"
+    system "gem push #{PKG_PATH}/#{gem_file}"
+  end
+end

data/tasks/git.rake

@@ -0,0 +1,34 @@
+desc "Alias to git:commit"
+task :git => 'git:commit'
+
+namespace :git do
+
+  desc "Stage and commit your work [with message]"
+  task :commit, [:message] do |t, args|
+    puts "Staging new (unversioned) files"
+    system "git add --all"
+    if args.message
+      puts "Committing with message: #{args.message}"
+      system %Q[git commit -a -m "#{args.message}" --author arvicco]
+    else
+      puts "Committing"
+      system %Q[git commit -a -m "No message" --author arvicco]
+    end
+  end
+
+  desc "Push local changes to Github"
+  task :push => :commit do
+    puts "Pushing local changes to remote"
+    system "git push"
+  end
+
+  desc "Create (release) tag on Github"
+  task :tag => :push do
+    tag = CLASS_NAME::VERSION
+    puts "Creating git tag: #{tag}"
+    system %Q{git tag -a -m "Release tag #{tag}" #{tag}}
+    puts "Pushing #{tag} to remote"
+    system "git push origin #{tag}"
+  end
+
+end

data/tasks/spec.rake

@@ -0,0 +1,15 @@
+desc 'Alias to spec:spec'
+task :spec => 'spec:spec'
+
+namespace :spec do
+  require 'rspec/core/rake_task'
+
+  desc "Run all specs"
+  RSpec::Core::RakeTask.new(:spec) { |task|}
+
+  desc "Run specs with RCov"
+  RSpec::Core::RakeTask.new(:rcov) do |task|
+    task.rcov = true
+    task.rcov_opts = ['--exclude', 'spec']
+  end
+end

data/tasks/version.rake

@@ -0,0 +1,71 @@
+class Version
+  attr_accessor :major, :minor, :patch, :build
+
+  def initialize(version_string)
+    raise "Invalid version #{version_string}" unless version_string =~ /^(\d+)\.(\d+)\.(\d+)(?:\.(.*?))?$/
+    @major = $1.to_i
+    @minor = $2.to_i
+    @patch = $3.to_i
+    @build = $4
+  end
+
+  def bump_major(x)
+    @major += x.to_i
+    @minor = 0
+    @patch = 0
+    @build = nil
+  end
+
+  def bump_minor(x)
+    @minor += x.to_i
+    @patch = 0
+    @build = nil
+  end
+
+  def bump_patch(x)
+    @patch += x.to_i
+    @build = nil
+  end
+
+  def update(major, minor, patch, build=nil)
+    @major = major
+    @minor = minor
+    @patch = patch
+    @build = build
+  end
+
+  def write(desc = nil)
+    CLASS_NAME::VERSION_FILE.open('w') { |file| file.puts to_s }
+    (BASE_PATH + 'HISTORY').open('a') do |file|
+      file.puts "\n== #{to_s} / #{Time.now.strftime '%Y-%m-%d'}\n"
+      file.puts "\n* #{desc}\n" if desc
+    end
+  end
+
+  def to_s
+    [major, minor, patch, build].compact.join('.')
+  end
+end
+
+desc 'Set version: [x.y.z] - explicitly, [1/10/100] - bump major/minor/patch, [.build] - build'
+task :version, [:command, :desc] do |t, args|
+  version = Version.new(CLASS_NAME::VERSION)
+  case args.command
+    when /^(\d+)\.(\d+)\.(\d+)(?:\.(.*?))?$/ # Set version explicitly
+      version.update($1, $2, $3, $4)
+    when /^\.(.*?)$/ # Set build
+      version.build = $1
+    when /^(\d{1})$/ # Bump patch
+      version.bump_patch $1
+    when /^(\d{1})0$/ # Bump minor
+      version.bump_minor $1
+    when /^(\d{1})00$/ # Bump major
+      version.bump_major $1
+    else # Unknown command, just display VERSION
+      puts "#{NAME} #{version}"
+      next
+  end
+
+  puts "Writing version #{version} to VERSION file"
+  version.write args.desc
+end