calc_profit 0.1.1

data/lib/calc_profit.rb

@@ -0,0 +1,14 @@
+require 'active_support/all'
+require 'fat_core'
+require 'pathname'
+require 'csv'
+
+require 'calc_profit/core_ext'
+require 'calc_profit/match'
+require 'calc_profit/transaction'
+require 'calc_profit/transaction_group'
+require 'calc_profit/table'
+require 'calc_profit/latex_table_builder'
+
+require 'byebug'
+require 'pry'

data/lib/calc_profit/core_ext.rb

@@ -0,0 +1,2 @@
+require 'calc_profit/core_ext/string'
+require 'calc_profit/core_ext/array'

data/lib/calc_profit/core_ext/array.rb

@@ -0,0 +1,10 @@
+class Array
+  # Duplicate each element of an Array into a new Array
+  def dup2
+    newa = []
+    self.each { |e|
+      newa << e.dup
+    }
+    newa
+  end
+end

data/lib/calc_profit/core_ext/string.rb

@@ -0,0 +1,32 @@
+class String
+  def dequote
+     if self.strip =~ /^"/
+       self.sub(/^\s*"?([^"]*)"?\s*$/, '\1')
+     else
+       self
+     end
+  end
+
+  # Remove leading and trailing white space and compress internal runs of
+  # white space to a single space.
+  def clean
+    self.strip.squeeze(' ')
+  end
+
+  # Format the string according to the given format.  A format of n, where n
+  # is an integer, formats the string as a number with embedded commas and
+  # rounded to n decimal places.  A nil format just returns the string.
+  def format_by(format)
+    case format
+    when Integer
+      val = gsub(/[$,]/, '')
+      if val.number?
+        val.to_f.commas(format)
+      else
+        self
+      end
+    else
+      self
+    end
+  end
+end

data/lib/calc_profit/latex_table_builder.rb

