hledger-forecast 1.5.1 → 2.0.0

data/lib/hledger_forecast/settings.rb

@@ -1,41 +1,56 @@
 module HledgerForecast
-  # Set the options from a user's confgi
+  # Set the options from a user's config
   class Settings
     def self.config(forecast, cli_options)
       settings = {}
+      settings[:max_amount] = 0
+      settings[:max_category] = 0
 
-      settings[:max_amount] = get_max_field_size(forecast, 'amount') + 1 # +1 for the negatives
-      settings[:max_category] = get_max_field_size(forecast, 'category')
+      forecast.each do |row|
+        if row['type'] != 'settings'
+          category_length = row['category'].length
+          settings[:max_category] = category_length if category_length > settings[:max_category]
 
-      settings[:currency] = Money::Currency.new(forecast.fetch('settings', {}).fetch('currency', 'USD'))
-      settings[:show_symbol] = forecast.fetch('settings', {}).fetch('show_symbol', true)
-      # settings[:sign_before_symbol] = forecast.fetch('settings', {}).fetch('sign_before_symbol', false)
-      settings[:thousands_separator] = forecast.fetch('settings', {}).fetch('thousands_separator', true)
+          amount = if row['amount'].is_a?(Integer) || row['amount'].is_a?(Float)
+                     ((row['amount'] + 3) * 100).to_s
+                   else
+                     row['amount'].to_s
+                   end
 
-      settings.merge!(cli_options) if cli_options
-
-      settings
-    end
+          settings[:max_amount] = amount.length if amount.length > settings[:max_amount]
+        end
 
-    def self.get_max_field_size(block, field)
-      max_size = 0
-
-      block.each do |period, items|
-        next if %w[settings].include?(period)
-
-        items.each do |item|
-          item['transactions'].each do |t|
-            field_value = if t[field].is_a?(Integer) || t[field].is_a?(Float)
-                            ((t[field] + 3) * 100).to_s
-                          else
-                            t[field].to_s
-                          end
-            max_size = [max_size, field_value.length].max
-          end
+        if row['type'] == 'settings'
+
+          settings[:currency] = if row['frequency'] == "currency"
+                                  row['account']
+                                else
+                                  "USD"
+                                end
+
+          settings[:show_symbol] = if row['frequency'] == "show_symbol"
+                                     row['account']
+                                   else
+                                     true
+                                   end
+
+          settings[:sign_before_symbol] = if row['frequency'] == "sign_before_symbol"
+                                            row['account']
+                                          else
+                                            false
+                                          end
+
+          settings[:thousands_separator] = if row['frequency'] == "thousands_separator"
+                                             row['account']
+                                           else
+                                             ","
+                                           end
         end
+
+        settings.merge!(cli_options) if cli_options
       end
 
-      max_size
+      settings
     end
   end
 end

data/lib/hledger_forecast/summarizer.rb

@@ -6,67 +6,46 @@ module HledgerForecast
     end
 
     def summarize(config, cli_options = nil)
-      @forecast = YAML.safe_load(config)
+      @forecast = CSV.parse(config, headers: true)
       @settings = Settings.config(@forecast, cli_options)
 
-      return { output: generate(@forecast), settings: @settings }
+      { output: generate(@forecast), settings: @settings }
     end
 
     private
 
     def generate(forecast)
-      output = {}
-      forecast.each do |period, blocks|
-        next if %w[settings].include?(period)
-
-        blocks.each do |block|
-          key = if @settings[:roll_up].nil?
-                  period
-                else
-                  output.length
-                end
-
-          output[key] ||= []
-          output[key] << process_block(period, block)
-        end
-      end
-
-      output = filter_out(flatten_and_merge(output))
-      output = calculate_rolled_up_amount(output) unless @settings[:roll_up].nil?
-
-      output
-    end
-
-    def process_block(period, block)
       output = []
 
-      output << {
-        account: block['account'],
-        from: Date.parse(block['from']),
-        to: block['to'] ? Date.parse(block['to']) : nil,
-        type: period,
-        frequency: block['frequency'],
-        transactions: []
-      }
+      forecast.each do |row|
+        next if row['type'] == 'settings'
+        next if row['summary_exclude']
 
-      process_transactions(period, block, output)
-    end
+        row['amount'] = Utilities.convert_amount(row['amount'])
 
