hledger-forecast 0.2.1 → 0.4.0

data/lib/hledger_forecast/cli.rb

@@ -2,27 +2,26 @@ module HledgerForecast
   # The Command Line Interface for the application
   # Takes user arguments and translates them into actions
   class Cli
-
-    def self.run(subcommand, options)
-      case subcommand
+    def self.run(command, options)
+      case command
       when 'generate'
         generate(options)
       when 'summarize'
         summarize(options)
       else
-        puts "Unknown command: #{subcommand}"
+        puts "Unknown command: #{command}"
         exit(1)
       end
     end
 
     def self.parse_commands(args = ARGV, _stdin = $stdin)
-      subcommand = nil
+      command = nil
       options = {}
 
       global = OptionParser.new do |opts|
-        opts.banner = "Usage: hledger-forecast [subcommand] [options]"
+        opts.banner = "Usage: hledger-forecast [command] [options]"
         opts.separator ""
-        opts.separator "Subcommands:"
+        opts.separator "Commands:"
         opts.separator "  generate    Generate the forecast file"
         opts.separator "  summarize   Summarize the forecast file and output to the terminal"
         opts.separator ""
@@ -33,7 +32,7 @@ module HledgerForecast
           exit
         end
 
-        opts.on_tail("-v", "--version", "Show version") do
+        opts.on_tail("-v", "--version", "Show the installed version") do
           puts VERSION
           exit
         end
@@ -41,63 +40,58 @@ module HledgerForecast
 
       begin
         global.order!(args)
-        subcommand = args.shift || 'generate'
+        command = args.shift || 'generate'
       rescue OptionParser::InvalidOption => e
         puts e
         puts global
         exit(1)
       end
 
-      case subcommand
+      case command
       when 'generate'
         options = parse_generate_options(args)
       when 'summarize'
         options = parse_summarize_options(args)
       else
-        puts "Unknown subcommand: #{subcommand}"
+        puts "Unknown command: #{command}"
         puts global
         exit(1)
       end
 
-      return subcommand, options
+      return command, options
     end
 
     def self.parse_generate_options(args)
       options = {}
 
       OptionParser.new do |opts|
-        opts.banner = "Usage: Hledger-Forecast generate [options]"
+        opts.banner = "Usage: hledger-forecast generate [options]"
         opts.separator ""
 
-        opts.on("-t", "--transaction FILE",
-                "The base TRANSACTIONS file to extend from") do |file|
-          options[:transactions_file] = file if file && !file.empty?
-        end
-
         opts.on("-f", "--forecast FILE",
-                "The FORECAST yaml file to generate from") do |file|
+                "The path to the FORECAST yaml file to generate from") do |file|
           options[:forecast_file] = file
           options[:output_file] ||= file.sub(/\.yml$/, '.journal')
         end
 
         opts.on("-o", "--output-file FILE",
-                "The OUTPUT file to create") do |file|
+                "The path to the OUTPUT file to create") do |file|
           options[:output_file] = file
         end
 
-        opts.on("-s", "--start-date DATE",
-                "The date to start generating from (yyyy-mm-dd)") do |a|
-          options[:start_date] = a
+        opts.on("-t", "--transaction FILE",
+                "The path to the TRANSACTION journal file") do |file|
+          options[:transaction_file] = file
         end
 
-        opts.on("-e", "--end-date DATE",
-                "The date to start generating to (yyyy-mm-dd)") do |a|
-          options[:end_date] = a
+        opts.on("--force",
+                "Force an overwrite of the output file") do
+          options[:force] = true
         end
 
-        opts.on("--force",
-                "Force an overwrite of the output file") do |a|
-          options[:force] = a
+        opts.on("--no-track",
+                "Don't track any transactions") do
+          options[:no_track] = true
         end
 
         opts.on_tail("-h", "--help", "Show this help message") do
@@ -109,18 +103,6 @@ module HledgerForecast
       options[:forecast_file] = "forecast.yml" unless options[:forecast_file]
       options[:output_file] = "forecast.journal" unless options[:output_file]
 