@@ -0,0 +1,182 @@
+module CalcProfit
+  class LatexTableBuilder
+    attr_reader :table
+
+    def initialize(table)
+      @table = table
+    end
+
+    # Return a LaTeX longtable string for the table showing the columns in the
+    # order given by the include parameter as an array of symbols representing
+    # table headers.  By default, all columns are included.
+
+    # The columns will be arranged in the order given in include.  Columns not
+    # found in the include array will not be displayed. Also, and columns
+    # named in the exclude argument will not be displayed.  Thus, if only an
+    # exclude parameter is given, all the columns will be displayed other than
+    # those named in the exclude parameter.
+    #
+    # An optional caption can be given as a string in the caption parameter.
+    #
+    # The rows of the table will be sorted according to the column (if a
+    # symbol) or columns (if an array of symbols) given in sort_on. By
+    # default, they will be sorted on the first column named in the columns
+    # parameter.
+    #
+    # A footer row containing the totals of columns named in the total_on
+    # parameter, which can be a symbol or an array of symbols.
+    #
+    # All columns will be right-aligned unless a different spec is given in
+    # the align parameter, which must be a hash keyed on the column symbol
+    # and having a value that is a valid LaTeX column spec.  For example,
+    # align: { date: 'c', ref: 'l' } will cause the items in the date
+    # column to be centered and the items in the ref column to be
+    # left-aligned.
+    #
+    # All table items will be formatted as is unless a format is given in the
+    # formats parameter.  It should be a hash that contains a formatting
+    # directive for any columns that need additional formatting.  As of now,
+    # the only formatting directive recognized is an integer to specify that
+    # the column items should be formatted as a number grouped with commas and
+    # rounded to the number of places given in the number.  For example,
+    # formats: { shares: 0, price: 5 } will cause the numbers in those columns
+    # to be rounded to 0 and 5 places respectively and have grouping commas
+    # embedded in them.
+    #
+    # Finally, the whole table can be returned as a macro definition named by
+    # the define_as: parameter if given.  Otherwise, return the direct table
+    # code.
+    def build(include: table.rows[0].keys, exclude: [],
+              caption: nil, sort_on: include[0], total_on: nil,
+              align: {}, formats: {}, define_as: nil)
+
+      # Allow include and exclude to be a single symbol or an array of symbols
+      # and compute the displayed columns.
+      columns = [include].flatten
+      exclude = [exclude].flatten
+      columns = include - exclude
+
+      # By default, right-align all columns
+      specs = {}
+      columns.each do |col|
+        specs[col] = align[col] || 'r'
+      end
+
+      # Allow sort_on and total_on to be a single symbol or an array of
+      # symbols
+      sort_on = [sort_on].flatten
+      total_on = [total_on].flatten if total_on
+
+      # Macro definition
+      ltable = ''
+      if define_as
+        ltable += "\\newcommand{\\#{define_as}}{\n"
+      end
+
+      # Table environment
+      spec_string = ''
+      columns.each do |col|
+        spec_string += specs[col]
+      end
+      ltable += <<-EOT.clean
+        \\begin{longtable}{#{spec_string}}
+        \\hline\\hline\\\\
+      EOT
+      ltable += "\n"
+
+      # Caption
+      ltable += "\\caption{#{caption.tex_quote}}\\\\\n" if caption
+
+      # Header
+      ltable += tex_header(columns)
+      ltable += <<-'EOT'.clean
+        \\\hline\\[0.5ex]
+        \endhead
+      EOT
+      ltable += "\n"
+
+      # Footer
+      if total_on
+        ltable += tex_row(total_row(total_on, columns), columns,
+                          formats: formats, bold: true)
+      end
+      ltable += <<-'EOT'.clean
+        \endlastfoot
+      EOT
+      ltable += "\n"
+
+      # Sorted, formated Body
+      sort_rows_on(sort_on).each do |row|
+        ltable += tex_row(row, columns, formats: formats)
+      end
+
+      # Close environment
+      ltable += <<-'EOT'.clean
+        \end{longtable}
+      EOT
+
+      # Close macro
+      if define_as
+        ltable += '}'
+      end
+      ltable
+    end
+
+    private
+
+    def tex_header(columns)
+      head = ''
+      columns.each do |col|
+        head += "\\multicolumn{1}{c}{\\textbf{#{col.entitle.tex_quote}}}&\n"
+      end
+      head = head.sub(/&\n\z/, '')
+      head += "\\\\\n"
+    end
+
+    # Return the rows of the table sorted on the possibly multiple keys given
+    # in columns.
+    def sort_rows_on(columns)
+      table.rows.sort do |r1, r2|
+        key1 = columns.each.map { |col| r1[col]}
+        key2 = columns.each.map { |col| r2[col]}
+        key1 <=> key2
+      end
+    end
+
+    # Return a constructed row of column totals for the columns named in
+    # total_on with a blank entry for all other columns.
+    def total_row(total_on, columns)
+      total_row = {}
+      first_col = true
+      columns.each do |col|
+        if first_col
+          total_row[col] = 'Totals'
+          first_col = false
+          next
+        end
+        if total_on.include?(col)
+          total_row[col] = table.column_sum(col).to_s
+        else
+          total_row[col] = ''
+        end
+      end
+      total_row
+    end
+
+    # Return a string for a TeX table row for the given columns, formatted
+    # according to the given formats.
+    def tex_row(row, columns, formats: {}, bold: false)
+      row_string = ''
+      columns.each do |col|
+        item = row[col].format_by(formats[col]).tex_quote
+        if bold
+          row_string += "\\textbf{#{item}}&"
+        else
+          row_string += "#{item}&"
+        end
+      end
+      row_string = row_string.sub(/&\z/, '')
+      row_string += "\\\\\n"
+    end
+  end
+end

data/lib/calc_profit/match.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+module CalcProfit
+  class Match
+    attr_reader :purchase, :sale
+
+    def initialize(p, s)
+      case p
+      when Transaction
+        if p.code == 'P'
+          @purchase = p
+        else
+          raise "First argument to Match (#{p}) not a purchase Transaction."
+        end
+      else
+        raise "First argument to Match (#{p}) not a purchase Transaction."
+      end
+
+      case s
+      when Transaction
+        if s.code == 'S'
+          @sale = s
+        else
+          raise "Second argument to Match (#{s}) not a sale Transaction."
+        end
+      else
+        raise "Second argument to Match (#{s}) not a sale Transaction."
+      end
+
+      if p.price >= s.price
+        raise "No profit from purchase @ #{p.price} and sale @ #{s.price} supplied to Match."
+      end
+
+      unless p.date.within_6mos_of?(s.date)
+        raise "Match purchase and sale not within 6 months of each other."
+      end
+    end
+
+    def profit
+      p = ((@sale.price - @purchase.price) *
+           [@sale.shares, @purchase.shares].min)
+      (p * 100.0).round / 100.0
+    end
+
+    def table_row
+      row = {}
+      purchase.table_row.each_pair do |k, v|
+        row[(k.entitle + ' P').as_sym] = v
+      end
+      sale.table_row.each_pair do |k, v|
+        row[(k.entitle + ' S').as_sym] = v
+      end
+      row[:profit] = profit.to_s
+      row
+    end
+  end
+end

data/lib/calc_profit/table.rb

@@ -0,0 +1,151 @@
+module CalcProfit
+
+  # A container for a two-dimensional table that can be used as input of a set
+  # of transactions and output for results of calculations.  All cells in the
+  # table are kept as strings with no attempt to determine their type.  The
+  # table is maintained as an array of hashes accessible from the Table#rows
+  # method.
+  #
+  # Initialize a new table with the name of a .csv file or a .org file.  The
+  # initializer will populate the table with the first csv or org table
+  # structure found in either file.  You can also pass in an IO object for
+  # either type of file, but in that case, you need to specify '.csv' or
+  # '.ext' as the second argument to tell it what kind of file format to
+  # expect.  Finally, the constructor will also take an array of arrays or an
+  # array of hashes.   In the former case, if the second array's first element
+  # is a string that looks like a rule spearator, '-----------',
+  # '+----------', etc., the headers will be taken from the first array.  In
+  # the latter case, the keys of the hashes will be used as headers.  It is
+  # assumed that all the hashes have the same keys.
+  #
+  # In the resulting array of hashes, the headers are converted into symbols,
+  # with all spaces converted to underscore and everything down-cased.  So, the
+  # heading, 'Two Words' becomes the hash key :two_words.
+  #
+  class Table
+    attr_reader :rows
+
+    def initialize(input = nil, ext = '.csv')
+      case input
+      when NilClass
+        @rows = []
+      when IO, StringIO
+        case ext
+        when '.csv'
+          @rows = read_table_from_csv(input)
+        when '.org'
+          @rows = read_table_from_org(input)
+        else
+          raise "Don't know how to read a #{ext} file."
+        end
+      when String
+        ext = File.extname(input).downcase
+        File.open(input, 'r') do |io|
+          case ext
+          when '.csv'
+            @rows = read_table_from_csv(io)
+          when '.org'
+            @rows = read_table_from_org(io)
+          else
+            raise "Don't know how to read a #{ext} file."
+          end
+        end
+      when Array
+        case input[0]
+        when Array
+          @rows = read_table_from_array_of_arrays(input)
+        when Hash
+          @rows = read_table_from_array_of_hashes(input)
+        else
+          raise ArgumentError, "Table object initialized with unknown data type"
+        end
+      else
+        raise ArgumentError, "Table object initialized with unknown data type"
+      end
+    end
+
+    def <<(row)
+      @rows << row
+    end
+
+    def read_table_from_csv(io)
+      rows = []
+      ::CSV.new(io, headers: true, header_converters: :symbol,
+                skip_blanks: true).each do |row|
+        rows << row.to_hash
+      end
+      rows
+    end
+
+    # Form rows of table by reading the first table found in the org file.
+    def read_table_from_org(io)
+      # For determining when we're looking at lines of the table, after
+      # the table with name /table_name/ has been spotted.
+      table_re = /\A\s*\|/
+
+      rows = []
+      table_found = false
+      io.each do |line|
+        if !table_found
+          # Skip through the file until a table is found
+          if line =~ table_re
+            table_found = true
+          else
+            next
+          end
+        end
+        break unless line =~ table_re
+        line = line.sub(/\A\s*\|/, '').sub(/\|\s*\z/, '')
+        rows << line.split('|')
+      end
+      read_table_from_array_of_arrays(rows)
+    end
+
+    def read_table_from_array_of_arrays(rows)
+      hrule_re = /\A\s*[-+]+\s*\z/
+      headers = []
+      first_data_row = 0
+      if rows[1][0] =~ hrule_re
+        # Use first row as headers
+        headers = rows[0].map(&:as_sym)
+        first_data_row = 2
+      else
+        headers = (1..rows[0].size).to_a.map{|k| "col#{k}".as_sym }
+      end
+      hash_rows = []
+      rows[first_data_row..-1].each do |row|
+        row = row.map{ |s| s.to_s.strip }
+        hash_rows << Hash[headers.zip(row)]
+      end
+      hash_rows
+    end
+
+    def read_table_from_array_of_hashes(rows)
+      hash_rows = []
+      rows.each do |row|
+        hash = {}
+        row.each_pair do |k, v|
+          case k
+          when String
+            key = k.as_sym
+          when Symbol
+            key = k
+          else
+            key = k.to_s.as_sym
+          end
+          hash[key] = v.to_s.strip
+        end
+        hash_rows << hash
+      end
+      hash_rows
+    end
+
+    def headers
+      rows[0].keys
+    end
+
+    def column_sum(col)
+      rows.map{ |r| r[col].gsub(/[,$]/, '').to_f }.inject(:+)
+    end
+  end
+end