rvgp 0.3.2

data/test/test_plot.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'csv'
+require 'minitest/autorun'
+
+require_relative '../lib/rvgp'
+require_relative '../lib/rvgp/plot'
+
+# Tests for RVGP::Plot
+class TestPlot < Minitest::Test
+  YEAR_ONLY_CORPUS = [
+    '/path/to/ledger/2018-wealth-growth.csv',
+    '/path/to/ledger/2019-wealth-growth.csv',
+    '/path/to/ledger/2020-wealth-growth.csv',
+    '/path/to/ledger/2021-wealth-growth.csv',
+    '/path/to/ledger/2022-wealth-growth.csv',
+    # These are meant to be ignored:
+    '/path/to/ledger/2018-profit-and-loss.csv',
+    '/path/to/ledger/2019-profit-and-loss.csv',
+    '/path/to/ledger/2020-profit-and-loss.csv',
+    '/path/to/ledger/2021-profit-and-loss.csv'
+  ].freeze
+
+  YEAR_AND_INTENTION_CORPUS = [
+    'build/grids/2018-cashflow-burgershop.csv',
+    'build/grids/2018-cashflow-multiplex.csv',
+    'build/grids/2018-cashflow-ignored.csv',
+    'build/grids/2018-cashflow-personal.csv',
+    # NOTE: We sold the frozenbananastand in 2018, so, there's no 2019 grid
+    'build/grids/2018-cashflow-frozenbananastand.csv',
+    'build/grids/2019-cashflow-burgershop.csv',
+    'build/grids/2019-cashflow-multiplex.csv',
+    'build/grids/2019-cashflow-ignored.csv',
+    'build/grids/2019-cashflow-personal.csv',
+    # These are meant to be ignored:
+    '/path/to/ledger/2018-profit-and-loss.csv',
+    '/path/to/ledger/2019-profit-and-loss.csv',
+    '/path/to/ledger/2020-profit-and-loss.csv',
+    '/path/to/ledger/2021-profit-and-loss.csv'
+  ].freeze
+
+  def test_globber
+    matches = RVGP::Plot.glob_variants '%{year}-wealth-growth.csv', YEAR_ONLY_CORPUS # rubocop:disable Style/FormatStringToken
+
+    assert_equal 5, matches.length
+
+    0.upto(4).map do |i|
+      year = 2018 + i
+      assert_equal [format('/path/to/ledger/%d-wealth-growth.csv', year)], matches[i][:files]
+      assert_equal format('%d-wealth-growth', year), matches[i][:name]
+      assert_equal({ year: year.to_s }, matches[i][:pairs])
+    end
+
+    matches = RVGP::Plot.glob_variants '%{year}-cashflow-%{intention}.csv', YEAR_AND_INTENTION_CORPUS # rubocop:disable Style/FormatStringToken
+
+    assert_equal 9, matches.length
+
+    assert_equal ['build/grids/2018-cashflow-burgershop.csv'], matches[0][:files]
+    assert_equal '2018-cashflow-burgershop', matches[0][:name]
+    assert_equal({ year: '2018', intention: 'burgershop' }, matches[0][:pairs])
+
+    assert_equal ['build/grids/2018-cashflow-multiplex.csv'], matches[1][:files]
+    assert_equal '2018-cashflow-multiplex', matches[1][:name]
+    assert_equal({ year: '2018', intention: 'multiplex' }, matches[1][:pairs])
+
+    assert_equal ['build/grids/2018-cashflow-ignored.csv'], matches[2][:files]
+    assert_equal '2018-cashflow-ignored', matches[2][:name]
+    assert_equal({ year: '2018', intention: 'ignored' }, matches[2][:pairs])
+
+    assert_equal ['build/grids/2018-cashflow-personal.csv'], matches[3][:files]
+    assert_equal '2018-cashflow-personal', matches[3][:name]
+    assert_equal({ year: '2018', intention: 'personal' }, matches[3][:pairs])
+
+    assert_equal ['build/grids/2018-cashflow-frozenbananastand.csv'], matches[4][:files]
+    assert_equal '2018-cashflow-frozenbananastand', matches[4][:name]
+    assert_equal({ year: '2018', intention: 'frozenbananastand' }, matches[4][:pairs])
+
+    assert_equal ['build/grids/2019-cashflow-burgershop.csv'], matches[5][:files]
+    assert_equal '2019-cashflow-burgershop', matches[5][:name]
+    assert_equal({ year: '2019', intention: 'burgershop' }, matches[5][:pairs])
+
+    assert_equal ['build/grids/2019-cashflow-multiplex.csv'], matches[6][:files]
+    assert_equal '2019-cashflow-multiplex', matches[6][:name]
+    assert_equal({ year: '2019', intention: 'multiplex' }, matches[6][:pairs])
+
+    assert_equal ['build/grids/2019-cashflow-ignored.csv'], matches[7][:files]
+    assert_equal '2019-cashflow-ignored', matches[7][:name]
+    assert_equal({ year: '2019', intention: 'ignored' }, matches[7][:pairs])
+
+    assert_equal ['build/grids/2019-cashflow-personal.csv'], matches[8][:files]
+    assert_equal '2019-cashflow-personal', matches[8][:name]
+    assert_equal({ year: '2019', intention: 'personal' }, matches[8][:pairs])
+  end
+
+  def test_all_year_globber
+    matches = RVGP::Plot.glob_variants '%{year}-wealth-growth.csv', YEAR_ONLY_CORPUS, year: 'all' # rubocop:disable Style/FormatStringToken
+
+    assert_equal 1, matches.length
+
+    assert_equal ['/path/to/ledger/2018-wealth-growth.csv',
+                  '/path/to/ledger/2019-wealth-growth.csv',
+                  '/path/to/ledger/2020-wealth-growth.csv',
+                  '/path/to/ledger/2021-wealth-growth.csv',
+                  '/path/to/ledger/2022-wealth-growth.csv'], matches[0][:files]
+    assert_equal 'all-wealth-growth', matches[0][:name]
+    assert_equal({ year: 'all' }, matches[0][:pairs])
+
+    matches = RVGP::Plot.glob_variants '%{year}-cashflow-%{intention}.csv', YEAR_AND_INTENTION_CORPUS, year: 'all' # rubocop:disable Style/FormatStringToken
+
+    assert_equal 5, matches.length
+
+    assert_equal(%w[2018 2019].map { |y| format('build/grids/%s-cashflow-burgershop.csv', y) }, matches[0][:files])
+    assert_equal 'all-cashflow-burgershop', matches[0][:name]
+    assert_equal({ year: 'all', intention: 'burgershop' }, matches[0][:pairs])
+
+    assert_equal(%w[2018 2019].map { |y| format('build/grids/%s-cashflow-multiplex.csv', y) }, matches[1][:files])
+    assert_equal 'all-cashflow-multiplex', matches[1][:name]
+    assert_equal({ year: 'all', intention: 'multiplex' }, matches[1][:pairs])
+
+    assert_equal(%w[2018 2019].map { |y| format('build/grids/%s-cashflow-ignored.csv', y) }, matches[2][:files])
+    assert_equal 'all-cashflow-ignored', matches[2][:name]
+    assert_equal({ year: 'all', intention: 'ignored' }, matches[2][:pairs])
+
+    assert_equal(%w[2018 2019].map { |y| format('build/grids/%s-cashflow-personal.csv', y) }, matches[3][:files])
+    assert_equal 'all-cashflow-personal', matches[3][:name]
+    assert_equal({ year: 'all', intention: 'personal' }, matches[3][:pairs])
+
+    assert_equal ['build/grids/2018-cashflow-frozenbananastand.csv'], matches[4][:files]
+    assert_equal 'all-cashflow-frozenbananastand', matches[4][:name]
+    assert_equal({ year: 'all', intention: 'frozenbananastand' }, matches[4][:pairs])
+  end
+end