-    def process_transactions(period, block, output)
-      block['transactions'].each do |t|
-        amount = Calculator.new.evaluate(t['amount'])
+        begin
+          annualised_amount = row['roll-up'] ? row['amount'] * row['roll-up'].to_f : row['amount'] * annualise(row['type'])
+        rescue StandardError
+          puts "\nError: ".bold.red + 'Could not create an annualised ammount. Have you set the roll-up for your custom type transactions?'
+          exit
+        end
 
-        output.last[:transactions] << {
-          amount: amount,
-          annualised_amount: amount * (t['roll-up'] || annualise(period)),
-          rolled_up_amount: 0,
-          category: t['category'],
-          exclude: t['summary_exclude'],
-          description: t['description'],
-          to: t['to'] ? Calculator.new.evaluate_date(Date.parse(block['from']), t['to']) : nil
+        output << {
+          account: row['account'],
+          from: Date.parse(row['from']),
+          to: row['to'] ? Calculator.new.evaluate_date(Date.parse(row['from']), row['to']) : nil,
+          type: row['type'],
+          frequency: row['frequency'],
+          category: row['category'],
+          description: row['description'],
+          amount: row['amount'],
+          annualised_amount: annualised_amount.to_f,
+          exclude: row['summary_exclude']
         }
       end
 
+      output = calculate_rolled_up_amount(output) unless @settings[:roll_up].nil?
+
       output
     end
 
@@ -84,22 +63,9 @@ module HledgerForecast
       annualise[period]
     end
 
-    def filter_out(data)
-      data.reject { |item| item[:exclude] == true }
-    end
-
-    def flatten_and_merge(blocks)
-      blocks.values.flatten.flat_map do |block|
-        block[:transactions].map do |transaction|
-          block.slice(:account, :from, :to, :type, :frequency).merge(transaction)
-        end
-      end
-    end
-
-    def calculate_rolled_up_amount(data)
-      data.map do |item|
-        item[:rolled_up_amount] = item[:annualised_amount] / annualise(@settings[:roll_up])
-        item
+    def calculate_rolled_up_amount(forecast)
+      forecast.each do |row|
+        row[:rolled_up_amount] = row[:annualised_amount] / annualise(@settings[:roll_up])
       end
     end
   end

data/lib/hledger_forecast/summarizer_formatter.rb

@@ -41,7 +41,7 @@ module HledgerForecast
         @table.add_row([{ value: type.capitalize.bold, colspan: 3, alignment: :center }])
         total = 0
         items.each do |item|
-          total += item[:amount]
+          total += item[:amount].to_f
 
           if @settings[:verbose]
             @table.add_row [{ value: item[:category], alignment: :left },
@@ -63,7 +63,7 @@ module HledgerForecast
     def sort(data)
       data.each do |type, items|
         data[type] = items.sort_by do |item|
-          value = item[:amount]
+          value = item[:amount].to_f
           [value >= 0 ? 1 : 0, value >= 0 ? -value : value]
         end
       end
@@ -114,12 +114,21 @@ module HledgerForecast
 
     def add_total_row_to_table(data, row_to_sum)
       total = data.reduce(0) do |sum, item|
-        sum + item[row_to_sum]
+        sum + item[row_to_sum].to_f
       end
 
+      income = data.reduce(0) do |sum, item|
+        sum += item[row_to_sum].to_f if item[row_to_sum].to_f < 0
+        sum
+      end
+
+      savings = (total / income * 100).to_f.round(2)
+
       @table.add_separator
       @table.add_row [{ value: "TOTAL".bold, colspan: 2, alignment: :left },
                       { value: format_amount(total).bold, alignment: :right }]
+      @table.add_row [{ value: "as a % of income".italic, colspan: 2, alignment: :left },
+                      { value: "#{savings}%".italic, alignment: :right }]
     end
 
     def format_amount(amount)

data/lib/hledger_forecast/transactions/default.rb

@@ -6,15 +6,15 @@ module HledgerForecast
     #    Expenses:Groceries    $250.00 ;  Food expenses
     #    Assets:Checking
     class Default
-      def self.generate(data, options)
-        new(data, options).generate
+      def self.generate(forecast, settings)
+        new(forecast, settings).generate
       end
 
       def generate
-        data.each_value do |blocks|
-          blocks.each do |block|
-            process_block(block)
-          end
+        forecast.each do |row|
+          next if row[:type] == "settings"
+
+          process_transactions(row)
         end
 
         output
@@ -22,59 +22,34 @@ module HledgerForecast
 
       private
 
-      attr_reader :data, :options, :output
+      attr_reader :forecast, :settings, :output
 
-      def initialize(data, options)
-        @data = data
-        @options = options
+      def initialize(forecast, settings)
+        @forecast = forecast
+        @settings = settings
         @output = []
       end
 
-      def process_block(block)
-        block[:transactions].each do |to, transactions|
-          to = get_header(block[:to], to)
-
-          if block[:type] == "custom"
-            process_custom_transactions(block, to, transactions)
-          else
-            process_standard_transactions(block, to, transactions)
-          end
-        end
-      end
-
-      def process_custom_transactions(block, to, transactions)
-        transactions.each do |t|
-          frequency = get_periodic_rules(block[:type], t[:frequency])
+      def process_transactions(row)
+        to = build_to_header(row[:to])
+        frequency = get_periodic_rules(row[:type], row[:frequency])
 
-          header = build_header(block, to, frequency, t[:description])
-          footer = build_footer(block)
-          output << build_transaction(header, [t], footer)
+        if @settings[:verbose]
+          description = row[:description]
+          transactions = [row]
+        else
+          description = get_descriptions(row[:transactions])
+          transactions = row[:transactions]
         end
-      end
 
-      def process_standard_transactions(block, to, transactions)
-        if @options[:verbose]
-          transactions.map do |t|
-            # Skip transactions that have been marked as tracked
-            next if t[:track]
-
-            frequency = get_periodic_rules(block[:type], block[:frequency])
-            header = build_header(block, to, frequency, t[:description])
-            footer = build_footer(block)
-            output << build_transaction(header, [t], footer)
-          end
-          return
-        end
+        header = build_header(row, frequency, to, description)
+        footer = build_footer(row)
 
-        block[:descriptions] = get_descriptions(transactions)
-        frequency = get_periodic_rules(block[:type], block[:frequency])
-        header = build_header(block, to, frequency, block[:descriptions])
-        footer = build_footer(block)
         output << build_transaction(header, transactions, footer)
       end
 
-      def build_header(block, to, frequency, description)
-        "#{frequency} #{block[:from]}#{to}  * #{description}\n"
+      def build_header(row, frequency, to, descriptions)
+        "#{frequency} #{row[:from]}#{to}  * #{descriptions}\n"
       end
 
       def build_footer(block)
@@ -85,11 +60,8 @@ module HledgerForecast
         { header: header, transactions: write_transactions(transactions), footer: footer }
       end
 
-      def get_header(block, transaction)
-        return " to #{transaction}" if transaction
-        return " to #{block}" if block
-
-        return nil
+      def build_to_header(to)
+        return " to #{to}" if to
       end
 
       def get_descriptions(transactions)
@@ -110,7 +82,6 @@ module HledgerForecast
           'yearly' => '~ yearly from',
           'custom' => "~ #{frequency} from"
         }
-
         map[type]
       end
 
@@ -119,11 +90,11 @@ module HledgerForecast
           # Skip transactions that have been marked as tracked
           next if t[:track]
 
-          t[:amount] = t[:amount].to_s.ljust(options[:max_amount])
-          t[:category] = t[:category].ljust(options[:max_category])
+          t[:amount] = t[:amount].to_s.ljust(@settings[:max_amount] + 5)
+          t[:category] = t[:category].to_s.ljust(@settings[:max_category])
 
           "    #{t[:category]}    #{t[:amount]};  #{t[:description]}\n"
-        end
+        end.compact
       end
     end
   end

data/lib/hledger_forecast/transactions/trackers.rb

@@ -9,84 +9,78 @@ module HledgerForecast
     #    Expenses:Groceries    $250.00 ;  Food expenses
     #    Assets:Checking
     class Trackers
-      def self.generate(data, options)
-        new(data, options).generate
+      def self.generate(forecast, options)
+        new(forecast, options).generate
       end
 
       def generate
-        return nil unless tracked?(data)
+        return if @options[:no_track]
+        return nil unless tracked?(forecast)
 
-        data.each_value do |blocks|
-          blocks.each do |block|
-            process_tracked(block)
-          end
+        forecast.each do |row|
+          process_tracked(row)
         end
 
         output
       end
 
-      def self.track?(transaction, data, options)
+      def self.track?(row, options)
         now = Date.today
-        transaction['track'] && Date.parse(data['from']) <= now && !exists?(transaction, data['account'],
-                                                                            data['from'], now, options)
+        row['track'] && Date.parse(row['from']) <= now && !exists?(row, now, options)
       end
 
-      def self.exists?(transaction, account, from, to, options)
-
-        if !options[:transaction_file]
+      def self.exists?(row, now, options)
+        unless options[:transaction_file]
           puts "\nWarning: ".bold.yellow + "For tracked transactions, please specify a file with the `-t` flag"
           puts "ERROR: ".bold.red + "Tracked transactions ignored for now"
           return
         end
 
         # Format the money
-        amount = Formatter.format_money(transaction['amount'], options)
-        inverse_amount = Formatter.format_money(transaction['amount'] * -1, options)
+        amount = Formatter.format_money(row['amount'], options)
+        inverse_amount = Formatter.format_money(row['amount'] * -1, options)
 
-        category = transaction['category'].gsub('[', '\\[').gsub(']', '\\]').gsub('(', '\\(').gsub(')', '\\)')
+        from = Date.parse(row['from'])
+        category = row['category'].gsub('[', '\\[').gsub(']', '\\]').gsub('(', '\\(').gsub(')', '\\)')
 
         # We run two commands and check to see if category +/- amount or account +/- amount exists
-        command1 = %(hledger print -f #{options[:transaction_file]} "date:#{from}..#{to}" | tr -s '[:space:]' ' ' | grep -q -Eo "#{category} (#{amount}|#{inverse_amount})")
-        command2 = %(hledger print -f #{options[:transaction_file]} "date:#{from}..#{to}" | tr -s '[:space:]' ' ' | grep -q -Eo "#{account} (#{amount}|#{inverse_amount})")
+        command1 = %(hledger print -f #{options[:transaction_file]} "date:#{from}..#{now}" | tr -s '[:space:]' ' ' | grep -q -Eo "#{category} (#{amount}|#{inverse_amount})")
+        command2 = %(hledger print -f #{options[:transaction_file]} "date:#{from}..#{now}" | tr -s '[:space:]' ' ' | grep -q -Eo "#{row['account']} (#{amount}|#{inverse_amount})")
 
         system(command1) || system(command2)
       end
 
       private
 
-      attr_reader :data, :options, :output
+      attr_reader :forecast, :options, :output
 
-      def initialize(data, options)
-        @data = data
+      def initialize(forecast, options)
+        @forecast = forecast
         @options = options
         @output = []
       end
 
-      def tracked?(data)
-        data.any? do |_, blocks|
-          blocks.any? do |block|
-            block[:transactions].any? do |_, transactions|
-              transactions.any? { |t| t[:track] }
-            end
-          end
+      def tracked?(forecast)
+        forecast.any? do |row|
+          return true if row[:track] == true
         end
+
+        return false
       end
 
-      def process_tracked(block)
-        block[:transactions].each do |_to, transactions|
-          transactions.each do |t|
-            next unless t[:track]
+      def process_tracked(row)
+        row[:transactions].each do |t|
+          next if t[:track] == false
 
-            category = t[:category].ljust(options[:max_category])
-            amount = t[:amount].to_s.ljust(options[:max_amount])
+          category = t[:category].ljust(options[:max_category])
+          amount = t[:amount].to_s.ljust(options[:max_amount])
 
-            header = "~ #{Date.new(Date.today.year, Date.today.month,
-                                   1).next_month}  * [TRACKED] #{t[:description]}\n"
-            transactions = "    #{category}    #{amount};  #{t[:description]}\n"
-            footer = "    #{block[:account]}\n\n"
+          header = "~ #{Date.new(Date.today.year, Date.today.month,
+                                 1).next_month}  * [TRACKED] #{t[:description]}\n"
+          transactions = "    #{category}    #{amount};  #{t[:description]}\n"
+          footer = "    #{row[:account]}\n\n"
 
-            output << { header: header, transactions: [transactions], footer: footer }
-          end
+          output << { header: header, transactions: [transactions], footer: footer }
         end
       end
     end

data/lib/hledger_forecast/utilities.rb

@@ -0,0 +1,14 @@
+module HledgerForecast
+  class Utilities
+    def self.convert_amount(amount)
+      case amount
+      when /^-?\d+\.\d+$/ # Detects floating-point numbers (including negatives)
+        amount.to_f
+      when /^-?\d+$/ # Detects integers (including negatives)
+        amount.to_i
+      else
+        amount
+      end
+    end
+  end
+end

data/lib/hledger_forecast/version.rb

@@ -1,3 +1,3 @@
 module HledgerForecast
-  VERSION = "1.5.1"
+  VERSION = "2.0.0".freeze
 end

data/lib/hledger_forecast.rb

@@ -8,7 +8,6 @@ require 'highline'
 require 'money'
 require 'optparse'
 require 'terminal-table'
-require 'yaml'
 
 Money.locale_backend = nil
 Money.rounding_mode = BigDecimal::ROUND_HALF_UP
@@ -17,12 +16,12 @@ Money.default_currency = 'USD'
 require_relative 'hledger_forecast/calculator'
 require_relative 'hledger_forecast/cli'
 require_relative 'hledger_forecast/comparator'
-require_relative 'hledger_forecast/csv_parser'
 require_relative 'hledger_forecast/formatter'
 require_relative 'hledger_forecast/generator'
 require_relative 'hledger_forecast/settings'
 require_relative 'hledger_forecast/summarizer'
 require_relative 'hledger_forecast/summarizer_formatter'
+require_relative 'hledger_forecast/utilities'
 require_relative 'hledger_forecast/version'
 
 require_relative 'hledger_forecast/transactions/default'

data/spec/cli_spec.rb

@@ -2,12 +2,12 @@ require_relative '../lib/hledger_forecast'
 
 output = <<~JOURNAL
   ~ monthly from 2023-03-01  * Mortgage, Food
-      Expenses:Mortgage    £2,000.55;  Mortgage
-      Expenses:Food        £100.00  ;  Food
+      Expenses:Mortgage    £2,000.55   ;  Mortgage
+      Expenses:Food        £100.00     ;  Food
       Assets:Bank
 
   ~ monthly from 2023-03-01  * Savings
-      Assets:Bank          £-1,000.00;  Savings
+      Assets:Bank          £-1,000.00  ;  Savings
       Assets:Savings
 
 JOURNAL
@@ -26,15 +26,6 @@ ensure
 end
 
 RSpec.describe 'command' do
-  it 'uses the CLI to generate an output' do
-    generated_journal = './test_output.journal'
-    File.delete(generated_journal) if File.exist?(generated_journal)
-
-    system("./bin/hledger-forecast generate -f ./spec/stubs/forecast.yml -o ./test_output.journal --force")
-
-    expect(File.read(generated_journal)).to eq(output)
-  end
-
   it 'uses the CLI to generate an output with a CSV config file' do
     generated_journal = './test_output.journal'
     File.delete(generated_journal) if File.exist?(generated_journal)

data/spec/computed_amounts_spec.rb

@@ -1,29 +1,18 @@
 require_relative '../lib/hledger_forecast'
 
-config = <<~YAML
-  settings:
-    currency: GBP
-
-  monthly:
-    - account: "Liabilities:Amex"
-      from: "2023-05-01"
-      transactions:
-        - amount: "=5000/24"
-          category: "Expenses:House"
-          description: New Kitchen
-        - amount: "=25*4.3"
-          category: "Expenses:Food"
-          description: Monthly food shop
-        - amount: "=(102.50+3.25)/2"
-          category: "Expenses:Food"
-          description: Random food
-YAML
+config = <<~CSV
+  type,frequency,account,from,to,description,category,amount,roll-up,summary_exclude,track
+  monthly,,Liabilities:Amex,01/05/2023,,New kitchen,Expenses:House,=5000/24,,,
+  monthly,,Liabilities:Amex,01/05/2023,,Monthly food shop,Expenses:Food,=25*4.3,,,
+  monthly,,Liabilities:Amex,01/05/2023,,Random food,Expenses:Food,=(102.50+3.25)/2,,,
+  settings,currency,GBP,,,,,,,,
+CSV
 
 output = <<~JOURNAL
-  ~ monthly from 2023-05-01  * New Kitchen, Monthly food shop, Random food
-      Expenses:House    £208.33          ;  New Kitchen
-      Expenses:Food     £107.50          ;  Monthly food shop
-      Expenses:Food     £52.88           ;  Random food
+  ~ monthly from 2023-05-01  * New kitchen, Monthly food shop, Random food
+      Expenses:House    £208.33              ;  New kitchen
+      Expenses:Food     £107.50              ;  Monthly food shop
+      Expenses:Food     £52.88               ;  Random food
       Liabilities:Amex
 
 JOURNAL