rticker 1.1.1

data/README

@@ -0,0 +1,3 @@
+rticker is a command line-based stock ticker application capable of
+retrieving and displaying information about stocks, futures, currency
+pairs, and option contracts.

data/bin/rticker

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby -w
+
+require 'rticker/application'
+
+application = RTicker::Application.new(ARGV)
+application.run

data/data/all.ticker

@@ -0,0 +1,12 @@
+;; Show all ticker entries
+;; An entry starting with an @ sign represents an include directive.
+
+@equities.ticker
+--
+@options.ticker
+--
+@indexes.ticker
+--
+@commodities.ticker
+--
+@currencies.ticker

data/data/commodities.ticker

@@ -0,0 +1,7 @@
+; Commodities are preceded by a pound sign.
+*#CL.NYM,Oil
+#KC.NYB,Coffee
+#GC.CMX,Gold
+#SI.CMX,Silver
+#SB.NYB,Sugar
+*#YW.CBT,Wheat

data/data/currencies.ticker

@@ -0,0 +1,7 @@
+; Currency pairs must be preceded by a dollar sign
+
+*$EURUSD,EUR/USD
+$GBPUSD,GBP/USD
+$USDCHF,USD/CHF
+$USDJPY,USD/JPY
+$USDAUD,USD/AUD

data/data/equities.ticker

@@ -0,0 +1,13 @@
+;; An entry preceded with an asterisk will be displayed in bold.
+
+AAPL
+
+;; If you own google, list the amount of shares you own and the average
+;; cost of those shares with the format COUNT@PRICE.  Use a negative
+;; count for short positions.
+
+;; I wish I bought 100 shares of GOOG at $300!
+GOOG
+MSFT
+*MT
+*SLX

data/data/indexes.ticker

@@ -0,0 +1,14 @@
+; Any entry starting with a caret (^) will be fetched from Yahoo.
+; Otherwise the entry is fetched from Google, which is closer to
+; realtime.
+
+; A description of the ticker symbol can be supplied after a comma.
+
+*.DJI,DJIA
+.INX,S&P 500
+.FTSE,FTSE.100
+.HSI,HangSeng
+SHA:000001,Shanghai
+.N225,Nikkei 225
+^^AXJO,S&P/ASX 200
+^^VIX,Volatility Index

data/data/options.ticker

@@ -0,0 +1,3 @@
+; An option contract must be preceded with an exclamation mark
+!MT120121C00035000,MT call $35 Jan '12
+

data/lib/rticker/application.rb

@@ -0,0 +1,91 @@
+
+require 'rticker/options'
+require 'rticker/parser'
+require 'rticker/printer'
+require 'rticker/tput'
+
+module RTicker
+
+  DEFAULT_ENTRY_FILE = "#{ENV['HOME']}/.rticker"
+
+  class Application
+
+    def initialize (args)
+      # Parse recognizable options from command line.  Strips away recognizable
+      # options from ARGV.
+      @options = Options.new(args)
+      @text_entries = []
+      @entries = []
+    end
+
+    def run ()
+      # text_entries is an array of ticker entries in raw text format.
+      # Any left over arguments should be ticker entries.
+      @text_entries = @options.rest
+    
+      @options.input_files.each do |file|
+        # For each file passed via the CLI, read its entries into text_entries.
+        @text_entries += RTicker::read_entry_file(file)
+      end
+      
+      if @text_entries.empty?
+        # If no entries were passed via CLI, then try to read from $HOME/.rticker
+        @text_entries += RTicker::read_entry_file(DEFAULT_ENTRY_FILE) 
+      end
+      
+      if @text_entries.empty?
+        # Still no entries?  Then there's nothing to do.
+        puts "No ticker entries provided.  Exiting."
+        exit
+      end
+      
+      # Parse text_entries into instances of Equity, Future, Currency, Option,
+      # and Separator
+      @entries = @text_entries.map {|entry| RTicker::parse_entry(entry)}
+      
+      currency_entries = @entries.select {|e| e.instance_of? Currency }
+      option_entries = @entries.select {|e| e.instance_of? Option }
+      future_entries = @entries.select {|e| e.instance_of? Future }
+      google_equity_entries = @entries.select {|e| e.instance_of? Equity and e.source == :google  }
+      yahoo_equity_entries = @entries.select {|e| e.instance_of? Equity and e.source == :yahoo  }
+      
+      # Don't raise an exception when user hits Ctrl-C.  Just exit silently
+      Signal.trap("INT") do
+        # Show the cursor again and shutdown cleanly.
+        print RTicker::tput "cnorm" unless @options.once?
+        exit
+      end
+
+      # Set proxy settings
+      if @options.proxy
+        RTicker::Net.proxy = @options.proxy
+      end
+      
+      # Update entries via web calls until user quits via Ctrl-C
+      while true
+        threads = []
+        
+        # Update each type of entry in its own thread.
+        threads << Thread.new { Currency.update(currency_entries) }
+        threads << Thread.new { Option.update(option_entries) }
+        threads << Thread.new { Future.update(future_entries) }
+        threads << Thread.new { Equity.update(google_equity_entries, :google) }
+        threads << Thread.new { Equity.update(yahoo_equity_entries, :yahoo) }
+        
+        # Wait for them all to finish executing
+        threads.each {|t| t.join}
+        
+        # Show updated info to the user
+        RTicker::update_screen @entries, @options.no_color?, @options.once?
+        
+        # If the user only wanted us to grab this info and display it once,
+        # then we've done our job and its time to quit.
+        exit if @options.once?
+        
+        sleep @options.sleep
+      end
+    end
+    
+  end # class
+
+end # module

