hledger-forecast 0.4.0 → 1.1.0

data/lib/hledger_forecast/generator.rb

@@ -1,282 +1,65 @@
 module HledgerForecast
-  # Generates periodic transactions from a YAML file
+  # Generate forecasts for hledger from a yaml config file
   class Generator
-    class << self
-      attr_accessor :calculator, :options, :modified, :tracked
+    def self.generate(config, cli_options = nil)
+      new.generate(config, cli_options)
     end
 
-    self.calculator = {}
-    self.options = {}
-    self.modified = {}
-    self.tracked = {}
+    def generate(config, cli_options = nil)
+      forecast = YAML.safe_load(config)
+      @settings = Settings.config(forecast, cli_options)
 
-    def self.set_options(forecast_data)
-      @options[:max_amount] = get_max_field_size(forecast_data, 'amount') + 1 # +1 for the negatives
-      @options[:max_category] = get_max_field_size(forecast_data, 'category')
+      output = {}
+      forecast.each do |period, blocks|
+        next if %w[settings].include?(period)
 
-      @options[:currency] = Money::Currency.new(forecast_data.fetch('settings', {}).fetch('currency', 'USD'))
-      @options[:show_symbol] = forecast_data.fetch('settings', {}).fetch('show_symbol', true)
-      # @options[:sign_before_symbol] = forecast_data.fetch('settings', {}).fetch('sign_before_symbol', false)
-      @options[:thousands_separator] = forecast_data.fetch('settings', {}).fetch('thousands_separator', true)
-    end
-
-    def self.generate(yaml_file, options = nil)
-      forecast_data = YAML.safe_load(yaml_file)
-
-      set_options(forecast_data)
-
-      @calculator = Dentaku::Calculator.new
-
-      output = ""
-
-      # Generate regular transactions
-      forecast_data.each do |period, forecasts|
-        if period == 'custom'
-          output += custom_transaction(forecasts)
-        else
-          frequency = convert_period_to_frequency(period)
-          next unless frequency
-
-          forecasts.each do |forecast|
-            account = forecast['account']
-            from = Date.parse(forecast['from'])
-            to = forecast['to'] ? Date.parse(forecast['to']) : nil
-            transactions = forecast['transactions']
-
-            output += regular_transaction(frequency, from, to, transactions, account)
-            output += ending_transaction(frequency, from, transactions, account)
-          end
-        end
-      end
-
-      # Generate tracked transactions
-      if options && !options[:no_track] && !@tracked.empty?
-        if options[:transaction_file]
-          output += output_tracked_transaction(Tracker.track(@tracked,
-                                                             options[:transaction_file]))
-        else
-          puts "\nWarning: ".yellow.bold + "You need to specify a transaction file with the `--t` flag for smart transactions to work\n"
-        end
-      end
-
-      output += output_modified_transaction(@modified) unless @modified.empty?
-
-      output
-    end
-
-    def self.regular_transaction(frequency, from, to, transactions, account)
-      transactions = transactions.select { |transaction| transaction['to'].nil? }
-      return "" if transactions.empty?
-
-      output = ""
-
-      transactions.each do |transaction|
-        if track_transaction?(transaction, from)
-          track_transaction(from, to, account, transaction)
-          next
-        end
-
-        modified_transaction(from, to, account, transaction)
-
-        output += output_transaction(transaction['category'], format_amount(calculate_amount(transaction['amount'])),
-                                     transaction['description'])
-      end
-
-      return "" unless output != ""
-
-      output = if to
-                 "#{frequency} #{from} to #{to}  * #{extract_descriptions(transactions,
-                                                                          from)}\n" << output
-               else
-                 "#{frequency} #{from}  * #{extract_descriptions(transactions, from)}\n" << output
-               end
-
-      output += "    #{account}\n\n"
-      output
-    end
-
-    def self.ending_transaction(frequency, from, transactions, account)
-      output = ""
-
-      transactions.each do |transaction|
-        to = transaction['to'] ? Date.parse(transaction['to']) : nil
-        next unless to
-
-        if track_transaction?(transaction, from)
-          track_transaction(from, to, account, transaction)
-          next
-        end
-
-        modified_transaction(from, to, account, transaction)
-
-        output += "#{frequency} #{from} to #{to}  * #{transaction['description']}\n"
-        output += output_transaction(transaction['category'], format_amount(calculate_amount(transaction['amount'])),
-                                     transaction['description'])
-        output += "    #{account}\n\n"
-      end
-
-      output
-    end
-
-    def self.custom_transaction(forecasts)
-      output = ""
-
-      forecasts.each do |forecast|
-        account = forecast['account']
-        from = Date.parse(forecast['from'])
-        to = forecast['to'] ? Date.parse(forecast['to']) : nil
-        frequency = forecast['frequency']
-        transactions = forecast['transactions']
-
-        output += "~ #{frequency} from #{from}  * #{extract_descriptions(transactions, from)}\n"
-
-        transactions.each do |transaction|
-          to = transaction['to'] ? Date.parse(transaction['to']) : to
-
-          if track_transaction?(transaction, from)
-            track_transaction(from, to, account, transaction)
-            next
-          end
-
-          modified_transaction(from, to, account, transaction)
-
-          output += output_transaction(transaction['category'], format_amount(calculate_amount(transaction['amount'])),
-                                       transaction['description'])
+        blocks.each do |block|
+          output[output.length] = process_block(period, block)
         end