-      today = Date.today
-
-      unless options[:start_date]
-        options[:default_dates] = true
-        options[:start_date] =
-          Date.new(today.year, today.month, 1).next_month.to_s
-      end
-      unless options[:end_date]
-        options[:default_dates] = true
-        options[:end_date] = Date.new(today.year + 3, 12, 31).to_s
-      end
-
       options
     end
 
@@ -128,11 +110,11 @@ module HledgerForecast
       options = {}
 
       OptionParser.new do |opts|
-        opts.banner = "Usage: Hledger-Forecast summarize [options]"
+        opts.banner = "Usage: hledger-forecast summarize [options]"
         opts.separator ""
 
         opts.on("-f", "--forecast FILE",
-                "The FORECAST yaml file to summarize") do |file|
+                "The path to the FORECAST yaml file to summarize") do |file|
           options[:forecast_file] = file
         end
 
@@ -146,30 +128,29 @@ module HledgerForecast
     end
 
     def self.generate(options)
-      end_date = options[:end_date]
-      start_date = options[:start_date]
       forecast = File.read(options[:forecast_file])
-      transactions = options[:transactions_file] ? File.read(options[:transactions_file]) : nil
-
-      # Generate the forecast
-      puts "[Using default dates: #{start_date} to #{end_date}]" if options[:default_dates]
 
-      transactions = Generator.generate(transactions, forecast, start_date, end_date)
+      begin
+        transactions = Generator.generate(forecast, options)
+      rescue StandardError => e
+        puts "An error occurred while generating transactions: #{e.message}"
+        exit(1)
+      end
 
       output_file = options[:output_file]
       if File.exist?(output_file) && !options[:force]
-        print "File '#{output_file}' already exists. Overwrite? (y/n): "
+        print "\nFile '#{output_file}' already exists. Overwrite? (y/n): "
         overwrite = gets.chomp.downcase
 
         if overwrite == 'y'
           File.write(output_file, transactions)
-          puts "File '#{output_file}' has been overwritten."
+          puts "\nSuccess: ".bold.green + "File '#{output_file}' has been overwritten."
         else
-          puts "Operation aborted. File '#{output_file}' was not overwritten."
+          puts "\nInfo: ".bold.blue + "Operation aborted. File '#{output_file}' was not overwritten."
         end
       else
         File.write(output_file, transactions)
-        puts "File '#{output_file}' has been created."
+        puts "\nSuccess: ".bold.green + "File '#{output_file}' has been created"
       end
     end
 
@@ -177,44 +158,5 @@ module HledgerForecast
       forecast = File.read(options[:forecast_file])
       puts Summarize.generate(forecast)
     end
-
-    # def self.run(args)
-    #   end_date = args[:end_date]
-    #   start_date = args[:start_date]
-    #   forecast = File.read(args[:forecast_file])
-    #   transactions = args[:transactions_file] ? File.read(args[:transactions_file]) : nil
-    #
-    #   # Output the summary
-    #   return HledgerForecast::Summarize.generate(forecast) if args[:summarize]
-    #
-    #   # Generate the forecast
-    #   unless args[:skip]
-    #
-    #     puts "[Using default dates: #{start_date} to #{end_date}]" if args[:default_dates]
-    #
-    #     transactions = Generator.generate(transactions, forecast, start_date, end_date)
-    #
-    #     output_file = args[:output_file]
-    #     if File.exist?(output_file) && !args[:force]
-    #       print "File '#{output_file}' already exists. Overwrite? (y/n): "
-    #       overwrite = gets.chomp.downcase
-    #
-    #       if overwrite == 'y'
-    #         File.write(output_file, transactions)
-    #         puts "File '#{output_file}' has been overwritten."
-    #       else
-    #         puts "Operation aborted. File '#{output_file}' was not overwritten."
-    #       end
-    #     else
-    #       File.write(output_file, transactions)
-    #       puts "File '#{output_file}' has been created."
-    #     end
-    #   end
-    #
-    #   # Check for missing transactions
-    #   return unless args[:check] && args[:transactions_file] && args[:forecast_file]
-    #
-    #   HledgerForecast::Checker.check(args)
-    # end
   end
 end