data/lib/rticker/currency.rb

@@ -0,0 +1,46 @@
+require 'rticker/entry'
+require 'rticker/net'
+require 'cgi'
+
+module RTicker
+
+  ##############################
+  # Represents currency pairs (e.g. USD/EUR)
+  class Currency < Entry
+    # In the context of currency pairs, each increment in @purchase_count
+    # represents single units of the quote currency exchanged for the base
+    # currency.  (The base currency is the first of the pair, the quote
+    # currency is the second.)  @purchase_price represents the pair ratio
+    # when the purchase was made.  For instance, a @purchase_count of 1000
+    # and @purchase_price of 1.412 for the currency pair 'EUR/USD' means that
+    # $1000 USD was swapped for 708.21 euros.  A *negative* @purchase_count
+    # of -1000 would mean that 1000 euros were swapped for $1,412 USD.
+
+    def Currency.update (entries)
+      # Strip out anything from symbol that is not an uppercase character
+      # This allows the user to freely use USD/EUR or USD.EUR, etc.
+      symbols = entries.map { |e| e.symbol.tr("^A-Z", "") }
+      uri_param = symbols.map{|x| x+"=X"}.join(",")
+      uri = "http://download.finance.yahoo.com/d/quotes.csv?s=%s&f=sl1d1t1ba&e=.csv" % CGI::escape(uri_param)
+      response = RTicker::Net.get_response(uri) rescue return
+      return if response =~ /"N\/A"/ # Yahoo sometimes returns bogus info.
+      results = response.split("\n")
+      entries.zip(results) do |entry, result|
+        # Yahoo uses A CSV format.
+        fields = result.split(",")
+        price = fields[1]
+        last_date = fields[2]
+        return if Date.strptime(last_date, '"%m/%d/%Y"') != Date.today
+        if price.to_f != entry.curr_value and not entry.curr_value.nil?
+          # The price has changed
+          entry.last_changed = Time.now() 
+        end
+        entry.curr_value = price.to_f
+        # Currencies aren't regulated.  So no need to calculate the
+        # @start_value, because there is no market open.  Currencies trade
+        # 24/7
+      end
+    end
+  end # class Currency
+
+end # module

data/lib/rticker/entry.rb

