From: Ruby Quiz <james@...>
Date: 2005-08-11T21:59:20+09:00
Subject: [SUMMARY] Stock Portfolios (#41)

The first thing this quiz requires is a source of stock data.  The only
essential piece of data for the program shown in the quiz is a current share
price.  Jeffrey Moss shows what is probably the easiest way to get exactly that:

	require 'soap/rpc/driver'

	driver = SOAP::RPC::Driver.new( 'http://services.xmethods.com/soap',
	                                'urn:xmethods-delayed-quotes' )
	driver.add_method( 'getQuote', 'a_string' )
	driver.getQuote('GOOG')

That code fetches a current quote for Google (symbol "GOOG"), though it doesn't
do anything with it.  It uses the standard SOAP library to retrieve the quote
from a web service provider.

There are, of course, other ways to fetch stock data.  You could always scrape
it from any of the numerous provider sites across the web.  Peter Verhage gave
us another interesting option with a link posted to Ruby Talk:

	http://www.gummy-stuff.org/Yahoo-data.htm

The page describes how to feed Yahoo! custom URL's to which it will respond with
and impressive array of stock data in Comma Separated Value (CSV) format.  A
couple of solutions put this to use.

Let's examine Adam Sanderson's code below:

	require 'open-uri'
	require 'ostruct'
	require 'csv'
	require 'yaml'

	# I used the methods outlined at http://www.gummy-stuff.org/Yahoo-data.htm
	# to fetch and manage data, it works quite well.
	#
	# StockData encapsulates Yahoo's service and generates OpenStructs 
	# which have the requested fields. A StockTransaction records the 
	# purchase or sale of stocks with a timestamp.  StockHistory aggregates
	# StockTransactions. The StockPortfolio manages a user's stocks.  Finaly
	# the StockApp provides a text UI.  StockApp isn't very polished, but it
	# does the trick.
	#
	# Usage:
	# ruby stocks.rb [filename]
	#
	# .adam sanderson
	# netghost@gmail.com

	# To make things easier. overide the way Time is printed.
	class Time
	    def to_s
	        strftime("%m/%d/%Y %I:%M%p")
	    end
	end
	
	# ...

You can see that the code starts by requesting four standard libraries be
loaded.  The open-uri library makes it trivially easy to read from a URL,
ostruct gives us an objectified Hash interface, csv can parse/write CSV data,
and YAML is an easy and powerful data language for persistent storage.  Learning
about the various libraries Ruby ships with can put a lot of powerful tools at
your finger tips.

The rest of the above snippet is mostly a comment that describes the code to
follow.  The Time class is also altered to print date and time information as
this code prefers.  (I'm not sure how much value the Time hack has, since the
user code could just call strftime() instead.  You be the judge.)

Here's the first class used in the solution:

	# http://www.gummy-stuff.org/Yahoo-data.htm
	class StockData
	    include Enumerable

	    SOURCE_URL = "http://finance.yahoo.com/d/quotes.csv"

	    #These are the symbols I understand, which are limited
	    OPTIONS = {
	        :symbol=>"s",
	        :name=>"n",
	        :last_trade=>"l1",
	        :last_trade_date=>"d1",
	        :last_trade_time=>"t1",
	        :open=>"o",
	        :high=>"h",
	        :low=>"g",
	        :high_52_week=>"k",
	        :low_52_week=>"j"
	    }

	    def initialize(symbols, options = [:symbol, :name,
	                                       :last_trade, :last_trade_date,
	                                       :last_trade_time])
	        @symbols = symbols
	        @options = options
	        @data = nil
	    end

	    def each
	        data.each do |row|
	            struct = OpenStruct.new(Hash[*(@options.zip(row).flatten)])
	            yield struct 
	        end
	    end

	    def each_hash
	        data.each do |row|
	            hash = Hash[*(@options.zip(row).flatten)]
	            yield hash
	        end
	    end

	    def refresh
	        symbol_fragment = @symbols.join "+"
	        option_fragment = @options.map{|s| OPTIONS[s] }.join ""
	        url = SOURCE_URL + "?s=#{symbol_fragment}&f=#{option_fragment}"
	        @data = []
	        CSV.parse open(url).read do |row|
	            @data << row
	        end
	    end

	    def data
	        refresh unless @data
	        @data
	    end
	end

This StockData class is a wrapper for the Yahoo! service I described earlier. 
It begins by initializing a few constants for the URL of the service and some of
the options provided by the service.  The constructor takes an Array of stock
ticker symbols you want to fetch data for and an Array of options indicating the
data you wish to fetch.

Skip down now to the refresh() method, which actually does the data fetching. 
This methods just does what the previously mentioned link tells you to:  join()
all the symbols with "+", string the options together, form a URL of all that,
and read the CSV data from it.  Note that data is loaded into @data, row by row.

The other three methods are how you get the data.  Let's start with data(),
because the other two rely on it.  I like it when people remember that you don't
have to write an accessor with the attr_... methods, and you can do clever
tricks when you code them yourself.  For example, this method makes sure the
data is refresh()ed, if the instance variable is still empty.  I think that's
handy.

The other two methods allow you to iterate over the rows of data.  You can use
each_hash(), to receive each row as a Hash pairing the requested option name and
the fetched value.  Note the smooth use of zip() and flatten() there to rapidly
build the Hash.  The each() method works exactly the same, same that it yields
OpenStruct objects instead of Hashes.  In other words, you can choose to access
your data with row[:last_trade] or row.last_trade, as you prefer.  (OpenStruct
seems to be the preferred choice here though since all the Enumerable methods
use it.)

On to the next class:

	# ...
	
	class StockTransaction
	    attr_reader :shares, :price, :date

	    def initialize(shares, price)
	        @shares = shares
	        @price = price
	        @date = Time.now
	    end

	    def cost
	        @price * @shares
	    end

	    def to_s
	        ((@shares > 0) ? "Bought":"Sold") +
	        " #{shares.abs} on #{date} for #{cost.abs}, at #{price}"
	    end
	end
	
	# ...

This is a simple data class.  It takes a number of shares (maybe negative, for
sale transactions) and a price.  It also records the creation time.  Given that,
you can ask it for the total cost() or a pretty String describing the
transaction.

Next class:

	# ...
	
	class StockHistory
	    attr_reader :symbol, :name, :history

	    def initialize(symbol, name)
	        @symbol = symbol
	        @name = name
	        @history = []
	    end

	    def net_shares
	        history.inject(0){|shares, transaction|
	            shares + transaction.shares
	        }
	    end

	    def net_balance
	        history.inject(0){|balance, transaction|
	            balance + transaction.cost
	        }
	    end

	    def started
	        history.first.date unless history.empty?
	    end

	    def buy(shares, price)
	        if(shares > 0 and price > 0)
	            history << StockTransaction.new(shares.abs, price)
	        else
	            puts "Could not buy #{shares} of #{name || symbol}, " + 
	                 "you only have #{net_shares} shares."
	        end
	    end

	    def sell(shares, price)
	        if(net_shares >= shares and shares > 0 and price > 0)
	            history << StockTransaction.new(shares.abs*-1, price)
	        else
	            puts "Could not sell #{shares} of #{name || symbol}, " + 
	                 "you only have #{net_shares} shares."
	        end
	    end

	    def to_s
	        lines = []
	        lines << "#{name}(#{symbol})"
	        history.each do |t|
	            lines << t.to_s
	        end
	        lines.join "\n"
	    end

	end
	
	# ...

This class is just a collection of the StockTransactions we just examined.  You
initialize() it with a symbol and name, then add transactions with buy() and
sell().  Those methods construct StockTransaction objects and add them to the
internal history Array.  Once you have a StockHistory started, you can query it
for net_shares(), net_balance(), and a started() date.  Finally, to_s() will
build a human readable summary using StockTransaction's to_s() to build each
line.

Last stock data class, coming up:

	# ...
	
	class StockPortfolio
	    DEFAULT_INFO = [:symbol, :name, :last_trade]
	    attr :stocks

	    def initialize()
	        @stocks = {}    #stocks by symbol
	    end

	    # Takes a hash of symbols to shares, yields history, price, 
	    # quantity requested
	    def transaction(purchases, &block)
	        data = StockData.new(purchases.keys, DEFAULT_INFO)
	        data.each do |stock|
	            price = stock.last_trade.to_f
	            if not price == 0
	                history = @stocks[ stock.symbol ] ||=
	                          StockHistory.new(stock.symbol, stock.name)
	                yield [history, purchases[stock.symbol],
	                       stock.last_trade.to_f]
	            else
	                puts "Couldn't find #{stock.symbol}."
	            end
	        end
	    end

	    def buy(purchases)
	        transaction(purchases){|history, shares, price|
	            history.buy(shares, price)
	        }
	    end

	    def sell(purchases)
	        transaction(purchases){|history, shares, price|
	            history.sell(shares, price)
	        }
	    end

	    def history(symbol=nil)
	        if (symbol)
	            puts stocks[symbol]
	        else
	            stocks.keys.each{|s| history s unless s.nil?}
	        end
	    end

	    def report()
	        data = StockData.new(stocks.keys, DEFAULT_INFO)

	        data.each do |stock|
	            history = stocks[stock.symbol]
	            if (history)
	                gain = (history.net_shares * stock.last_trade.to_f) -
	                       history.net_balance
	                puts "#{stock.name}(#{stock.symbol}), " + 
	                     "Started #{history.started}"
	                puts " Gain = Shares x Price - Balance:"
	                puts " $#{gain} = #{history.net_shares} x " +
	                     "$#{stock.last_trade.to_f} - $#{history.net_balance}"
	                puts ""
	            end
	        end
	    end
	end
	
	# ...

This class manages a portfolio, which is basically a collection of StockHistory
objects.  The buy() and sell() methods are the primary interface here, but they
both just delegate to transaction().

That method, which might be better as a private instance method, takes a Hash of
symbol keys and shares to buy or sell values.  It also requires a block, though
it doesn't use its "block" parameter.  First, transaction() uses a StockData
object (with the hardcoded DEFAULT_INFO selection of options) to lookup a
current price for each of the symbols passed in.  From that, it constructs price
data and a matching StockHistory object, either by looking it up or creating a
new one.  The history, passed in share count, and price are then yielded to the
block, which buy() and sell() use to add the transactions to the history.

The other two methods report on the data.  The history() method will print a
single transaction history for a requested symbol or all known histories by
symbol.  To see how all the owned stocks are holding up, you can call report(). 
It fetches current prices, again using StockData, then outputs gain/loss
information for each symbol in the portfolio.  Note that these methods print
data directly to STDOUT and thus wouldn't play too nice with non-console
interfaces.

Finally, here's the application itself:

	# ...
	
	class StockApp
	    QUIT    = /^exit|^quit/
	    BUY     = /^buy\s+((\d+\s+\w+)(\,\s*\d+\s+\w+)*)\s*$/
	    SELL    = /^sell\s+((\d+\s+\w+)(\,\s*\d+\s+\w+)*)\s*$/
	    HISTORY = /^history\s*(\w+)?\s*$/
	    REPORT  = /^report\s*$/
	    VIEW    = /^view\s+((\w+)(\,\s*\w+)*)\s*$/
	    HELP    = /^help|^\?/

	    def initialize(path="stock_data.yaml")
	        if File.exist? path
	            puts "Loading Portfolio from #{path}"
	            @portfolio = YAML.load( open(path).read )
	            @portfolio.report
	        else
	            puts "Starting a new portfolio..."
	            @portfolio = StockPortfolio.new()
	        end
	        @path = path
	    end

	    def run
	        command = nil

	        while(STDOUT << ">"; command = gets.chomp)

	            case command
	                when QUIT
	                    puts "Saving data..."
	                    open(@path,"w"){|f| f << @portfolio.to_yaml}
	                    puts "Good bye"
	                    break

	                when REPORT
	                    @portfolio.report

	                when BUY
	                    purchases = parse_purchases($1)
	                    @portfolio.buy purchases
	                    @portfolio.report

	                when SELL
	                    purchases = parse_purchases($1)
	                    @portfolio.sell purchases
	                    @portfolio.report

	                when VIEW
	                    symbols = ($1).split
	                    options = [:symbol, :name, :last_trade]
	                    data = StockData.new(symbols, options)
	                    data.each do |stock|
	                        puts "#{stock.name} (#{stock.symbol} " +
	                             "$#{stock.last_trade})"
	                    end

	                when HISTORY
	                    symbol = $1 ? ($1).upcase : nil
	                    @portfolio.history(symbol)

	                when HELP
	                   help() 

	                else
	                    puts "Enter: 'help' for help, or 'exit' to quit."
	            end

	        end
	    end

	    def parse_purchases(str)
	        purchases = {}
	        str.scan(/(\d+)\s+(\w+)/){|pair| purchases[$2.upcase] = $1.to_i}
	        purchases
	    end

	    def help
	        puts <<END_OF_HELP
	Commands:
	[buy]: Purchase Stocks
	    buy Shares Symbol[, Shares Symbol...]
	    example: buy 30 GOOG, 10 MSFT

	[sell]: Sell Stocks
	    sell Shares Symbol[, Shares Symbol...]
	    example: sell 30 GOOG, 10 MSFT

	[history]: View your transaction history
	    history [Symbol]
	    example: history GOOG

	[report]: View a report of your current stocks
	    report

	[view]: View the current price of a stock
	    view Symbol[, Symbol...]
	    example: view GOOG, MSFT

	[exit]: Quit the stock application (also quit)

	END_OF_HELP

	    end

	end
	
	# ...

While that looks like a lot of code, there's really not a lot of fancy stuff
going on.

The constructor just opens an existing portfolio file, using YAML, if one
exists.  You can point it at a file, or it will default.  The path of this file
is saved, so the file can be updated on exit.

The two biggest methods are run() and help().  The run() method just read
commands from STDIN, parses them using Regexps (you can see these at the top of
the class) in a large case statement, and executes the proper methods on the
classes we've been looking at in response.  If you need more details on how any
of these work, glance at the other big method, help(), which is just a heredoc
String.

The parse_purchase() method is a helper for the BUY and SELL commands that
extracts all the symbols and shares entered by the user.

Here's the last little chunk of code that creates and runs the application:

	# ...
	
	if __FILE__ == $0
	    app = if ARGV.length > 0
	        StockApp.new(ARGV.pop)
	    else
	        StockApp.new()
	    end
	    app.run
	end

My thanks to those who delved into the land of Wall Street and made some trades.
Hopefully you're now well on your way to a balanced portfolio.

Tomorrow we will try a submitted problem from Hans Fugal that should be plenty
of fun for all you algorithm junkies out there...