data/test/test_posting.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'date'
+require 'minitest/autorun'
+
+require_relative '../lib/rvgp'
+require_relative '../lib/rvgp/journal'
+
+# Tests for RVGP::Journal::Posting
+class TestPosting < Minitest::Test
+  def test_posting_to_ledger
+    posting = RVGP::Journal::Posting.new(
+      Date.new(2021, 10, 2),
+      'Heroes R Us',
+      tags: ['Vacation: Seattle'.to_tag],
+      transfers: [
+        ['Expenses:Comics', { commodity: '$ 5.00'.to_commodity, tags: ['Publisher: Marvel'.to_tag] }],
+        ['Expenses:Cards', { commodity: '$ 9.00'.to_commodity, tags: ['Collection: Baseball'.to_tag] }],
+        ['Cash']
+      ].collect { |args| RVGP::Journal::Posting::Transfer.new(*args) }
+    )
+
+    assert_equal [
+      '2021-10-02 Heroes R Us',
+      '  ; Vacation: Seattle',
+      '  Expenses:Comics    $ 5.00',
+      '  ; Publisher: Marvel',
+      '  Expenses:Cards     $ 9.00',
+      '  ; Collection: Baseball',
+      '  Cash'
+    ].join("\n"), posting.to_ledger
+  end
+
+  def test_posting_with_complex_commodity_to_ledger
+    complex_commodity = RVGP::Journal::ComplexCommodity.from_s(['-1000.0001 VBTLX', '@@', '$ 100000.00'].join(' '))
+
+    posting = RVGP::Journal::Posting.new(
+      '2022-03-28',
+      'VANGUARD TOTAL BOND MARKET INDEX Sell',
+      transfers: [RVGP::Journal::Posting::Transfer.new('Personal:Assets:Vanguard:VBTLX', commodity: complex_commodity),
+                  RVGP::Journal::Posting::Transfer.new('Personal:Assets:Vanguard:MoneyMarket')]
+    )
+
+    assert_equal ['2022-03-28 VANGUARD TOTAL BOND MARKET INDEX Sell',
+                  '  Personal:Assets:Vanguard:VBTLX    -1000.0001 VBTLX @@ $ 100000.00',
+                  '  Personal:Assets:Vanguard:MoneyMarket'].join("\n"),
+                 posting.to_ledger
+  end
+end