@@ -0,0 +1,36 @@
+
+module RTicker
+
+  ##############################
+  # Parent class to represent all types of ticker entries to watch.  The
+  # classes that subclass from Entry are: Equity, Currency, Future, and
+  # Option.
+  class Entry
+    
+    # @symbol represents the ticker symbol for an entry (e.g., AAPL, MSFT,
+    # etc.)  @description is an optional string that can give a more
+    # user-friendly description of a symbol.  If a description is not
+    # provided, the symbol itself is displayed to the user.  If the user
+    # provides information on having purchased an entry (for example AAPL
+    # stock), the user may specify how many via @purchase_count (in this case
+    # how many shares), and for how much via @purchase_price (in this case
+    # how much paid per share).  A user can specify a negative
+    # @purchase_count to represent a SHORT position.  @bold specifies if
+    # this entry should stand apart from other entries when displayed to the
+    # user.
+    attr_accessor :symbol, :description, :purchase_count, :purchase_price
+    attr_accessor :bold, :curr_value, :last_changed
+    
+    alias bold? bold
+    
+    def initialize (symbol, description=nil, purchase_count=nil, purchase_price=nil, bold=false)
+      @symbol = symbol
+      @description = description
+      @purchase_count = purchase_count
+      @purchase_price = purchase_price
+      @bold = bold
+      @last_changed = nil
+    end
+  end # class Entry
+
+end # module

data/lib/rticker/equity.rb

@@ -0,0 +1,78 @@
+require 'rticker/entry'
+require 'rticker/net'
+require 'cgi'
+require 'rational'
+require 'date'
+
+module RTicker
+
+  ##############################
+  # Represents stocks/equities (e.g. AAPL, MSFT)
+  class Equity < Entry
+    # Equities can be retrieved via either Google Finance or Yahoo Finance.
+    # @source should be set to one of either :google (the default) or :yahoo.
+    # @start_value represents the value of the equity at market open.
+    
+    attr_accessor :start_value, :source
+
+    def initialize (symbol, description=nil, purchase_count=nil, purchase_price=nil, bold=false)
+      super(symbol, description, purchase_count, purchase_price, bold)
+      @start_value=nil
+      @source=:google
+    end
+
+    def Equity.update (entries, source=:google)
+      if source == :google
+        Equity.update_google(entries)
+      elsif source == :yahoo
+        Equity.update_yahoo(entries)
+      else
+        raise ArgumentError, "Unexpected symbol: #{source.to_s}"
+      end
+    end
+
+    def Equity.update_google (entries)
+      symbols = entries.map { |e| e.symbol }
+      uri = "http://www.google.com/finance/info?client=ig&q=%s" % CGI::escape(symbols.join(","))
+      response = RTicker::Net.get_response(uri) rescue return
+      return if response =~ /illegal/ # Google didn't like our request.
+      results = response.split("{")[1..-1]
+      return if results.nil?
+      entries.zip(results) do |entry, result|
+        # Fish out the info we want.  Could use a JSON library, but that's
+        # one more gem that would be required of the user to install.  Opted
+        # instead to just use some ugly regexs
+        price =  /,"l" : "([^"]*)"/.match(result)[1].tr(",", "") rescue return
+        change = /,"c" : "([^"]*)"/.match(result)[1].tr(",", "") rescue return
+        if price.to_f != entry.curr_value and not entry.curr_value.nil?
+          # The price has changed
+          entry.last_changed = Time.now() 
+        end
+        entry.curr_value  = price.to_f
+        entry.start_value = entry.curr_value - change.to_f
+      end
+    end
+
+    def Equity.update_yahoo (entries)
+      symbols = entries.map { |e| e.symbol }
+      uri = "http://download.finance.yahoo.com/d/quotes.csv?s=%s&f=l1c1d1va2xj1b4j4dyekjm3m4rr5p5p6s7" % CGI::escape(symbols.join(","))
+      response = RTicker::Net.get_response(uri) rescue return
+      results = response.split("\n")
+      entries.zip(results) do |entry, result|
+        # Yahoo uses A CSV format.
+        fields = result.split(",")
+        price  = fields[0]
+        change = fields[1]
+        last_date = fields[2]
+        return if Date.strptime(last_date, '"%m/%d/%Y"') != Date.today
+        if price.to_f != entry.curr_value and not entry.curr_value.nil?
+          # The price has changed
+          entry.last_changed = Time.now() 
+        end
+        entry.curr_value  = price.to_f
+        entry.start_value = entry.curr_value - change.to_f
+      end
+    end
+  end # class Equity
+
+end # module

data/lib/rticker/future.rb