-
-        output += "    #{account}\n\n"
-      end
-
-      output
-    end
-
-    def self.output_transaction(category, amount, description)
-      "    #{category.ljust(@options[:max_category])}    #{amount.ljust(@options[:max_amount])};  #{description}\n"
-    end
-
-    def self.output_modified_transaction(transactions)
-      output = ""
-
-      transactions.each do |_key, transaction|
-        date = "date:#{transaction['from']}"
-        date += "..#{transaction['to']}" if transaction['to']
-
-        output += "= #{transaction['category']} #{date}\n"
-        output += "    #{transaction['category'].ljust(@options[:max_category])}    *#{transaction['amount'].to_s.ljust(@options[:max_amount] - 1)};  #{transaction['description']}\n"
-        output += "    #{transaction['account'].ljust(@options[:max_category])}    *#{transaction['amount'] * -1}\n\n"
       end
 
-      output
+      Formatter.output_to_ledger(
+        Transactions::Default.generate(output, @settings),
+        Transactions::Trackers.generate(output, @settings),
+        Transactions::Modifiers.generate(output, @settings)
+      )
     end
 
-    def self.output_tracked_transaction(transactions)
-      output = ""
-
-      transactions.each do |_key, transaction|
-        next if transaction['found']
-
-        output += "~ #{transaction['from']}  * [TRACKED] #{transaction['transaction']['description']}\n"
-        output += "    #{transaction['transaction']['category'].ljust(@options[:max_category])}    #{transaction['transaction']['amount'].ljust(@options[:max_amount])};  #{transaction['transaction']['description']}\n"
-        output += "    #{transaction['account']}\n\n"
-      end
+    private
 
-      output
-    end
+    def process_block(period, block)
+      output = []
 
-    def self.extract_descriptions(transactions, from)
-      descriptions = []
+      output << {
+        account: block['account'],
+        from: Date.parse(block['from']),
+        to: block['to'] ? Date.parse(block['to']) : nil,
+        type: period,
+        frequency: block['frequency'],
+        transactions: []
+      }
 
-      transactions.each do |transaction|
-        next if track_transaction?(transaction, from)
+      output = process_transactions(block, output)
 
-        description = transaction['description']
-        descriptions << description
+      output.map do |item|
+        transactions = item[:transactions].group_by { |t| t[:to] }
+        item.merge(transactions: transactions)
       end
-
-      descriptions.join(', ')
     end
 