data/test/test_pricer.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'time'
+require 'minitest/autorun'
+
+require_relative '../lib/rvgp'
+
+# Tests for RVGP::Journal::Pricer
+class TestPricer < Minitest::Test
+  TEST_PRICES_DB_FORMAT1 = <<~DB_FORMAT1
+    P 2004/06/25 00:00:00 FEQTX $24.00
+    P 2004/06/21 02:18:01 FEQTX $22.49
+    P 2004/06/21 02:18:01 BORL $6.20
+    P 2004/06/21 02:18:02 AAPL $32.91
+    P 2004/06/21 02:18:02 AU $400.00
+    P 2004/06/21 14:15:00 FEQTX $ 22.75
+    P 2004/06/25 01:00:00 BORL $6.20
+    P 2004/06/25 02:00:00 AAPL $32.91
+    P 2004/06/25 03:18:02 AU $400.00
+  DB_FORMAT1
+
+  TEST_PRICES_DB_FORMAT2 = <<~DB_FORMAT2
+    P 2020-01-01 USD 0.893179 EUR
+    P 2020-02-01 EUR 1.109275 USD
+    P 2020-03-01 USD 0.907082  EUR
+  DB_FORMAT2
+
+  TEST_PRICES_LARGE_ASSETS = <<~LARGE_ASSETS
+    P 2018/01/01 FLORIDAHOME  $500,000.00
+    P 2018/01/01 CORVETTE  $50,000.00
+  LARGE_ASSETS
+
+  def test_price_format1
+    p = RVGP::Journal::Pricer.new TEST_PRICES_DB_FORMAT1
+
+    assert_raises(RVGP::Journal::Pricer::NoPriceError) { price_on p, '1900-01-01', 'FEQTX', 'USD' }
+    assert_raises(RVGP::Journal::Pricer::NoPriceError) { price_on p, '2004-06-20', 'FEQTX', '$' }
+    assert_raises(RVGP::Journal::Pricer::NoPriceError) { price_on p, '2004-06-21', 'FEQTX', 'USD' }
+
+    assert_equal '$ 22.49', price_on(p, '2004-06-21 12:00:00', 'FEQTX', '$')
+    assert_equal '$ 22.49', price_on(p, '2004-06-21 14:14:59', 'FEQTX', 'USD')
+    assert_equal '$ 22.75', price_on(p, '2004-06-21 14:15:00', 'FEQTX', '$')
+    assert_equal '$ 22.75', price_on(p, '2004-06-21 14:15:01', 'FEQTX', 'USD')
+    assert_equal '$ 22.75', price_on(p, '2004-06-22', 'FEQTX', '$')
+    assert_equal '$ 24.00', price_on(p, '2004-06-25', 'FEQTX', 'USD')
+    assert_equal '$ 24.00', price_on(p, '2300-01-01', 'FEQTX', '$')
+
+    # This is the same set of tests as above, but ,inverted:
+    # Probably this doesn't make much sense in production, but, we use it with
+    # fiat currencies later:
+    assert_raises(RVGP::Journal::Pricer::NoPriceError) { price_on p, '1900-01-01', 'USD', 'FEQTX' }
+    assert_raises(RVGP::Journal::Pricer::NoPriceError) { price_on p, '2004-06-20', '$', 'FEQTX' }
+    assert_raises(RVGP::Journal::Pricer::NoPriceError) { price_on p, '2004-06-21', 'USD', 'FEQTX' }
+
+    assert_equal '0.0444642063139173 FEQTX', price_on(p, '2004-06-21 12:00:00', 'USD', 'FEQTX')
+    assert_equal '0.0444642063139173 FEQTX', price_on(p, '2004-06-21 14:14:59', '$', 'FEQTX')
+    assert_equal '0.04395604395604396 FEQTX', price_on(p, '2004-06-21 14:15:00', 'USD', 'FEQTX')
+    assert_equal '0.04395604395604396 FEQTX', price_on(p, '2004-06-21 14:15:01', '$', 'FEQTX')
+    assert_equal '0.04395604395604396 FEQTX', price_on(p, '2004-06-22', 'USD', 'FEQTX')
+    assert_equal '0.04166666666666667 FEQTX', price_on(p, '2004-06-25', '$', 'FEQTX')
+    assert_equal '0.04166666666666667 FEQTX', price_on(p, '2300-01-01', 'USD', 'FEQTX')
+  end
+
+  def test_price_format2
+    p = RVGP::Journal::Pricer.new TEST_PRICES_DB_FORMAT2
+
+    assert_raises(RVGP::Journal::Pricer::NoPriceError) { price_on p, '2019-12-31', 'EUR', 'USD' }
+    assert_raises(RVGP::Journal::Pricer::NoPriceError) { price_on p, '2019-12-31', 'USD', 'EUR' }
+
+    assert_equal '1.11959640788688494 USD', price_on(p, '2020-01-01', 'EUR', 'USD')
+    assert_equal '0.893179 EUR', price_on(p, '2020-01-01', 'USD', 'EUR')
+
+    assert_equal '1.11959640788688494 USD', price_on(p, '2020-01-15', 'EUR', 'USD')
+    assert_equal '0.893179 EUR', price_on(p, '2020-01-15', 'USD', 'EUR')
+
+    assert_equal '1.109275 USD', price_on(p, '2020-02-01', 'EUR', 'USD')
+    assert_equal '0.90148971174866467 EUR', price_on(p, '2020-02-01', 'USD', 'EUR')
+
+    assert_equal '1.10243616343395636 USD', price_on(p, '2020-03-01', 'EUR', 'USD')
+    assert_equal '0.907082 EUR', price_on(p, '2020-03-01', 'USD', 'EUR')
+
+    assert_equal '1.10243616343395636 USD', price_on(p, '2020-03-01', 'EUR', 'USD')
+    assert_equal '0.907082 EUR', price_on(p, '2020-03-15', 'USD', 'EUR')
+  end
+
+  def test_price_format3
+    p = RVGP::Journal::Pricer.new TEST_PRICES_LARGE_ASSETS
+
+    # Make sure the database is parsed ok:
+    assert_equal '$ 500000.00', price_on(p, '2020-01-01 12:00:00', 'FLORIDAHOME', '$')
+    assert_equal '$ 50000.00', price_on(p, '2020-01-01 12:00:00', 'CORVETTE', '$')
+
+    # I don't think anyone will ever do this, but, why not:
+    assert_equal '0.000002 FLORIDAHOME', price_on(p, '2020-01-01 12:00:00', '$', 'FLORIDAHOME')
+    assert_equal '0.00002 CORVETTE', price_on(p, '2020-01-01 12:00:00', '$', 'CORVETTE')
+
+    # And now get fancy with the conversions:
+    at = Date.new(2020, 1, 1).to_time
+
+    dollar = '$ 1.00'.to_commodity
+    home = '1 FLORIDAHOME'.to_commodity
+    minus_home = '-1 FLORIDAHOME'.to_commodity
+    minus_dollar = '$ -1.00'.to_commodity
+
+    assert_equal '$ 500000.00', p.convert(at, home, '$').to_s
+    assert_equal '$ -500000.00', p.convert(at, minus_home, '$').to_s
+
+    assert_equal '0.000002 FLORIDAHOME', p.convert(at, dollar, 'FLORIDAHOME').to_s
+    assert_equal '-0.000002 FLORIDAHOME', p.convert(at, minus_dollar, 'FLORIDAHOME').to_s
+  end
+
+  def test_price_insert
+    pricer = RVGP::Journal::Pricer.new
+    pricer.add(Date.new(2020, 8, 1), 'ABC', '$ 0.80'.to_commodity)
+    pricer.add(Date.new(2020, 1, 1), 'ABC', '0.10 USD'.to_commodity)
+    pricer.add(Date.new(2020, 2, 1), 'ABC', '$0.20'.to_commodity)
+    pricer.add(Date.new(2020, 3, 1), 'ABC', '0.30 USD'.to_commodity)
+    pricer.add(Date.new(2020, 4, 1), 'ABC', '$0.40'.to_commodity)
+    pricer.add(Date.new(2020, 6, 1), 'ABC', '0.60 USD'.to_commodity)
+    pricer.add(Date.new(2020, 7, 1), 'ABC', '$0.70'.to_commodity)
+    pricer.add(Date.new(2020, 5, 1), 'ABC', '0.50 USD'.to_commodity)
+
+    assert_equal '0.10 USD', price_on(pricer, '2020-01-15', 'ABC', '$')
+    assert_equal '$ 0.20',   price_on(pricer, '2020-02-15', 'ABC', '$')
+    assert_equal '0.30 USD', price_on(pricer, '2020-03-15', 'ABC', '$')
+    assert_equal '$ 0.40',   price_on(pricer, '2020-04-15', 'ABC', '$')
+    assert_equal '0.50 USD', price_on(pricer, '2020-05-15', 'ABC', '$')
+    assert_equal '0.60 USD', price_on(pricer, '2020-06-15', 'ABC', '$')
+    assert_equal '$ 0.70',   price_on(pricer, '2020-07-15', 'ABC', '$')
+    assert_equal '$ 0.80',   price_on(pricer, '2020-08-15', 'ABC', '$')
+  end
+
+  private
+
+  def price_on(pricer, date_str, code_from, code_to)
+    pricer.price(Time.parse(date_str), code_from, code_to).to_s
+  end
+end