data/lib/hledger_forecast/generator.rb

@@ -1,130 +1,282 @@
 module HledgerForecast
-  # Generates journal entries based on a YAML forecast file.
-  # on forecast data and optional existing transactions.
+  # Generates periodic transactions from a YAML file
   class Generator
     class << self
-      attr_accessor :settings
+      attr_accessor :calculator, :options, :modified, :tracked
     end
 
-    self.settings = {}
+    self.calculator = {}
+    self.options = {}
+    self.modified = {}
+    self.tracked = {}
 
-    def self.configure_settings(forecast_data)
-      @settings[:currency] = Money::Currency.new(forecast_data.fetch('settings', {}).fetch('currency', 'USD'))
-      @settings[:show_symbol] = forecast_data.fetch('settings', {}).fetch('show_symbol', true)
-      @settings[:sign_before_symbol] = forecast_data.fetch('settings', {}).fetch('sign_before_symbol', true)
-      @settings[:thousands_separator] = forecast_data.fetch('settings', {}).fetch('thousands_separator', true)
-    end
+    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')
 
-    def self.write_transactions(output, date, account, transaction)
-      output.concat("#{date} * #{transaction['description']}\n")
-      output.concat("    #{transaction['category']}                #{transaction['amount']}\n")
-      output.concat("    #{account}\n\n")
+      @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.format_transaction(transaction)
-      formatted_transaction = transaction.clone
+    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
 
-      formatted_transaction['amount'] =
-        Money.from_cents(formatted_transaction['amount'].to_f * 100, @settings[:currency]).format(
-          symbol: @settings[:show_symbol],
-          sign_before_symbol: @settings[:sign_before_symbol],
-          thousands_separator: @settings[:thousands_separator] ? ',' : nil
-        )
+          forecasts.each do |forecast|
+            account = forecast['account']
+            from = Date.parse(forecast['from'])
+            to = forecast['to'] ? Date.parse(forecast['to']) : nil
+            transactions = forecast['transactions']
 
-      formatted_transaction
+            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.process_custom(output, forecast_data, date)
-      forecast_data['custom']&.each do |forecast|
-        start_date = Date.parse(forecast['start'])
-        end_date = forecast['end'] ? Date.parse(forecast['end']) : nil
-        account = forecast['account']
-        period = forecast['recurrence']['period']
-        quantity = forecast['recurrence']['quantity']
+    def self.regular_transaction(frequency, from, to, transactions, account)
+      transactions = transactions.select { |transaction| transaction['to'].nil? }
+      return "" if transactions.empty?
 
-        next if end_date && date > end_date
+      output = ""
 
-        date_matches = case period
-                       when 'days'
-                         (date - start_date).to_i % quantity == 0
-                       when 'weeks'
-                         (date - start_date).to_i % (quantity * 7) == 0
-                       when 'months'
-                         ((date.year * 12 + date.month) - (start_date.year * 12 + start_date.month)) % quantity == 0 && date.day == start_date.day
-                       end
+      transactions.each do |transaction|
+        if track_transaction?(transaction, from)
+          track_transaction(from, to, account, transaction)
+          next
+        end
+
+        modified_transaction(from, to, account, transaction)
 
-        if date_matches
-          forecast['transactions'].each do |transaction|
-            end_date = transaction['end'] ? Date.parse(transaction['end']) : nil
+        output += output_transaction(transaction['category'], format_amount(calculate_amount(transaction['amount'])),
+                                     transaction['description'])
+      end
 
-            next unless end_date.nil? || date <= end_date
+      return "" unless output != ""
 
-            write_transactions(output, date, account, format_transaction(transaction))
-          end
+      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.process_forecast(output_file, forecast_data, type, date)
-      forecast_data[type]&.each do |forecast|
-        start_date = Date.parse(forecast['start'])
-        end_date = forecast['end'] ? Date.parse(forecast['end']) : nil
+    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
 
