hledger-forecast 2.0.0 → 3.0.0

data/hledger-forecast.gemspec

@@ -1,30 +1,32 @@
-lib = File.expand_path('lib', __dir__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-require 'hledger_forecast/version'
+require "hledger_forecast/version"
 
 Gem::Specification.new do |s|
-  s.required_ruby_version = '~> 3.0'
-  s.name        = 'hledger-forecast'
-  s.version     = HledgerForecast::VERSION
-  s.authors     = ['Oli Morris']
-  s.summary     = "An extended wrapper around hledger's forecasting functionality"
-  s.description = 'Use a CSV file for improved forecasting with hledger'
-  s.email       = 'olimorris@users.noreply.github.com'
-  s.homepage    = 'https://github.com/olimorris/hledger-forecast'
-  s.license     = 'MIT'
+  s.required_ruby_version = "~> 3.3"
+  s.name = "hledger-forecast"
+  s.version = HledgerForecast::VERSION
+  s.authors = ["Oli Morris"]
+  s.summary = "An extended wrapper around hledger's forecasting functionality"
+  s.description = "Use a CSV file for improved forecasting with hledger"
+  s.email = "olimorris@users.noreply.github.com"
+  s.homepage = "https://github.com/olimorris/hledger-forecast"
+  s.license = "MIT"
 
-  s.add_dependency "colorize", "~> 0.8.1"
-  s.add_dependency "dentaku", "~> 3.5.1"
-  s.add_dependency "highline", "~> 2.1.0"
-  s.add_dependency "money", "~> 6.16.0"
-  s.add_dependency "terminal-table", "~> 3.0.2"
-  s.add_development_dependency 'rspec', '~> 3.12'
+  s.add_dependency("abbrev", "~> 0.1")
+  s.add_dependency("csv", "~> 3.0")
+  s.add_dependency("colorize", "~> 0.8.1")
+  s.add_dependency("dentaku", "~> 3.5.1")
+  s.add_dependency("highline", "~> 2.1.0")
+  s.add_dependency("money", "~> 6.16.0")
+  s.add_dependency("terminal-table", "~> 3.0.2")
+  s.add_development_dependency("rspec", "~> 3.12")
 
   s.files = `git ls-files`.split("\n")
   s.test_files = `git ls-files -- spec/*`.split("\n")
   s.executables = `git ls-files -- bin/*`.split("\n").map do |f|
     File.basename(f)
   end
-  s.require_paths = ['lib']
+  s.require_paths = ["lib"]
 end

data/lib/hledger_forecast/calculator.rb

@@ -1,25 +1,17 @@
 module HledgerForecast
-  # Calculate various
-  class Calculator
-    def initialize
-      @calculator = Dentaku::Calculator.new
-    end
+  module Calculator
+    @calc = Dentaku::Calculator.new
 
-    def evaluate(amount)
+    def self.evaluate(amount)
       return amount.to_f unless amount.is_a?(String)
 
-      @calculator.evaluate(amount.slice(1..-1))
+      @calc.evaluate(amount.slice(1..-1))
     end
 
-    def evaluate_date(from, to)
-      if to[0] != "="
-        return to if to.is_a?(Date)
-
-        return Date.parse(to)
-      end
+    def self.evaluate_date(from, to)
+      return Date.parse(to) unless to.start_with?("=")
 
-      # Subtract a day from the final date
-      (from >> @calculator.evaluate(to.slice(1..-1))) - 1
+      (from >> @calc.evaluate(to.slice(1..-1))) - 1
     end
   end
 end

data/lib/hledger_forecast/cli.rb

@@ -4,14 +4,14 @@ module HledgerForecast
   class Cli
     def self.run(command, options)
       case command
-      when 'generate'
+      when "generate"
         generate(options)
-      when 'summarize'
+      when "summarize"
         summarize(options)
-      when 'compare'
+      when "compare"
         compare(options)
       else
-        puts "Unknown command: #{command}"
+        puts("Unknown command: #{command}")
         exit(1)
       end
     end
@@ -22,49 +22,49 @@ module HledgerForecast
 
       global = OptionParser.new do |opts|
         opts.banner = "Usage: hledger-forecast [command] [options]"
-        opts.separator ""
-        opts.separator "Commands:"
-        opts.separator "  generate    Generate a forecast from a file"
-        opts.separator "  summarize   Summarize the forecast file and output to the terminal"
-        opts.separator "  compare     Compare and highlight the differences between two CSV files"
-        opts.separator ""
-        opts.separator "Options:"
+        opts.separator("")
+        opts.separator("Commands:")
+        opts.separator("  generate    Generate a forecast from a file")
+        opts.separator("  summarize   Summarize the forecast file and output to the terminal")
+        opts.separator("  compare     Compare and highlight the differences between two CSV files")
+        opts.separator("")
+        opts.separator("Options:")
 
         opts.on_tail("-h", "--help", "Show this help message") do
-          puts opts
+          puts(opts)
           exit
         end
 
         opts.on_tail("-v", "--version", "Show the installed version") do
-          puts VERSION
+          puts(VERSION)
           exit
         end
       end
 
       if args.empty?
-        puts global
+        puts(global)
         exit(1)
       end
 
       begin
         global.order!(args)
-        command = args.shift || 'generate'
+        command = args.shift || "generate"
       rescue OptionParser::InvalidOption => e
-        puts e
-        puts global
+        puts(e)
+        puts(global)
         exit(1)
       end
 
       case command
-      when 'generate'
+      when "generate"
         options = parse_generate_options(args)
-      when 'summarize'
+      when "summarize"
         options = parse_summarize_options(args)
-      when 'compare'
+      when "compare"
         options = parse_compare_options(args)
       else
-        puts "Unknown command: #{command}"
-        puts global
+        puts("Unknown command: #{command}")
+        puts(global)
         exit(1)
       end
 
@@ -76,41 +76,50 @@ module HledgerForecast
 
       global = OptionParser.new do |opts|
         opts.banner = "Usage: hledger-forecast generate [options]"
-        opts.separator ""
+        opts.separator("")
 
-        opts.on("-f", "--forecast FILE",
-                "The path to the FORECAST csv file to generate from") do |file|
+        opts.on(
+          "-f",
+          "--forecast FILE",
+          "The path to the FORECAST csv file to generate from"
+        ) do |file|
           options[:forecast_file] = file
-          options[:output_file] ||= file.sub('csv', 'journal')
+          options[:output_file] ||= file.sub("csv", "journal")
         end
 
-        opts.on("-o", "--output-file FILE",
-                "The path to the OUTPUT file to create") do |file|
+        opts.on(
+          "-o",
+          "--output-file FILE",
+          "The path to the OUTPUT file to create"
+        ) do |file|
           options[:output_file] = file
         end
 
-        opts.on("-t", "--transaction FILE",
-                "The path to the TRANSACTION journal file") do |file|
-          options[:transaction_file] = file
-        end
-
-        opts.on("-v", "--verbose",
-                "Do not group transactions in the output file") do
+        opts.on(
+          "-v",
+          "--verbose",
+          "Do not group transactions in the output file"
+        ) do
           options[:verbose] = true
         end
 
-        opts.on("--force",
-                "Force an overwrite of the output file") do
-          options[:force] = true
+        opts.on(
+          "-t",
+          "--tags TAGS",
+          "Only include transactions with given tags (comma-separated)"
+        ) do |tags|
+          options[:tags] = tags.split(",").map(&:strip)
         end
 
-        opts.on("--no-track",
-                "Do not track any transactions") do
-          options[:no_track] = true
+        opts.on(
+          "--force",
+          "Force an overwrite of the output file"
+        ) do
+          options[:force] = true
         end
 
         opts.on_tail("-h", "--help", "Show this help message") do
-          puts opts
+          puts(opts)
           exit
         end
       end
@@ -118,13 +127,13 @@ module HledgerForecast
       begin
         global.parse!(args)
       rescue OptionParser::InvalidOption => e
-        puts e
-        puts global
+        puts(e)
+        puts(global)
         exit(1)
       end
 
       if options.empty?
-        puts global
+        puts(global)
         exit(1)
       end
 
@@ -140,21 +149,39 @@ module HledgerForecast
 
       global = OptionParser.new do |opts|
         opts.banner = "Usage: hledger-forecast summarize [options]"
-        opts.separator ""
+        opts.separator("")
 
-        opts.on("-f", "--forecast FILE",
-                "The path to the FORECAST csv file to summarize") do |file|
+        opts.on(
+          "-f",
+          "--forecast FILE",
+          "The path to the FORECAST csv file to summarize"
+        ) do |file|
           options[:forecast_file] = file
         end
 
-        opts.on("-r", "--roll-up PERIOD",
-                "The period to roll-up your forecasts into. One of:",
-                "[yearly], [half-yearly], [quarterly], [monthly], [weekly], [daily]") do |rollup|
-          options[:roll_up] = rollup
+        opts
+          .on(
+            "-r",
+            "--roll-up PERIOD",
+            "The period to roll-up your forecasts into. One of:",
+            "[yearly], [half-yearly], [quarterly], [monthly], [weekly], [daily]"
+          ) do |rollup|
+            options[:roll_up] = rollup
+          end
+
+        opts.on(
+          "-t",
+          "--tags TAGS",
+          "Only include transactions with given tags (comma-separated)"
+        ) do |tags|
+          options[:tags] = tags.split(",").map(&:strip)
         end
 
-        opts.on("-v", "--verbose",
-                "Show additional information in the summary") do |_|
+        opts.on(
+          "-v",
+          "--verbose",
+          "Show additional information in the summary"
+        ) do |_|
           options[:verbose] = true
         end
 
@@ -176,7 +203,7 @@ module HledgerForecast
         # end
 
         opts.on_tail("-h", "--help", "Show this help message") do
-          puts opts
+          puts(opts)
           exit
         end
       end
@@ -184,13 +211,13 @@ module HledgerForecast
       begin
         global.parse!(args)
       rescue OptionParser::InvalidOption => e
-        puts e
-        puts global
+        puts(e)
+        puts(global)
         exit(1)
       end
 
       if options.empty?
-        puts global
+        puts(global)
         exit(1)
       end
 
@@ -202,19 +229,19 @@ module HledgerForecast
 
       global = OptionParser.new do |opts|
         opts.banner = "Usage: hledger-forecast compare [path/to/file1.csv] [path/to/file2.csv]"
-        opts.separator ""
+        opts.separator("")
       end
 
       begin
         global.parse!(args)
       rescue OptionParser::InvalidOption => e
-        puts e
-        puts global
+        puts(e)
+        puts(global)
         exit(1)
       end
 
       if args[0].nil? || args[1].nil?
-        puts global
+        puts(global)
         exit(1)
       end
 
@@ -230,25 +257,25 @@ module HledgerForecast
       begin
         transactions = Generator.generate(forecast, options)
       rescue StandardError => e
-        puts "An error occurred while generating transactions: #{e.message}"
+        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 "\nFile '#{output_file}' already exists. Overwrite? (y/n): "
+        print("\nFile '#{output_file}' already exists. Overwrite? (y/n): ")
         overwrite = gets.chomp.downcase
 
-        if overwrite == 'y'
+        if overwrite == "y"
           File.write(output_file, transactions)
-          puts "\nSuccess: ".bold.green + "File '#{output_file}' has been overwritten."
+          puts("\nSuccess: ".bold.green + "File '#{output_file}' has been overwritten.")
         else
-          puts "\nInfo: ".bold.blue + "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 "\nSuccess: ".bold.green + "File '#{output_file}' has been created"
+        puts("\nSuccess: ".bold.green + "File '#{output_file}' has been created")
       end
     end
 
@@ -258,15 +285,15 @@ module HledgerForecast
 
       summarizer = Summarizer.summarize(config, options)
 
-      puts SummarizerFormatter.format(summarizer[:output], summarizer[:settings])
+      puts(SummarizerFormatter.format(summarizer[:output], summarizer[:settings]))
     end
 
     def self.compare(options)
       if !File.exist?(options[:file1]) || !File.exist?(options[:file2])
-        return puts "\nError: ".bold.red + "One or more of the files could not be found to compare"
+        return puts("\nError: ".bold.red + "One or more of the files could not be found to compare")
       end
 
-      puts Comparator.compare(options[:file1], options[:file2])
+      puts(Comparator.compare(options[:file1], options[:file2]))
     end
   end
 end

data/lib/hledger_forecast/comparator.rb

@@ -20,17 +20,17 @@ module HledgerForecast
       csv2 = CSV.read(file2)
 
       unless csv1.length == csv2.length && csv1[0].length == csv2[0].length
-        return puts "\nError: ".bold.red + "The files have different formats and cannot be compared"
+        return puts("\nError: ".bold.red + "The files have different formats and cannot be compared")
       end
 
-      @table.add_row csv2[0].map(&:bold)
+      @table.add_row(csv2[0].map(&:bold))
       @table.add_separator
 
       generate_diff(csv1, csv2).drop(1).each do |row|
-        @table.add_row [row[0].bold] + row[1..]
+        @table.add_row([row[0].bold] + row[1..])
       end
 
-      puts @table
+      puts(@table)
     end
 
     def header?(row_num)
@@ -40,7 +40,8 @@ module HledgerForecast
     def generate_diff(csv1, csv2)
       csv1.each_with_index.map do |row, i|
         row.each_with_index.map do |cell, j|
-          if header?(i) || j == 0 # Checking for the first column here
+          # Checking for the first column here
+          if header?(i) || j == 0
             csv2[i][j]
           else
             difference = parse_money(csv2[i][j]) - parse_money(cell)
@@ -66,17 +67,17 @@ module HledgerForecast
     end
 
     def parse_money(value)
-      return 0.0 if value.strip == '0'
+      return 0.0 if value.strip == "0"
 
-      value.gsub(/[^0-9.-]/, '').to_f
+      value.gsub(/[^0-9.-]/, "").to_f
     end
 
     def format_difference(amount, currency)
       formatted_amount = if currency.nil?
-                           format("%.2f", amount)
-                         else
-                           Formatter.format_money(amount, { currency: currency })
-                         end
+        format("%.2f", amount)
+      else
+        Formatter.format_money(amount, Settings.parse([], {currency: currency}))
+      end
 
       return formatted_amount if amount == 0
 

data/lib/hledger_forecast/forecast.rb

@@ -0,0 +1,29 @@
+module HledgerForecast
+  class Forecast
+    attr_reader :transactions, :settings
+
+    def self.parse(csv_string, cli_options = nil)
+      rows = CSV.parse(
+        csv_string,
+        headers: true,
+        header_converters: -> (h) { h.to_s.tr("-", "_").to_sym },
+        converters: :numeric
+      )
+
+      settings = Settings.parse(rows.select { |r| r[:type] == "settings" }, cli_options)
+      transactions = rows.reject { |r| r[:type] == "settings" }.map { |r| Transaction.from_row(r) }
+
+      new(transactions, settings, rows.headers.include?(:tag))
+    end
+
+    def has_tags_column? = @has_tags_column
+
+    private
+
+    def initialize(transactions, settings, has_tags_column)
+      @transactions = transactions
+      @settings = settings
+      @has_tags_column = has_tags_column
+    end
+  end
+end

data/lib/hledger_forecast/formatter.rb

@@ -1,24 +1,22 @@
 module HledgerForecast
-  # Formats various items used throughout the application
   class Formatter
     def self.format_money(amount, settings)
-      Money.from_cents(amount.to_f * 100, (settings[:currency]) || 'USD').format(
-        symbol: settings[:show_symbol] || true,
-        sign_before_symbol: settings[:sign_before_symbol] || false,
-        thousands_separator: settings[:thousands_separator] ? ',' : nil
+      Money.from_cents(amount.to_f * 100, settings.currency).format(
+        symbol: settings.show_symbol,
+        sign_before_symbol: settings.sign_before_symbol,
+        thousands_separator: resolve_separator(settings.thousands_separator)
       )
     end
 
-    def self.output_to_ledger(*compiled_data)
-      output = compiled_data.compact.map do |data|
-        data.map do |item|
-          next unless item[:transactions].any?
-
-          item[:header] + item[:transactions].join + item[:footer]
-        end.join
-      end.join("\n")
-
-      output.gsub(/\n{2,}/, "\n\n")
+    private_class_method def self.resolve_separator(value)
+      case value
+      when "false", false, nil
+        nil
+      when "true", true
+        ","
+      else
+        value
+      end
     end
   end
 end

data/lib/hledger_forecast/generator.rb

@@ -1,83 +1,43 @@
 module HledgerForecast
-  # Generate forecasts for hledger from a yaml config file
   class Generator
-    def self.generate(config, cli_options = nil)
-      new.generate(config, cli_options)
-    end
-
-    def generate(config, cli_options = nil)
-      forecast = CSV.parse(config, headers: true)
-      @settings = Settings.config(forecast, cli_options)
-
-      processed = []
-      forecast.each do |row|
-        next if row['type'] == "settings"
+    def self.generate(csv_string, cli_options = nil)
+      forecast = Forecast.parse(csv_string, cli_options)
+      transactions = forecast.transactions
 
-        processed.push(process_forecast(row))
+      if cli_options&.dig(:tags)
+        raise "The --tags option requires a 'tag' column in the forecast CSV" unless forecast.has_tags_column?
+        transactions = transactions.select { |t| t.matches_tags?(cli_options[:tags]) }
       end
 
-      unless @settings[:verbose]
-        processed = processed.group_by do |row|
-          [row[:type], row[:frequency], row[:from], row[:to], row[:account], row[:track]]
-        end
-
-        processed = processed.map do |(type, frequency, from, to, account, track), transactions|
-          {
-            type: type,
-            frequency: frequency,
-            from: from,
-            to: to,
-            account: account,
-            track: track || false,
-            transactions: transactions
-          }
-        end
-      end
-
-      Formatter.output_to_ledger(
-        Transactions::Default.generate(processed, @settings),
-        Transactions::Trackers.generate(processed, @settings)
-      )
-    end
-
-    private
-
-    def process_forecast(row)
-      row['amount'] = Utilities.convert_amount(row['amount'])
-
-      {
-        type: row['type'],
-        frequency: row['frequency'] || nil,
-        account: row['account'],
-        from: Date.parse(row['from']),
-        to: row['to'] ? Calculator.new.evaluate_date(Date.parse(row['from']), row['to']) : nil,
-        description: row['description'],
-        category: row['category'],
-        amount: Formatter.format_money(Calculator.new.evaluate(row['amount']), @settings),
-        track: Transactions::Trackers.track?(row, @settings) ? true : false
-      }
+      Transactions::Default.render(build_groups(transactions, forecast.settings), forecast.settings)
     end
 
-    def transform_data(data)
-      transformed_data = []
-
-      data.each do |group_key, transactions|
-        next if group_key == "settings"
-
-        split_keys = group_key.split("@@")
-
-        group_info = {
-          type: split_keys[0],
-          from: split_keys[1],
-          to: split_keys[2],
-          account: split_keys[3],
-          transactions: transactions
-        }
-
-        transformed_data << group_info
+    private_class_method def self.build_groups(transactions, settings)
+      if settings.verbose?
+        transactions.map do |t|
+          TransactionGroup.new(
+            type: t.type,
+            frequency: t.frequency,
+            account: t.account,
+            from: t.from,
+            to: t.to,
+            transactions: [t]
+          )
+        end
+      else
+        transactions
+          .group_by { |t| [t.type, t.frequency, t.from, t.to, t.account] }
+          .map do |(type, frequency, from, to, account), txns|
+            TransactionGroup.new(
+              type: type,
+              frequency: frequency,
+              account: account,
+              from: from,
+              to: to,
+              transactions: txns
+            )
+          end
       end
-
-      transformed_data
     end
   end
 end