@@ -0,0 +1,128 @@
+require 'rticker/entry'
+require 'rticker/net'
+require 'cgi'
+
+module RTicker
+
+  ##############################
+  # Represents futures contracts (e.g., oil, gold, corn, wheat)
+  class Future < Entry
+    # Futures contracts expire on a given month and year.  Let's track that
+    # information to display to the user.  Might as well show the @market
+    # that the contract is traded on, too.  For instance oil can be traded via
+    # NYMEX or ICE (InterContinental Exchange).  Also, because we won't know
+    # ahead of time what the nearest expiration for a contract will be, we'll
+    # have to figure this out for each contract with web calls.  Once we know
+    # the expiration, we'll calculate the real symbol for the contract and
+    # store it in @real_symbol.
+    attr_accessor :start_value, :exp_month, :exp_year, :market
+    attr_accessor :real_symbol
+
+    # Commodities have strange codes for months
+    COMMODITY_MONTHS = %w[F G H J K M N Q U V X Z]
+
+    def initialize (symbol, description=nil, purchase_count=nil, purchase_price=nil, bold=false)
+      super(symbol, description, purchase_count, purchase_price, bold)
+      @start_value=nil
+      @exp_month=nil
+      @exp_year=nil
+      @market=nil
+      @real_symbol=nil
+    end
+
+    def Future.update (entries)
+      # Futures are special.  The first run requires us to find the spot
+      # contract for the commodity in question.  The spot contract is simply
+      # the closest expiring contract that is still open for trades.
+      # Determining the spot contract is not always clear, and so we must
+      # brute force to find the answer.  When we find the spot contract, we
+      # set the entry's real_symbol attribute to the actual spot contract's
+      # symbol.  Got it?
+
+      # Since variables are shared in block closures, a simple for loop
+      # won't do.  We must create a new Proc to eliminate sharing of the
+      # entry variable.
+      go = Proc.new do |entry|
+        Thread.new { entry.determine_spot_contract }
+      end
+
+      if entries.any? {|e| e.real_symbol.nil?}
+        #puts "Please wait... determining spot contracts"
+        threads = []
+        for entry in entries
+          if not entry.real_symbol
+            threads << go.call(entry)
+          end
+        end
+        threads.each {|t| t.join}
+      end
+
+      # All spot contracts have been found.  Now let's update our entries
+      # with the latest price information.  This is what we came here for!
+      symbols = entries.map { |e| e.real_symbol }
+      uri = "http://download.finance.yahoo.com/d/quotes.csv?s=%s&f=l1c1d1va2xj1b4j4dyekjm3m4rr5p5p6s7" % CGI.escape(symbols.join(","))
+      response = RTicker::Net.get_response(uri) rescue return
+      results = response.split("\n")
+      entries.zip(results) do |_entry, result|
+        # Yahoo uses A CSV format.
+        fields = result.split(",")
+        return if fields[4] == '""' # This is a sign yahoo is giving us bad info
+        price  = fields[0]
+        change = fields[1]
+        last_date = fields[2]
+        return if Date.strptime(last_date, '"%m/%d/%Y"') != Date.today
+        if price.to_f != _entry.curr_value and not _entry.curr_value.nil?
+          # The price has changed
+          _entry.last_changed = Time.now() 
+        end
+        _entry.curr_value  = price.to_f
+        _entry.start_value = _entry.curr_value - change.to_f
+      end
+    end # def
+
+    def determine_spot_contract
+      # This is as nasty as it gets.  Keep trying contracts, month after
+      # month, until we find a valid one.  Stop after 9 failed attempts.
+      attempt_count = 9 # Maximum number of attempts to try
+
+      symbol, exchange = @symbol.split(".")
+      @market = exchange
+      curr_month = curr_year = nil
+      
+      while attempt_count > 0
+        if curr_month.nil?
+          # By default start looking at next month.  Also, let's use a zero
+          # based index into months.  Jan == 0, Dec == 11
+          curr_month = Time.now().month % 12
+          curr_year  = Time.now().year
+        else
+          curr_month = (curr_month + 1) % 12
+        end
+        curr_year += 1 if curr_month == 0  # We've rolled into next year
+        month_symbol = Future::COMMODITY_MONTHS[curr_month]
+        year_symbol = curr_year % 100 # Only want last two digits of year.
+        real_symbol_attempt = "#{symbol}#{month_symbol}#{year_symbol}.#{exchange}"
+        uri = "http://download.finance.yahoo.com/d/quotes.csv?s=%s&f=l1c1va2xj1b4j4dyekjm3m4rr5p5p6s7" % CGI::escape(real_symbol_attempt)
+        response = RTicker::Net.get_response(uri) rescue return
+
+        # This contract is only valid if the response doesn't start with
+        # 0.00.  A commodity is never worth nothing!
+        unless response =~ /^0.00/
+          @real_symbol = real_symbol_attempt
+          @exp_month = curr_month+1 # Convert from 0-based back to 1-based
+          @exp_year = curr_year
+          break # Get out of this loop!
+        end
+        attempt_count -= 1
+      end # while
+
+      if attempt_count == 0 and @real_symbol.nil?
+        # Can't determine month for this contract.  Set the real_symbol to
+        # symbol and hope for the best.
+        @real_symbol = @symbol
+      end
+    end # def
+
+  end # class Future
+
+end # module

