treasurer 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65f2e9677098bdac4956e3562dd33f66317c52df
-  data.tar.gz: 34118648a3281e1274a00f953887283937af5d76
+  metadata.gz: 931217424d6cdc37f7c8dcc760fd08bc9d5d2a3d
+  data.tar.gz: a48e8e11f67f770600ff93f6506a4eed78eb2c8d
 SHA512:
-  metadata.gz: 728db7d25466eb3f09bb2e47f0336dee0ea762624b899f7cc521584c17629de66818f584afbbefbdbeb4d351110381984b8075581c4df2da725a903bae864287
-  data.tar.gz: c1837491048206c26c5dc37104201ce2b5d232bbdb85135b0e2e3e482495d1ad52dcfbe17d2662fe860c4c0b06ac32be32c08fe9f3d8e16c90289339ff614f54
+  metadata.gz: abb2e38f758b4737b9084479661e274a2dcc5fb536b01327d032374991ab02da419fb33d412fdd26799da0ebe53b018bf73fe77cff90a361dfe3668384e232c1
+  data.tar.gz: 9abf97d6b4166d1e71b636d0486ab69369f7645644882b0d212541d19f37ae90e35cc4f8a823cdb3f39221ab9d99dd76ba9763c39b6cfa909d71082525f7edbe

data/Gemfile

@@ -1,9 +1,9 @@
 source "http://rubygems.org"
 # Add dependencies required to use your gem here.
 # Example:
-#   gem "activesupport", ">= 2.3.5"
+gem "activesupport", ">= 5.0.0"
     gem "coderunner", ">= 0.14.16"
-    gem "budgetcrmod", ">= 0.2.0"
+    gem "budgetcrmod", ">= 0.2.1"
     gem "command-line-flunky", ">= 1.0.0"
 
 # Add dependencies to develop your gem here.

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.5.0

data/lib/treasurer/accounts.rb