-        next if end_date && date > end_date
-
-        date_matches = case type
-                       when 'monthly'
-                         date.day == start_date.day
-                       when 'quarterly'
-                         date.day == start_date.day && date.month % 3 == start_date.month % 3
-                       when 'half-yearly'
-                         date.day == start_date.day && (date.month - start_date.month) % 6 == 0
-                       when 'yearly'
-                         date.day == start_date.day && date.month == start_date.month
-                       when 'once'
-                         date == start_date
-                       end
-
-        if date_matches
-          forecast['transactions'].each do |transaction|
-            transaction_start_date = transaction['start'] ? Date.parse(transaction['start']) : nil
-            transaction_end_date = transaction['end'] ? Date.parse(transaction['end']) : nil
-
-            if (transaction_start_date && date < transaction_start_date) || (transaction_end_date && date > transaction_end_date)
-              next
-            end
-
-            write_transactions(output_file, date, account, format_transaction(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
+
+        output += "    #{account}\n\n"
       end
+
+      output
     end
 
-    def self.generate(transactions, forecast, start_date, end_date)
-      start_date = Date.parse(start_date)
-      end_date = Date.parse(end_date)
-      forecast_data = YAML.safe_load(forecast)
+    def self.output_transaction(category, amount, description)
+      "    #{category.ljust(@options[:max_category])}    #{amount.ljust(@options[:max_amount])};  #{description}\n"
+    end
 
-      configure_settings(forecast_data)
+    def self.output_modified_transaction(transactions)
+      output = ""
 
-      output = ''
-      output.concat(transactions) if transactions
+      transactions.each do |_key, transaction|
+        date = "date:#{transaction['from']}"
+        date += "..#{transaction['to']}" if transaction['to']
 
-      date = start_date
+        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
+    end
+
+    def self.output_tracked_transaction(transactions)
+      output = ""
 
-      while date <= end_date
-        process_forecast(output, forecast_data, 'monthly', date)
-        process_forecast(output, forecast_data, 'quarterly', date)
-        process_forecast(output, forecast_data, 'half-yearly', date)
-        process_forecast(output, forecast_data, 'yearly', date)
-        process_forecast(output, forecast_data, 'once', date)
-        process_custom(output, forecast_data, date)
+      transactions.each do |_key, transaction|
+        next if transaction['found']
 
-        date = date.next_day
+        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
 
       output
     end
+
+    def self.extract_descriptions(transactions, from)
+      descriptions = []
+
+      transactions.each do |transaction|
+        next if track_transaction?(transaction, from)
+
+        description = transaction['description']
+        descriptions << description
+      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)
+        }
+      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
+    end
   end
 end

data/lib/hledger_forecast/summarize.rb

@@ -15,7 +15,7 @@ module HledgerForecast
 
     def self.init_generator(forecast_data)
       generator = HledgerForecast::Generator
-      generator.configure_settings(forecast_data)
+      generator.set_options(forecast_data)
 
       @generator = generator
     end
@@ -37,8 +37,7 @@ module HledgerForecast
 
       forecast_data['custom']&.each do |entry|
         period_data = {}
-        period_data[:quantity] = entry['recurrence']['quantity']
-        period_data[:period] = entry['recurrence']['period']
+        period_data[:frequency] = entry['frequency']
         period_data[:category] = entry['transactions'].first['category']
         period_data[:amount] = entry['transactions'].first['amount']
 
@@ -53,7 +52,7 @@ module HledgerForecast
     end
 
     def self.format_amount(amount)
-      formatted_amount = @generator.format_transaction({ 'amount' => amount })['amount']
+      formatted_amount = @generator.format_amount(amount)
       amount.to_f < 0 ? formatted_amount.green : formatted_amount.red
     end
 
@@ -61,7 +60,7 @@ module HledgerForecast
       if custom
         row_data[:periods].each do |period|
           @table.add_row [{ value: period[:category], alignment: :left },
-                          { value: "every #{period[:quantity]} #{period[:period]}", alignment: :right },
+                          { value: period[:frequency], alignment: :right },
                           { value: format_amount(period[:amount]), alignment: :right }]
 
           period_total += period[:amount]