data/lib/rticker/net.rb

@@ -0,0 +1,30 @@
+require 'net/http'
+require 'uri'
+
+module RTicker
+  class Net
+    
+    @@proxy_host = nil
+    @@proxy_port = nil
+
+    def self.proxy ()
+      return nil if @@proxy_host.nil?
+      port = @@proxy_port || 80
+      return "#{@@proxy_host}:#{port}"
+    end
+
+    def self.proxy= (proxy)
+      host, port = proxy.split(":")
+      @@proxy_host = host
+      @@proxy_port = port || 80
+    end
+
+    def self.get_response (url)
+      begin
+        return ::Net::HTTP::Proxy(@@proxy_host, @@proxy_port).get(URI.parse url)
+      rescue Timeout::Error => e
+        return ""
+      end
+    end
+  end
+end

data/lib/rticker/option.rb

@@ -0,0 +1,64 @@
+require 'rticker/entry'
+require 'rticker/net'
+require 'cgi'
+
+module RTicker
+
+  ##############################
+  # Represents option contracts which are derivatives of either equities or
+  # futures.
+  class Option < Entry
+    # Because option contracts are not traded as much as their underlying,
+    # the bid/ask spread can be pretty high and there might be quite a bit of
+    # time since a trade has occurred for a given contract.  Therefore it is
+    # sometimes more meaningful to represent the value of an option by
+    # showing both the current bid and ask prices rather than the last trade
+    # price.
+    attr_accessor :bid, :ask
+
+    def initialize (symbol, description=nil, purchase_count=nil, purchase_price=nil, bold=false)
+      super(symbol, description, purchase_count, purchase_price, bold)
+      @bid = @ask = nil
+    end
+
+    def Option.update (entries)
+      go = Proc.new do |entry|
+        Thread.new { Option.run_update entry }
+      end
+
+      threads = []
+      for entry in entries
+        # Can only grab one option contract at a time, so request each one in
+        # a separate thread.
+        threads << go.call(entry)
+      end
+      threads.each {|t| t.join}
+    end
+
+    private
+    
+    def Option.run_update (entry)
+      uri = "http://finance.yahoo.com/q?s=%s" % CGI::escape(entry.symbol)
+      response = RTicker::Net.get_response(uri) rescue Thread.current.exit
+      # Rake through the HTML and find the bits we want.
+      # This can be a bit messy.
+      begin
+        bid = /id="yfs_b00_[^"]*">([^<]*)</.match(response)[1]
+        ask = /id="yfs_a00_[^"]*">([^<]*)</.match(response)[1]
+      rescue Exception => e
+        # These results aren't available from about 9am to 9:30am.
+        # Yahoo's results are often 20-30 minutes behind.
+        Thread.current.exit
+      end
+      if (bid.to_f != entry.bid or ask.to_f != entry.ask) and not entry.bid.nil?
+        # The price has changed
+        entry.last_changed = Time.now()
+      end
+      entry.bid = bid.to_f
+      entry.ask = ask.to_f
+      # The value is the mean average of the bid/ask spread
+      entry.curr_value = (entry.bid + entry.ask) / 2
+    end
+  end
+
+end # module

data/lib/rticker/options.rb