@@ -0,0 +1,307 @@
+class Treasurer::Reporter
+  class Account
+  end
+  class SubAccount < Account
+    def initialize(name, reporter, runner, runs, external, options={})
+      @name = name
+      @reporter = reporter
+      @runner = runner
+      #@projected_accounts_info =Hash[projected_accounts_info.find_all{|k,v| v[:account] == name}]
+      @external = external
+      @runs = runs.find_all{|r| r.sub_account  == name}
+      info[:external] = external if info
+      #ep ['sub_accounts333', name, @runs.size, runs.size]
+    end
+  end
+  class Account
+    attr_reader :name, :external, :runs, :currency
+    attr_accessor :projection, :average
+    def initialize(name, reporter, runner, runs, external, options={})
+      @name = name
+      @reporter = reporter
+      @runner = runner
+      @currency = options[:currency]
+      #@projected_accounts_info =Hash[projected_accounts_info.find_all{|k,v| v[:account] == name}]
+      @external = external
+      @runs = runs.find_all do |r| 
+        #p ['checking11', name, @currency, ACCOUNT_INFO[r.account]] if name == r.external_account and @currency and @external
+        #@external ? r.external_account : r.account) == name}
+        if not @external
+          r.account == name
+        elsif info and cur = info[:currencies] and cur.size > 1
+          #p ['checking11', name, @currency, ACCOUNT_INFO[r.account]] if name == r.external_account and @currency
+          r.external_account == name and acinfo = ACCOUNT_INFO[r.account] and acinfo[:currencies] == [@currency]
+        else 
+          r.external_account == name
+        end
+      end
+      #p ['Accountinf', name, @currency, @runs.size, runs.size]
+      info[:external] = external if info
+    end
+    def sub_accounts
+      @sub_accounts ||= @runs.map{|r| r.sub_account}.uniq.compact.map{|acc| SubAccount.new(acc, @reporter, @runner, @runs, @external, currency: @currency)}
+    end
+    def type
+      #account_type(name)
+      if ACCOUNT_INFO[name] and type = ACCOUNT_INFO[name][:type]
+        type
+      else
+        :Expense
+      end
+    end
+    def red_line(date)
+      if Treasurer::LocalCustomisations.instance_methods.include? :red_line
+        super(name, date)
+      else 
+        0.0
+      end
+    end
+    def report_start
+      @reporter.today - @reporter.days_before
+    end
+    def opening_date
+      (info && info[:start]) || @runs.map{|r| r.date}.min
+    end
+    def opening_balance
+      (info && info[:opening_balance]) || 0.0
+    end
+    def has_balance?
+      not @runs.find{|r| not r.has_balance?} 
+    end
+    def balance(date = @reporter.today) 
+      date_i = date.to_datetime.to_time.to_i
+      #if !date
+      #@runs.sort_by{|r| r.date}[-1].balance
+      if @external or not has_balance?
+        #p ['name is ', name, type]
+        #
+        balance = (@runs.find_all{|r| r.date <= date and r.date >= opening_date }.map{|r| money_in_sign * (r.deposit - r.withdrawal) * (@external ? -1 : 1)}.sum || 0.0)
+        balance += info[:opening_balance] if info[:opening_balance]
+        balance
+        #Temporary....
+        #0.0
+      else
+        #p ['name33 is ', name, type, @runs.size, @currency]
+        nearest_time = @runs.map{|r| (r.date_i - date_i).to_f.abs}.sort[0]
+        @runs.find_all{|r| (r.date_i - date_i).to_f.abs == nearest_time}.sort_by{|r| r.id}[-1].balance
+      end
+    end
+    def deposited(today, days_before, &block)
+      #p ['name22 is ', name, type, @runs.size]
+      #@runs.find_all{|r| r.days_ago(today) < days_before and (!block or yield(r)) }.map{|r| (@external and not ([:Liability, :Income].include?(type))) ? r.withdrawal : r.deposit }.sum || 0
+      @runs.find_all{|r| r.days_ago(today) < days_before and (!block or yield(r)) }.map{|r| (@external) ? r.withdrawal : r.deposit }.sum || 0
+    end
+    def withdrawn(today, days_before)
+      #@runs.find_all{|r| r.days_ago(today) < days_before }.map{|r| (@external and not ([:Liability, :Income].include?(type))) ? r.deposit : r.withdrawal }.sum || 0
+      @runs.find_all{|r| r.days_ago(today) < days_before }.map{|r| (@external) ? r.deposit : r.withdrawal }.sum || 0
+    end
+    def currency
+      @currency || (info[:currencies] && info[:currencies][0])
+    end
+    def currency_label
+      if @currency
+        " (#@currency)"
+      else
+        ''
+      end
+    end
+
+    def name_c
+      name + currency_label
+    end
+    def name_c_file
+      name_c.to_s.gsub(/[: ()]/, '_')
+    end
+
+    def summary_table(today, days_before)
+
+      <<EOF
+\\subsubsection{#{name_c}}
+\\begin{tabulary}{0.8\\textwidth}{ r | l}
+Balance & #{balance} \\\\
+Deposited & #{deposited(today, days_before)} \\\\
+Withdrawn & #{withdrawn(today, days_before)} \\\\
+\\end{tabulary}
+EOF
+    end
+    def summary_line(today, days_before)
+
+      <<EOF
+      #{name_c} & #{balance} & #{deposited(today, days_before)} & #{withdrawn(today, days_before)} 
+EOF
+    end
+    def money_in_sign
+      case type
+      when :Liability, :Income
+        -1.0
+      else
+        1.0
+      end
+    end
+    def discretionary
+      info and info[:discretionary]
+    end
+    def info
+      ACCOUNT_INFO[name] ||= {}
+    end
+    def projected_balance(date)
+      #return 0.0 if @external # Temporary Hack
+      #ep ['projected', @reporter.projected_accounts_info]
+      raise "Only should be called for Asset and Liability accounts" unless [:Asset, :Liability].include? type
+      non_discretionary_projected_balance(date)  -
+        @reporter.sum_regular(linked_projected_account_info, date)
+
+      #(discretionary ? @reporter.sum_regular({name => info}, date) : 0.0)
+    end
+    def linked_projected_account_info
+      Hash[@reporter.projected_accounts_info.find_all{|ext_ac,inf| inf[:linked_account] == name and ext_ac.currency == currency}]
+    end
+    def cache
+      @cache ||={}
+    end
+    def non_discretionary_projected_balance(date)
+      #ep ['FUTURE_INCOME', FUTURE_INCOME, name] if FUTURE_INCOME.size > 0
+      cache[[:non_discretionary_projected_balance, date]] ||= 
+        balance +
+        #@reporter.sum_regular(REGULAR_EXPENDITURE[name], date) + 
+        #@reporter.sum_regular(REGULAR_INCOME[name], date) -  
+        #@reporter.sum_future(FUTURE_EXPENDITURE[name], date) + 
+        #@reporter.sum_future(FUTURE_INCOME[name], date) + 
+        (FUTURE_TRANSFERS.keys.find_all{|from,to| to == name}.map{|key|
+          @reporter.sum_future(FUTURE_TRANSFERS[key], date) * money_in_sign
+        }.sum||0) - 
+        (FUTURE_TRANSFERS.keys.find_all{|from,to| from == name}.map{|key|
+          @reporter.sum_future( FUTURE_TRANSFERS[key], date) * money_in_sign
+        }.sum||0) +
+        (REGULAR_TRANSFERS.keys.find_all{|from,to| to == name}.map{|key|
+          @reporter.sum_regular(REGULAR_TRANSFERS[key], date) * money_in_sign
+        }.sum||0) - 
+        (REGULAR_TRANSFERS.keys.find_all{|from,to| from == name}.map{|key|
+          @reporter.sum_regular( REGULAR_TRANSFERS[key], date) * money_in_sign
+        }.sum||0)  
+    end
+    # Write an eps graph to disk of past and projected
+    # balance of the account
+    def write_balance_graph(today, days_before, days_ahead)
+      #accshort = name.gsub(/\s/, '')
+      if not (@external or type == :Equity or not has_balance?)
+        kit = @runner.graphkit(['date.to_time.to_i', 'balance'], {conditions: "account == #{name.inspect} and days_ago(Date.parse(#{today.to_s.inspect})) < #{days_before} and days_ago(Date.parse(#{today.to_s.inspect})) > -1", sort: '[date, id]'})
+      else
+        pastdates = (today-days_before..today).to_a
+        balances = pastdates.map{|date| balance(date)}
+        kit = GraphKit.quick_create([pastdates.map{|d| d.to_time.to_i}, balances])
+      end
+      futuredates = (today..today+days_ahead).to_a
+      projection = futuredates.map{|date| projected_balance(date) }
+      kit2 = GraphKit.quick_create([futuredates.map{|d| d.to_time.to_i}, projection])
+      red = futuredates.map{|date| red_line(date)}
+      kit3 = GraphKit.quick_create([futuredates.map{|d| d.to_time.to_i}, red])
+      @reporter.projected_account_factor = @reporter.in_limit_discretionary_account_factors[currency]
+      limit = futuredates.map{|date| projected_balance(date)}
+      kit4 = GraphKit.quick_create([futuredates.map{|d| d.to_time.to_i}, limit])
+      @reporter.projected_account_factor = @reporter.stable_discretionary_account_factors[currency]
+      #ep ['projected_account_factor!!!!', @reporter.projected_account_factor]
+      stable = futuredates.map{|date| projected_balance(date)}
+      kit5 = GraphKit.quick_create([futuredates.map{|d| d.to_time.to_i}, stable])
+      #exit
+      @reporter.projected_account_factor = nil
+      kit += (kit2 + kit4 + kit5)
+      #kit += (kit2)
+      kit = kit3 + kit
+      kit.title = "Balance for #{name_c}"
+      kit.xlabel = %['Date' offset 0,-2]
+      kit.xlabel = nil
+      kit.ylabel = "Balance"
+
+
+      kit.data[0].gp.title = 'Limit'
+      kit.data[1].gp.title = 'Previous'
+      kit.data[2].gp.title = '0 GBP Discretionary'
+      kit.data[2].gp.title = 'Projection'
+      kit.data[3].gp.title = 'Limit'
+      kit.data[4].gp.title = 'Stable'
+      kit.data.each{|dk| dk.gp.with = "l lw 5"}
+      kit.gp.key = ' bottom left '
+      kit.gp.key = ' rmargin '
+
+      #(p kit; STDIN.gets) if name == :LloydsCreditCard
+      CodeRunner::Budget.kit_time_format_x(kit)
+
+      fork do
+        (kit).gnuplot_write("#{name_c_file}_balance.eps", size: "4.0in,1.5in") #, latex: true)
+        %x[epspdf #{name_c_file}_balance.eps]
+      end
+      #%x[epspdf #{name}_balance.eps]
+    end
+    # A string to include the balance graph in the document
+    def balance_graph_string
+      #accshort = name.gsub(/\s/, '')
+      #"\\begin{center}\\includegraphics[width=3.0in]{#{name}_balance.eps}\\end{center}"
+      #"\\begin{center}\\includegraphics[width=0.9\\textwidth]{#{name}_balance.eps}\\end{center}"
+      "\\myfigure{#{name_c_file}_balance.pdf}"
+    end
+  end
+  class Equity < Account
+    def initialize(reporter, runner, accounts, options={})
+      @reporter = reporter
+      @runner = runner
+      @accounts = accounts #.find_all{|acc| not acc.external}
+      @currency = options[:currency]
+    end
+    def type
+      :Equity
+    end
+    def name
+      :Equity
+    end
+    def red_line(date)
+      @accounts.map{|acc|
+        case acc.type
+        when :Asset
+          acc.red_line(date)
+        when :Liability
+          -acc.red_line(date)
+        else
+          0.0
+        end
+      }.sum
+    end
+    def balance(date=@reporter.today)
+      @accounts.map{|acc|
+        case acc.type
+        when :Asset
+          acc.balance(date)
+        when :Liability
+          -acc.balance(date)
+        else
+          0.0
+        end
+      }.sum
+    end
+    def projected_balance(date=@reporter.today)
+      @accounts.map{|acc|
+        case acc.type
+        when :Asset
+          acc.projected_balance(date)
+        when :Liability
+          -acc.projected_balance(date)
+        else
+          0.0
+        end
+      }.sum
+    end
+    def summary_table(today, days_before)
+
+      <<EOF
+\\subsubsection{#{name}}
+\\begin{tabulary}{0.8\\textwidth}{ r | l}
+Balance & #{balance} \\\\
+\\end{tabulary}
+EOF
+    end
+    def summary_line(today, days_before)
+      "#{name_c} & #{balance(today)} &  & "
+    end
+  end
+end
+

data/lib/treasurer/analysis.rb

@@ -6,32 +6,32 @@ module Analysis
 	# period, along with a list of the expenditures
 	# for each period and a list of the items within
 	# each period
-	def account_expenditure(account, account_info, options={})
+	def account_expenditure(account, options={})
 		dates = []
 		expenditures = []
 		account_items = []
-		date = account_info[:end]||@today
-		start_date = [(account_info[:start]||@start_date), @start_date].max
+		date = account.info[:end]||@today
+		#start_date = [(account.info[:start]||@start_date), @start_date].max
 		expenditure = 0
 		items_temp = []
-		items = @runner.component_run_list.values.find_all{|r| r.external_account == account and r.in_date(account_info)}
-		#ep ['items', items]
-		#ep ['account', account]
+    items = @runner.component_run_list.values.find_all{|r| r.external_account == account.name and r.in_date(account.info) and @accounts_hash[r.account].currency == account.currency}
+    #ep ['items', items.map{|i| i.date}]
+    #ep ['account', account.name_c]
 		counter = 0
-		if not account_info[:period]
+		if not account.info[:period]
 			dates.push date
 			account_items.push items
-			expenditures.push (items.map{|r| (r.deposit - r.withdrawal) * (account_info[:external] ? -1 : 1)}+[0]).sum
+			expenditures.push (items.map{|r| (r.deposit - r.withdrawal) * (account.info[:external] ? -1 : 1)}+[0]).sum
 		else
 
-			case account_info[:period][1]
+			case account.info[:period][1]
 			when :month
 				while date > @start_date
 					items_temp += items.find_all{|r| r.date == date}
-					if date.mday == (account_info[:monthday] or 1)
+					if date.mday == (account.info[:monthday] or 1)
 						counter +=1
-						if counter % account_info[:period][0] == 0
-							expenditure = (items_temp.map{|r| (r.deposit - r.withdrawal) * (account_info[:external] ? -1 : 1)}+[0]).sum
+						if counter % account.info[:period][0] == 0
+							expenditure = (items_temp.map{|r| (r.deposit - r.withdrawal) * (account.info[:external] ? -1 : 1)}+[0]).sum
 							dates.push date
 							expenditures.push expenditure
 							account_items.push items_temp
@@ -46,8 +46,8 @@ module Analysis
 					items_temp += items.find_all{|r| r.date == date}
 					#expenditure += (account_items[-1].map{|r| r.debit}+[0]).sum
 					counter +=1
-					if counter % account_info[:period][0] == 0
-						expenditure = (items_temp.map{|r| (r.deposit - r.withdrawal) * (account_info[:external] ? -1 : 1)}+[0]).sum
+					if counter % account.info[:period][0] == 0
+						expenditure = (items_temp.map{|r| (r.deposit - r.withdrawal) * (account.info[:external] ? -1 : 1)}+[0]).sum
 						dates.push date
 						expenditures.push expenditure
 						account_items.push items_temp
@@ -68,21 +68,21 @@ module Analysis
 	 projected_accounts_info.each{|key,v| projected_accounts_info[key]=projected_accounts_info[key].dup}
 	 projected_accounts_info.each do |account, account_info|
 		 #account_info = accounts[account]
-		 dates, expenditures, items = account_expenditure(account, account_info)
-		 account_info[:average] = expenditures.mean rescue 0.0
+		 _dates, expenditures, _items = account_expenditure(account, account_info)
+     account.average = expenditures.mean rescue 0.0
 	 end
 	 projected_accounts_info
 	end
 	# Work out the projected spend from the account and include it in the account info
-	def accounts_with_projections(accounts, options={})
-	 projected_accounts_info = accounts.dup
-	 projected_accounts_info.each{|key,v| projected_accounts_info[key]=projected_accounts_info[key].dup}
-	 projected_accounts_info.each do |account, account_info|
+	def accounts_with_projections(projected_accounts, options={})
+	 #projected_accounts_info = accounts.dup
+	 #projected_accounts_info.each{|key,v| projected_accounts_info[key]=projected_accounts_info[key].dup}
+	 projected_accounts.each do |account|
 		 #account_info = accounts[account]
-		 dates, expenditures, items = account_expenditure(account, account_info)
-		 account_info[:projection] = expenditures.mean rescue 0.0
+		 _dates, expenditures, _items = account_expenditure(account)
+		 account.projection = expenditures.mean rescue 0.0
 	 end
-	 projected_accounts_info
+   projected_accounts.map{|acc| [acc, acc.info]}.to_h
 	end
 	## Get a list of accounts to be included in the report
 	## i.e. accounts with non-empty expenditure
@@ -96,9 +96,11 @@ module Analysis
 	# expenditure from that account based on past
 	# expenditure (currently only a simple average)
 	def get_projected_accounts
-		 @projected_accounts_info = Hash[ACCOUNT_INFO.dup.find_all{|k,v| v[:discretionary]}]
-		 @projected_accounts_info = accounts_with_projections(@projected_accounts_info)
+		 #@projected_accounts_info = Hash[ACCOUNT_INFO.dup.find_all{|k,v| v[:discretionary]}]
+		 #@projected_accounts_info = accounts_with_projections(@projected_accounts_info)
 		 #@projected_accounts_info = @accounts.find_all{|acc| info = ACCOUNT_INFO[acc.name] and info[:discretionary]} 
+    projected_accounts = @accounts.find_all{|acc| acc.info and acc.info[:discretionary]}
+    @projected_accounts_info = accounts_with_projections(projected_accounts)
 	end
 	# Calculate the sum of all items within future
 	# items that fall before end_date
@@ -121,7 +123,7 @@ module Analysis
 	# regular items that falls within the account period
 	def sum_regular(regular_items, end_date, options={})
 	  #end_date = @today + @days_ahead
-		sum = regular_items.inject(0) do |sum, (name, item)|	
+		sum_out = regular_items.inject(0) do |sum, (account, item)|	
 			item = [item] unless item.kind_of? Array
 #			  ep item
 			value = item.inject(0) do |value,info|
@@ -182,13 +184,13 @@ module Analysis
 
         #ep ['name2234', name, info, @projected_account_factor] if info[:discretionary]
 
-				value + nunits * (info[:size]||info[:projection]*(@projected_account_factor||1.0))
+        value + nunits * (info[:size]||account.projection*(@projected_account_factor||1.0))
 
 			end
 			sum + value
 			#(rcp.excluding? and rcp.excluding.include?(name)) ? sum : sum + value
 		end
-		sum
+		sum_out
 	end
 end
 	include Analysis

data/lib/treasurer/commands.rb

@@ -2,7 +2,7 @@
 class Treasurer
 class << self
 	def add_file(file, account, copts={})
-		load_treasurer_folder
+		load_treasurer_folder(copts)
 		ep 'entries', Dir.entries
 		CodeRunner.submit(p: "{data_file: '#{File.expand_path(file)}', account: :#{account}}")
 	end
@@ -23,9 +23,13 @@ class << self
 		reporter.report()
 	end
 	def fetch_reporter(copts = {})
-		load_treasurer_folder
-		reporter = Reporter.new(CodeRunner.fetch_runner(h: :component), days_before: copts[:b]||360, days_ahead: copts[:a]||180, today: copts[:t])
+		load_treasurer_folder(copts)
+		reporter = Reporter.new(CodeRunner.fetch_runner(h: :component, A: true), days_before: copts[:b]||360, days_ahead: copts[:a]||180, today: copts[:t])
 	end
+  def status(copts={})
+    load_treasurer_folder(copts)
+    CodeRunner.status(eval(copts[:C]||"{}"))
+  end
 	def init_root_folder(folder, copts={})
 		raise "Folder already exists" if FileTest.exist? folder
 		FileUtils.makedirs(folder)
@@ -33,15 +37,16 @@ class << self
 		CodeRunner.fetch_runner(Y: folder, C: 'budget', X: '/dev/null')
 		eputs "\n\n Your treasurer folder '#{folder}' has been set up. All further treasurer commands should be run from within this folder.\n"
 	end
-	def load_treasurer_folder
+	def load_treasurer_folder(copts={})
 		check_is_treasurer_folder
 		Treasurer.send(:remove_const, :LocalCustomisations) if defined? Treasurer::LocalCustomisations
     load 'local_customisations.rb'
 		Treasurer::Reporter.send(:include, Treasurer::LocalCustomisations)
 		Treasurer::Reporter::Account.send(:include, Treasurer::LocalCustomisations)
 		Treasurer::Reporter::Analysis.send(:include, Treasurer::LocalCustomisations)
-		runner = CodeRunner.fetch_runner
+    require 'budgetcrmod'
 		CodeRunner::Budget.send(:include, Treasurer::LocalCustomisations)
+		_runner = CodeRunner.fetch_runner(eval(copts[:C]||"{}"))
 	end
 
 	def method_missing(meth, *args)