-    def self.modified_transaction(from, to, account, transaction)
-      return unless transaction['modifiers']
-
-      transaction['modifiers'].each do |modifier|
-        description = transaction['description']
-        description += ' - ' + modifier['description'] unless modifier['description'].empty?
-
-        @modified[@modified.length] = {
-          'account' => account,
-          'amount' => modifier['amount'],
-          'category' => transaction['category'],
-          'description' => description,
-          'from' => modifier['from'] ? Date.parse(modifier['from']) : (from || nil),
-          'to' => modifier['to'] ? Date.parse(modifier['to']) : (to || nil)
+    def process_transactions(block, output)
+      block['transactions'].each do |t|
+        output.last[:transactions] << {
+          category: t['category'],
+          amount: Formatter.format_money(Calculator.new.evaluate(t['amount']), @settings),
+          description: t['description'],
+          to: t['to'] ? Calculator.new.evaluate_date(Date.parse(block['from']), t['to']) : nil,
+          modifiers: t['modifiers'] ? Transactions::Modifiers.get_modifiers(t, block) : [],
+          track: Transactions::Trackers.track?(t, block, @settings) ? true : false
         }
       end
-    end
 
-    def self.track_transaction?(transaction, from)
-      transaction['track'] && from <= Date.today
-    end
-
-    def self.track_transaction(from, to, account, transaction)
-      amount = calculate_amount(transaction['amount'])
-      transaction['amount'] = format_amount(amount)
-      transaction['inverse_amount'] = format_amount(amount * -1)
-
-      @tracked[@tracked.length] = {
-        'account' => account,
-        'from' => from,
-        'to' => to,
-        'transaction' => transaction
-      }
-    end
-
-    def self.convert_period_to_frequency(period)
-      map = {
-        'once' => '~',
-        'monthly' => '~ monthly from',
-        'quarterly' => '~ every 3 months from',
-        'half-yearly' => '~ every 6 months from',
-        'yearly' => '~ yearly from'
-      }
-
-      map[period]
-    end
-
-    def self.calculate_amount(amount)
-      return amount unless amount.is_a?(String)
-
-      @calculator.evaluate(amount.slice(1..-1))
-    end
-
-    def self.format_amount(amount)
-      Money.from_cents(amount.to_f * 100, @options[:currency]).format(
-        symbol: @options[:show_symbol],
-        sign_before_symbol: @options[:sign_before_symbol],
-        thousands_separator: @options[:thousands_separator] ? ',' : nil
-      )
-    end
-
-    def self.get_max_field_size(forecast_data, field)
-      max_size = 0
-
-      forecast_data.each do |period, forecasts|
-        next if period == 'settings'
-
-        forecasts.each do |forecast|
-          transactions = forecast['transactions']
-          transactions.each do |transaction|
-            field_value = if transaction[field].is_a?(Integer) || transaction[field].is_a?(Float)
-                            ((transaction[field] + 3) * 100).to_s
-                          else
-                            transaction[field].to_s
-                          end
-            max_size = [max_size, field_value.length].max
-          end
-        end
-      end
-
-      max_size
+      output
     end
   end
 end

data/lib/hledger_forecast/settings.rb

@@ -0,0 +1,41 @@
+module HledgerForecast
+  # Set the options from a user's confgi
+  class Settings
+    def self.config(forecast, cli_options)
+      settings = {}
+
+      settings[:max_amount] = get_max_field_size(forecast, 'amount') + 1 # +1 for the negatives
+      settings[:max_category] = get_max_field_size(forecast, '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)
+
+      settings.merge!(cli_options) if cli_options
+
+      settings
+    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
+        end
+      end
+
+      max_size
+    end
+  end
+end

data/lib/hledger_forecast/summarizer.rb

@@ -0,0 +1,106 @@
+module HledgerForecast
+  # Summarise a forecast yaml file and output it to the CLI
+  class Summarizer
+    def self.summarize(config, cli_options)
+      new.summarize(config, cli_options)
+    end
+
+    def summarize(config, cli_options = nil)
+      @forecast = YAML.safe_load(config)
+      @settings = Settings.config(@forecast, cli_options)
+
+      return { 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: []
+      }
+
+      process_transactions(period, block, output)
+    end
+
+    def process_transactions(period, block, output)
+      block['transactions'].each do |t|
+        amount = Calculator.new.evaluate(t['amount'])
+
+        output.last[:transactions] << {
+          amount: amount,
+          annualised_amount: amount * (block['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
+        }
+      end
+
+      output
+    end
+
+    def annualise(period)
+      annualise = {
+        'monthly' => 12,
+        'quarterly' => 4,
+        'half-yearly' => 2,
+        'yearly' => 1,
+        'once' => 1,
+        'daily' => 352,
+        'weekly' => 52
+      }
+
+      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
+      end
+    end
+  end
+end

data/lib/hledger_forecast/summarizer_formatter.rb

@@ -0,0 +1,115 @@
+module HledgerForecast
+  # Output the summarised forecast to the CLI
+  class SummarizerFormatter
+    def self.format(output, settings)
+      new.format(output, settings)
+    end
+
+    def format(output, settings)
+      @table = Terminal::Table.new
+      @settings = settings
+
+      init_table
+
+      if @settings[:roll_up].nil?
+        add_rows_to_table(output)
+        add_total_row_to_table(output, :amount)
+      else
+        add_rolled_up_rows_to_table(output)
+        add_total_row_to_table(output, :rolled_up_amount)
+      end
+
+      @table
+    end
+
+    private
+
+    def init_table
+      title = 'FORECAST SUMMARY'
+      title += " (#{@settings[:roll_up].upcase} ROLL UP)" if @settings[:roll_up]
+
+      @table.add_row([{ value: title.bold, colspan: 3, alignment: :center }])
+      @table.add_separator
+    end
+
+    def add_rows_to_table(data)
+      data = data.group_by { |item| item[:type] }
+
+      data = sort(data)
+
+      data.each_with_index do |(type, items), index|
+        @table.add_row([{ value: type.capitalize.bold, colspan: 3, alignment: :center }])
+        total = 0
+        items.each do |item|
+          total += item[:amount]
+          @table.add_row [{ value: item[:category], colspan: 2, alignment: :left },
+                          { value: format_amount(item[:amount]), alignment: :right }]
+        end
+
+        @table.add_row [{ value: "TOTAL".bold, colspan: 2, alignment: :left },
+                        { value: format_amount(total).bold, alignment: :right }]
+
+        @table.add_separator if index != data.size - 1
+      end
+    end
+
+    def sort(data)
+      data.each do |type, items|
+        data[type] = items.sort_by do |item|
+          value = item[:amount]
+          [value >= 0 ? 1 : 0, value >= 0 ? -value : value]
+        end
+      end
+    end
+
+    def add_rolled_up_rows_to_table(data)
+      sum_hash = Hash.new { |h, k| h[k] = { sum: 0, descriptions: [] } }
+
+      data.each do |item|
+        sum_hash[item[:category]][:sum] += item[:rolled_up_amount]
+        sum_hash[item[:category]][:descriptions] << item[:description]
+      end
+
+      # Convert arrays of descriptions to single strings
+      sum_hash.each do |_category, values|
+        values[:descriptions] = values[:descriptions].join(", ")
+      end
+
+      # Sort the array
+      sorted_sums = sort_roll_up(sum_hash, :sum)
+
+      sorted_sums.each do |hash|
+        @table.add_row [{ value: hash[:category], colspan: 2, alignment: :left },
+                        { value: format_amount(hash[:sum]), alignment: :right }]
+      end
+    end
+
+    def sort_roll_up(data, sort_by)
+      # Convert the hash to an array of hashes
+      array = data.map do |category, values|
+        { category: category, sum: values[sort_by], descriptions: values[:descriptions] }
+      end
+
+      # Sort the array
+      array.sort_by do |hash|
+        value = hash[:sum]
+        [value >= 0 ? 1 : 0, value >= 0 ? -value : value]
+      end
+    end
+
+    def add_total_row_to_table(data, row_to_sum)
+      total = data.reduce(0) do |sum, item|
+        sum + item[row_to_sum]
+      end
+
+      @table.add_separator
+      @table.add_row [{ value: "TOTAL".bold, colspan: 2, alignment: :left },
+                      { value: format_amount(total).bold, alignment: :right }]
+    end
+
+    def format_amount(amount)
+      formatted_amount = Formatter.format_money(amount, @settings)
+      amount.to_f < 0 ? formatted_amount.green : formatted_amount.red
+    end
+  end
+end

data/lib/hledger_forecast/transactions/default.rb

@@ -0,0 +1,88 @@
+module HledgerForecast
+  module Transactions
+    # Generate default hledger transactions
+    # Example output:
+    # ~ monthly from 2023-05-1  * Food expenses
+    #    Expenses:Groceries    $250.00 ;  Food expenses
+    #    Assets:Checking
+    class Default
+      def self.generate(data, options)
+        new(data, options).generate
+      end
+
+      def generate
+        data.each_value do |blocks|
+          blocks.each do |block|
+            process_block(block)
+          end
+        end
+
+        output
+      end
+
+      private
+
+      attr_reader :data, :options, :output
+
+      def initialize(data, options)
+        @data = data
+        @options = options
+        @output = []
+      end
+
+      def process_block(block)
+        block[:transactions].each do |to, transactions|
+          to = get_header(block[:to], to)
+          block[:descriptions] = get_descriptions(transactions)
+          frequency = get_periodic_rules(block[:type], block[:frequency])
+
+          header = "#{frequency} #{block[:from]}#{to}  * #{block[:descriptions]}\n"
+          footer = "    #{block[:account]}\n\n"
+
+          output << { header: header, transactions: write_transactions(transactions), footer: footer }
+        end
+      end
+
+      def get_header(block, transaction)
+        return " to #{transaction}" if transaction
+        return " to #{block}" if block
+
+        return nil
+      end
+
+      def get_descriptions(transactions)
+        transactions.map do |t|
+          # Skip transactions that have been marked as tracked
+          next if t[:track]
+
+          t[:description]
+        end.compact.join(', ')
+      end
+
+      def get_periodic_rules(type, frequency)
+        map = {
+          'once' => '~',
+          'monthly' => '~ monthly from',
+          'quarterly' => '~ every 3 months from',
+          'half-yearly' => '~ every 6 months from',
+          'yearly' => '~ yearly from',
+          'custom' => "~ #{frequency} from"
+        }
+
+        map[type]
+      end
+
+      def write_transactions(transactions)
+        transactions.map do |t|
+          # 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[:category]}    #{t[:amount]};  #{t[:description]}\n"
+        end
+      end
+    end
+  end
+end