@@ -0,0 +1,70 @@
+require 'optparse'  # Use OptionParser to parse command line args
+
+module RTicker
+
+  class Options
+
+    attr_reader :once, :no_color, :input_files
+    attr_reader :sleep, :rest, :proxy
+    
+    def initialize (args)
+      # Defaults
+      @once = false     # Only run once then quit
+      @no_color = false # Don't use color when showing results to user
+      @input_files = [] # Input files provided by user
+      @proxy = nil      # "host:port" proxy
+      @sleep = 2        # how long to delay between web requests
+      @rest = []        # The rest of the command line arguments
+      parse!(args)
+    end
+
+    alias no_color? no_color
+    alias once? once
+
+    private
+
+    def parse! (args)
+      # Use OptionParser to parse command line arguments
+      OptionParser.new do |opts|
+        opts.banner = "Usage: rticker [-onh] [-d SECS] [-p host:port] [-f FILE] ... [SYMBOL[,DESC[,COUNT@PRICE]]] ..."
+        
+        opts.on("-o", "--once", "Only display ticker results once then quit") do
+          @once = true
+        end
+        
+        opts.on("-n", "--no-color", "Do not use colors when displaying results") do
+          @no_color = true
+        end
+        
+        opts.on("-f", "--file FILE", "Specify a file that lists ticker entries, one per line") do |file|
+          @input_files << file
+        end
+
+        opts.on("-d", "--delay SECS", "How long to delay in SECS between each update") do |secs|
+          @sleep = secs.to_f
+        end
+        
+        opts.on("-p", "--proxy HOST:PORT", "Host and port of HTTP proxy to use.") do |proxy|
+          @proxy = proxy
+        end
+        
+        opts.on("-h", "--help", "Display this screen") do 
+          puts opts
+          exit
+        end
+
+        # Parse options and pop recognized options out of ARGV.
+        # If a parse error occurs, print help and exit
+        begin
+          opts.parse!(args)
+        rescue OptionParser::ParseError => e
+          STDERR.puts e.message, "\n", opts 
+          exit(-1)
+        end
+        @rest = args
+      end
+    end
+
+  end # class
+
+end # module

data/lib/rticker/parser.rb

@@ -0,0 +1,105 @@
+require 'rticker/types'
+require 'pathname'
+
+module RTicker
+  
+  ##############################
+  # Read raw text entries, line by line, from file.  Return result as an
+  # array of text entries.  File "-" represents STDIN.
+  def RTicker.read_entry_file (file, context=nil)
+    context ||= Dir.pwd
+
+    # If this is a relative path, make it absolute according to context
+    if file != "-" and file[0,1] != "/"
+      file = [context, file].join("/")
+    end
+
+    # If we're not dealing with a readable source then get out of here
+    return [] if file != "-" and not File.readable? file
+
+    if File.symlink? file
+      # Follow symlinks so that we can honor relative include directives
+      return read_entry_file(Pathname.new(file).realpath.to_s)
+    end
+    
+    entries = []
+    source = if file == "-" then $stdin else File.open(file) end
+    source.each do |line|
+      line.chomp!
+      case line
+      when  /^;/, /^\s*$/
+        # If this line starts with a semicolon (comment) or only contains
+        # whitespace, ignore it.
+        next
+      when /^@.+/
+        # If this line starts with an @ sign, then this is an 'include'
+        # directive.  Ie, this entry is simply including another entry file.
+        # Eg: @otherfile.txt
+        # This will include another file called otherfile.txt
+        include_file = line[1..-1]
+        context = File.dirname(file) unless file == "-"
+        entries += read_entry_file(include_file, context)
+      else
+        entries << line
+      end
+    end
+    
+    entries
+  end # read_entry_file
+
+  ##############################
+  # Parse a raw text entry into an instance of Equity, Future, Currency,
+  # Option, or Separator.
+  def RTicker.parse_entry (entry)
+
+    # An entry starting with a dash represents a Separator
+    return Separator.new if entry[0,1] == "-"
+
+    # An entry beginning with an asterisk represents a bold entry.
+    bold = false
+    if entry[0,1] == "*"
+      bold = true
+      entry = entry[1..-1] # Shift off asterisk
+    end
+    
+    ## Here is a breakdown of the format: 
+    ## [sign]symbol[,desc[,purchase_count@purchase_price]]
+    ## Where sign can be a "#" (Future), "!" (Option), "^" (Yahoo Equity), 
+    ## or "$" (Currency).  Anything else represents a Google Equity.
+    pattern = /^([#!^$])?([^,]+)(?:,([^,]*)(?:,(-?[0-9]+)@([0-9]+\.?[0-9]*))?)?/
+    match = pattern.match entry
+
+    sign = match[1]
+    symbol = match[2]
+    # Because description is optional, let's make it clear with a nil that no
+    # description was provided.
+    description = match[3] == "" ? nil : match[3]
+    purchase_count = match[4]
+    purchase_price = match[5]
+
+    args = [symbol, description, purchase_count.to_f, purchase_price.to_f, bold]
+    case sign
+    when "#"
+      # An entry starting with a hash is a Future.  A useful mnemonic is to
+      # think of the "pound" sign and think of lbs of a commodity.
+      return Future.new(*args)
+    when "!"
+      # An entry starting with an exclamation mark is an option contract.
+      return Option.new(*args)
+    when "^"
+      # An entry starting with a caret represents an equity to be fetched
+      # from Yahoo Finance.
+      e = Equity.new(*args)
+      e.source = :yahoo
+      return e
+    when "$"
+      # An entry starting with a dollar sign represents a currency pair.
+      return Currency.new(*args)
+    else
+      # Everthing else is an equity to be fetched from Google Finance (the
+      # default).
+      return Equity.new(*args)
+    end
+  end
+  
+end # module

data/lib/rticker/printer.rb

@@ -0,0 +1,110 @@
+require 'rticker/tput'
+require 'rticker/types'
+
+module RTicker
+
+  ##############################
+  # Update the screen with the latest information.
+  def RTicker.update_screen (entries, no_color=false, once=false)
+    # An interesting side-effect of using unless here is that if no_color is
+    # true, then all of these variables are still created, but set to nil.
+    # So setting no_color effectively turns all of the following variables
+    # into empty strings, turning off terminal manipulation.
+    hide_cursor = tput "civis" unless no_color
+    show_cursor = tput "cnorm" unless no_color
+    bold = tput "bold" unless no_color
+    unbold = tput "sgr0" unless no_color
+    default = tput "sgr0" unless no_color
+    red = tput "setaf 1" unless no_color
+    green = tput "setaf 2" unless no_color
+    blue = tput "setaf 4" unless no_color
+
+    if not once
+      print %x[clear]
+      print "#{hide_cursor}"
+    end
+    print "#{default}"
+    
+    # Calculate the longest symbol name or description
+    max_length = 0
+    for entry in entries.select {|e| not e.is_a? Separator}
+      output = entry.description || entry.symbol
+      max_length = [output.size, max_length].max
+    end
+    max_length += 2 # Give a little extra breathing room
+
+    for entry in entries
+      if entry.is_a? Separator
+        print "___________________________________________\n"
+        next # Skip to the next entry
+      end
+
+      # Prefer a description over a raw symbol name.  Use max_length to left
+      # align the output with extra padding on the right.  This lines
+      # everything up nice and neat.
+      output = "%-#{max_length}s" % (entry.description || entry.symbol)
+      output = "#{bold}#{output}#{unbold}" if entry.bold?
+
+      # If we're still waiting for valid responses from yahoo or google, then
+      # just let the user know that they need to wait.
+      curr_value = entry.curr_value || "please wait..."
+
+      if entry.is_a? Option
+        curr_value = "#{entry.bid}/#{entry.ask}" if entry.bid
+      end
+
+      # Does this entry have a start_value?  If so, let's calculate the
+      # change in percent.
+      change_string = nil
+      if entry.respond_to? :start_value and not entry.start_value.nil?
+        change = entry.curr_value - entry.start_value
+        change_percent = (change / entry.start_value) * 100
+        color = (change >= 0 ? "#{green}" : "#{red}")
+        change_string = " (#{color}%+.2f %%%0.2f#{default})" % [change, change_percent]
+      end
+
+      # If this entry has purchase info, let's calculate profit/loss
+      profit_string = nil
+      if entry.purchase_count != 0 and not entry.curr_value.nil?
+        count = entry.purchase_count
+        price = entry.purchase_price
+        # Options are purchased in multiples of 100 of the contract price
+        count *= 100 if entry.is_a? Option 
+        # There is also a price multiplier for futures, but they are
+        # completely different for each contract.  So the user will simply
+        # need to enter the correct multiplier when configuring the
+        # purchase_count in the ticker entry.  For instance, a contract for
+        # CL, crude light sweet oil, has a multiplier of 1000.  Ie, one
+        # contract represents 1000 barrels of oil.  So if a contract is
+        # bought, the user should enter a purchase_count of 1000.  If the
+        # contract is sold (a short position), the purchase_count should be
+        # -1000.
+        profit_loss = count * entry.curr_value - count * price
+        profit_loss_percent = profit_loss / (count*price) * 100
+        color = (profit_loss >= 0 ? "#{green}" : "#{red}")
+        profit_string = " = #{color}$%.2f %%%0.2f#{default}" % [profit_loss, profit_loss_percent]
+      end
+
+      case entry
+      when Equity
+        print "#{output} #{curr_value}#{change_string}#{profit_string}"
+      when Future
+        print "#{output} #{curr_value}#{change_string}#{profit_string}"
+      when Option
+        print "#{output} #{curr_value}#{profit_string}"
+      when Currency
+        print "#{output} #{curr_value}#{profit_string}"
+      end
+
+      # Let the user know with a blue asterisk if this entry has changed
+      # within the past 5 minutes.
+      if entry.last_changed and (Time.now() - entry.last_changed) <= 5*60
+        print " #{blue}*#{default}"
+      end
+
+      print "\n"
+    end # for
+    
+  end # def
+
+end

data/lib/rticker/separator.rb

@@ -0,0 +1,10 @@
+
+module RTicker
+
+  ##############################
+  # This class is simply used to represent a separator when displaying
+  # entries to the user.
+  class Separator
+  end
+
+end

data/lib/rticker/tput.rb

@@ -0,0 +1,15 @@
+module RTicker
+
+  ##############################
+  # tput is a command line utility used for sending special terminal codes.
+  # This method is memoized to cut down on execution time.
+  $__tput_cache = {}
+  def RTicker.tput (args)
+    if $__tput_cache.has_key? args
+      $__tput_cache[args]
+    else
+      $__tput_cache[args] = %x[tput #{args}]
+    end
+  end
+
+end

data/lib/rticker/types.rb

@@ -0,0 +1,5 @@
+require 'rticker/equity'
+require 'rticker/future'
+require 'rticker/option'
+require 'rticker/currency'
+require 'rticker/separator'

data/rticker.gemspec

@@ -0,0 +1,15 @@
+
+Gem::Specification.new do |s|
+  s.name = "rticker"
+  s.summary = "Command line-based stock ticker application"
+  s.description = File.read(File.join(File.dirname(__FILE__), 'README'))
+  s.version = "1.1.1"
+  s.author = "Alfred J. Fazio"
+  s.email = "alfred.fazio@gmail.com"
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = '>=1.8.7'
+  s.files = Dir['**/**']
+  s.files -= Dir["pkg/**"]
+  s.executables = ['rticker']
+  s.has_rdoc = false
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: rticker
+version: !ruby/object:Gem::Version 
+  hash: 17
+  prerelease: 
+  segments: 
+  - 1
+  - 1
+  - 1
+  version: 1.1.1
+platform: ruby
+authors: 
+- Alfred J. Fazio
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-13 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: |-
+  rticker is a command line-based stock ticker application capable of
+  retrieving and displaying information about stocks, futures, currency
+  pairs, and option contracts.
+email: alfred.fazio@gmail.com
+executables: 
+- rticker
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/rticker
+- data/all.ticker
+- data/commodities.ticker
+- data/currencies.ticker
+- data/equities.ticker
+- data/indexes.ticker
+- data/options.ticker
+- doc/images/Screen shot 2011-09-16 at 11.02.29 AM.png
+- lib/rticker/application.rb
+- lib/rticker/currency.rb
+- lib/rticker/entry.rb
+- lib/rticker/equity.rb
+- lib/rticker/future.rb
+- lib/rticker/net.rb
+- lib/rticker/option.rb
+- lib/rticker/options.rb
+- lib/rticker/parser.rb
+- lib/rticker/printer.rb
+- lib/rticker/separator.rb
+- lib/rticker/tput.rb
+- lib/rticker/types.rb
+- README
+- rticker.gemspec
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Command line-based stock ticker application
+test_files: []
+