reckon 0.8.1 → 0.9.1

data/lib/reckon/csv_parser.rb

@@ -1,32 +1,28 @@
-#coding: utf-8
+# frozen_string_literal: true
+
+require 'stringio'
 
 module Reckon
+  # Parses CSV files
   class CSVParser
-    attr_accessor :options, :csv_data, :money_column_indices, :date_column_index, :description_column_indices, :money_column, :date_column
+    attr_accessor :options, :csv_data, :money_column_indices, :date_column_index,
+                  :description_column_indices, :money_column, :date_column
 
     def initialize(options = {})
       self.options = options
+
+      self.options[:csv_separator] = "\t" if options[:csv_separator] == '\t'
       self.options[:currency] ||= '$'
+
+      # we convert to a string so we can do character encoding cleanup
       @csv_data = parse(options[:string] || File.read(options[:file]), options[:file])
       filter_csv
       detect_columns
     end
 
+    # transpose csv_data (array of rows) to an array of columns
     def columns
-      @columns ||=
-        begin
-          last_row_length = nil
-          csv_data.inject([]) do |memo, row|
-            unless row.all? { |i| i.nil? || i.length == 0 }
-              row.each_with_index do |entry, index|
-                memo[index] ||= []
-                memo[index] << (entry || '').strip
-              end
-              last_row_length = row.length
-            end
-            memo
-          end
-        end
+      @columns ||= @csv_data[0].zip(*@csv_data[1..])
     end
 
     def date_for(index)
@@ -34,7 +30,7 @@ module Reckon
     end
 
     def pretty_date_for(index)
-      @date_column.pretty_for( index )
+      @date_column.pretty_for(index)
     end
 
     def money_for(index)
@@ -42,7 +38,7 @@ module Reckon
     end
 
     def pretty_money(amount, negate = false)
-      Money.new( amount, @options ).pretty( negate )
+      Money.new(amount, @options).pretty(negate)
     end
 
     def pretty_money_for(index, negate = false)
@@ -54,11 +50,11 @@ module Reckon
 
     def description_for(index)
       description_column_indices.map { |i| columns[i][index].to_s.strip }
-        .reject(&:empty?)
-        .join("; ")
-        .squeeze(" ")
-        .gsub(/(;\s+){2,}/, '')
-        .strip
+                                .reject(&:empty?)
+                                .join("; ")
+                                .squeeze(" ")
+                                .gsub(/(;\s+){2,}/, '')
+                                .strip
     end
 
     def row(index)
@@ -84,9 +80,10 @@ module Reckon
         money_score = date_score = possible_neg_money_count = possible_pos_money_count = 0
         last = nil
         column.reverse.each_with_index do |entry, row_from_bottom|
+          entry ||= "" # entries can be nil
           row = csv_data[csv_data.length - 1 - row_from_bottom]
           entry = entry.strip
-          money_score += Money::likelihood( entry )
+          money_score += Money::likelihood(entry)
           possible_neg_money_count += 1 if entry =~ /^\$?[\-\(]\$?\d+/
           possible_pos_money_count += 1 if entry =~ /^\+?\$?\+?\d+/
           date_score += DateColumn.likelihood(entry)
@@ -97,8 +94,8 @@ module Reckon
             row.each do |row_entry|
               row_entry = row_entry.to_s.gsub(/[^\-\d\.]/, '').to_f
               if row_entry != 0 && last + row_entry == entry_as_num
-                 money_score -= 10
-                 break
+                money_score -= 10
+                break
               end
             end
           end
@@ -110,7 +107,8 @@ module Reckon
           found_likely_money_column = true
         end
 
-        results << { :index => index, :money_score => money_score, :date_score => date_score }
+        results << { :index => index, :money_score => money_score,
+                     :date_score => date_score }
       end
 
       results.sort_by! { |n| -n[:money_score] }
@@ -126,24 +124,18 @@ module Reckon
       return results.sort_by { |n| n[:index] }
     end
 
-    def found_double_money_column(id1, id2)
-      self.money_column_indices = [id1, id2]
-      puts "It looks like this CSV has two seperate columns for money, one of which shows positive"
-      puts "changes and one of which shows negative changes.  If this is true, great.  Otherwise,"
-      puts "please report this issue to us so we can take a look!\n"
-    end
-
     # Some csv files negative/positive amounts are indicated in separate account
     def detect_sign_column
       return if columns[0].length <= 2 # This test needs requires more than two rows otherwise will lead to false positives
+
       signs = []
       if @money_column_indices[0] > 0
-        column = columns[ @money_column_indices[0] - 1 ]
+        column = columns[@money_column_indices[0] - 1]
         signs = column.uniq
       end
       if (signs.length != 2 &&
           (@money_column_indices[0] + 1 < columns.length))
-        column = columns[ @money_column_indices[0] + 1 ]
+        column = columns[@money_column_indices[0] + 1]
         signs = column.uniq
       end
       if signs.length == 2
@@ -162,14 +154,34 @@ module Reckon
     def detect_columns
       results = evaluate_columns(columns)
 
+      # We keep money_column options for backwards compatibility reasons, while
+      # adding option to specify multiple money_columns
       if options[:money_column]
         self.money_column_indices = [options[:money_column] - 1]
+
+      # One or two columns can be specified as money_columns
+      elsif options[:money_columns]
+        if options[:money_columns].length == 1
+          self.money_column_indices = [options[:money_column] - 1]
+        elsif options[:money_columns].length == 2
+          in_col, out_col = options[:money_columns]
+          self.money_column_indices = [in_col - 1, out_col - 1]
+        else
+          puts "Unable to determine money columns, use --money-columns to specify the 1 or 2 column(s) reckon should use."
+        end
+
+      # If no money_column(s) argument is supplied, try to automatically infer money_column(s)
       else
-        self.money_column_indices = results.select { |n| n[:is_money_column] }.map { |n| n[:index] }
+        self.money_column_indices = results.select { |n|
+                                      n[:is_money_column]
+                                    }.map { |n| n[:index] }
         if self.money_column_indices.length == 1
+          # TODO: print the unfiltered column number, not the filtered
+          # ie if money column is 7, but we ignore columns 4 and 5, this prints "Using column 5 as the money column"
           puts "Using column #{money_column_indices.first + 1} as the money column.  Use --money-colum to specify a different one."
         elsif self.money_column_indices.length == 2
-          found_double_money_column(*self.money_column_indices)
+          puts "Using columns #{money_column_indices[0] + 1} and #{money_column_indices[1] + 1} as money column. Use --money-columns to specify different ones."
+          self.money_column_indices = self.money_column_indices[0..1]
         else
           puts "Unable to determine a money column, use --money-column to specify the column reckon should use."
         end
@@ -195,20 +207,53 @@ module Reckon
       self.description_column_indices = results.map { |i| i[:index] }
     end
 
-    def parse(data, filename=nil)
+    def parse(data, filename = nil)
       # Use force_encoding to convert the string to utf-8 with as few invalid characters
       # as possible.
       data.force_encoding(try_encoding(data, filename))
       data = data.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
       data.sub!("\xEF\xBB\xBF", '') # strip byte order marker, if it exists
 
-      rows = []
-      data.each_line.with_index do |line, i|
-        next if i < (options[:contains_header] || 0)
-        rows << CSV.parse_line(line, col_sep: options[:csv_separator] || ',')
+      separator = options[:csv_separator] || guess_column_separator(data)
+      header_lines_to_skip = options[:contains_header] || 0
+      # -1 is skip 0 footer rows
+      footer_lines_to_skip = (options[:contains_footer] || 0) + 1
+
+      # convert to a stringio object to handle multi-line fields
+      parser_opts = {
+        col_sep: separator,
+        skip_blanks: true
+      }
+      begin
+        rows = CSV.parse(StringIO.new(data), **parser_opts)
+        rows[header_lines_to_skip..-footer_lines_to_skip]
+      rescue CSV::MalformedCSVError
+        # try removing N header lines before parsing
+        index = 0
+        count = 0
+        while count < header_lines_to_skip
+          index = data.index("\n", index) + 1 # skip over newline character
+          count += 1
+        end
+        rows = CSV.parse(StringIO.new(data[index..-1]), **parser_opts)
+        rows[0..-footer_lines_to_skip]
       end
+    end
+
+    def guess_column_separator(data)
+      delimiters = [',', "\t", ';', ':', '|']
+
+      counts = [0] * delimiters.length
+
+      data.each_line do |line|
+        delimiters.each_with_index do |delim, i|
+          counts[i] += line.count(delim)
+        end
+      end
+
+      LOGGER.info("guessing #{delimiters[counts.index(counts.max)]} as csv separator")
 
-      rows
+      delimiters[counts.index(counts.max)]
     end
 
     def try_encoding(data, filename = nil)

data/lib/reckon/date_column.rb

@@ -2,13 +2,17 @@ module Reckon
   class DateColumn < Array
     attr_accessor :endian_precedence
     def initialize( arr = [], options = {} )
-      @options = options
+      # output date format
+      @ledger_date_format = options[:ledger_date_format]
+
+      # input date format
+      date_format = options[:date_format]
       arr.each do |value|
-        if options[:date_format]
+        if date_format
           begin
-            value = Date.strptime(value, options[:date_format])
+            value = Date.strptime(value, date_format)
           rescue
-            puts "I'm having trouble parsing '#{value}' with the desired format: #{options[:date_format]}"
+            puts "I'm having trouble parsing '#{value}' with the desired format: #{date_format}"
             exit 1
           end
         else
@@ -34,7 +38,7 @@ module Reckon
         self.push( value )
       end
       # if endian_precedence still nil, raise error
-      unless @endian_precedence || options[:date_format]
+      unless @endian_precedence || date_format
         raise( "Unable to determine date format. Please specify using --date-format" )
       end
     end
@@ -54,7 +58,7 @@ module Reckon
       date = self.for(index)
       return "" if date.nil?
 
-      date.strftime(@options[:ledger_date_format] || '%Y-%m-%d')
+      date.strftime(@ledger_date_format || '%Y-%m-%d')
     end
 
     def self.likelihood(entry)
@@ -65,7 +69,14 @@ module Reckon
       date_score -= entry.gsub(/[\-\/\.\d:\[\]]/, '').length
       date_score += 30 if entry =~ /^\d+[:\/\.-]\d+[:\/\.-]\d+([ :]\d+[:\/\.]\d+)?$/
       date_score += 10 if entry =~ /^\d+\[\d+:GMT\]$/i
-      return date_score
+
+      begin
+        DateTime.parse(entry)
+        date_score += 20
+      rescue Date::Error, ArgumentError
+      end
+
+      date_score
     end
   end
 end

data/lib/reckon/ledger_parser.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # frozen_string_literal: true
 
 # From: https://www.ledger-cli.org/3.0/doc/ledger3.html#Transactions-and-Comments
@@ -110,20 +109,20 @@ require 'rubygems'
 module Reckon
   class LedgerParser
 
-    attr_accessor :entries
-
-    def initialize(ledger, options = {})
+    # ledger is an object that response to #each_line,
+    # (i.e. a StringIO or an IO object)
+    def initialize(options = {})
       @options = options
       @date_format = options[:ledger_date_format] || options[:date_format] || '%Y-%m-%d'
-      parse(ledger)
     end
 
     def parse(ledger)
-      @entries = []
+      entries = []
       new_entry = {}
       in_comment = false
       comment_chars = ';#%*|'
-      ledger.strip.split("\n").each do |entry|
+      ledger.each_line do |entry|
+        entry.rstrip!
         # strip comment lines
         in_comment = true if entry == 'comment'
         in_comment = false if entry == 'end comment'
@@ -132,7 +131,7 @@ module Reckon
 
         # (date, type, code, description), type and code are optional
         if (m = entry.match(%r{^(\d+[\d/-]+)\s+([*!])?\s*(\([^)]+\))?\s*(.*)$}))
-          add_entry(new_entry)
+          add_entry(entries, new_entry)
           new_entry = {
             date: try_parse_date(m[1]),
             type: m[2] || "",
@@ -141,23 +140,24 @@ module Reckon
             accounts: []
           }
         elsif entry =~ /^\s*$/ && new_entry[:date]
-          add_entry(new_entry)
+          add_entry(entries,new_entry)
           new_entry = {}
         elsif new_entry[:date] && entry =~ /^\s+/
           LOGGER.info("Adding new account #{entry}")
           new_entry[:accounts] << parse_account_line(entry)
         else
           LOGGER.info("Unknown entry type: #{entry}")
-          add_entry(new_entry)
+          add_entry(entries, new_entry)
           new_entry = {}
         end
       end
-      add_entry(new_entry)
+      add_entry(entries, new_entry)
+      entries
     end
 
     # roughly matches ledger csv format
-    def to_csv
-      return @entries.flat_map do |n|
+    def to_csv(ledger)
+      return parse(ledger).flat_map do |n|
         n[:accounts].map do |a|
           row = [
             n[:date].strftime(@date_format),
@@ -174,13 +174,21 @@ module Reckon
       end
     end
 
+    def format_row(row, line1, line2)
+      out = "#{row[:pretty_date]}\t#{row[:description]}#{row[:note] ? "\t; " + row[:note]: ""}\n"
+      out += "\t#{line1.first}\t\t\t#{line1.last}\n"
+      out += "\t#{line2.first}\t\t\t#{line2.last}\n\n"
+      out
+    end
+
+
     private
 
-    def add_entry(entry)
+    def add_entry(entries, entry)
       return unless entry[:date] && entry[:accounts].length > 1
 
       entry[:accounts] = balance(entry[:accounts])
-      @entries << entry
+      entries << entry
     end
 
     def try_parse_date(date_str)

data/lib/reckon/money.rb

@@ -6,11 +6,10 @@ module Reckon
     include Comparable
     attr_accessor :amount, :currency, :suffixed
     def initialize(amount, options = {})
-      @options = options
       @amount_raw = amount
       @raw = options[:raw]
 
-      @amount = parse(amount, options)
+      @amount = parse(amount, options[:comma_separates_cents])
       @amount = -@amount if options[:inverse]
       @currency = options[:currency] || "$"
       @suffixed = options[:suffixed]
@@ -21,7 +20,7 @@ module Reckon
     end
 
     def to_s
-      return @options[:raw] ? "#{@amount_raw} | #{@amount}" : @amount
+      return @raw ? "#{@amount_raw} | #{@amount}" : @amount
     end
 
     # unary minus
@@ -60,34 +59,37 @@ module Reckon
       return (@amount >= 0 ? " " : "") + amt
     end
 
+    def self.likelihood(entry)
+      money_score = 0
+      # digits separated by , or . with no more than 2 trailing digits
+      money_score += 40 if entry.match(/\d+[,.]\d{2}[^\d]*$/)
+      money_score += 10 if entry[/^\$?\-?\$?\d+[\.,\d]*?[\.,]\d\d$/]
+      money_score += 10 if entry[/\d+[\.,\d]*?[\.,]\d\d$/]
+      money_score += entry.gsub(/[^\d\.\-\+,\(\)]/, '').length if entry.length < 7
+      money_score -= entry.length if entry.length > 12
+      money_score -= 20 if (entry !~ /^[\$\+\.\-,\d\(\)]+$/) && entry.length > 0
+      money_score
+    end
+
+    private
+
     def pretty_amount(amount)
       sprintf("%0.2f", amount).reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
     end
 
-    def parse(value, options = {})
+    def parse(value, comma_separates_cents)
       value = value.to_s
       # Empty string is treated as money with value 0
       return value.to_f if value.to_s.empty?
 
       invert = value.match(/^\(.*\)$/)
       value = value.gsub(/[^0-9,.-]/, '')
-      value = value.tr('.', '').tr(',', '.') if options[:comma_separates_cents]
+      value = value.tr('.', '').tr(',', '.') if comma_separates_cents
       value = value.tr(',', '')
       value = value.to_f
       return invert ? -value : value
     end
 
-    def Money::likelihood(entry)
-      money_score = 0
-      # digits separated by , or . with no more than 2 trailing digits
-      money_score += 40 if entry.match(/\d+[,.]\d{2}[^\d]*$/)
-      money_score += 10 if entry[/^\$?\-?\$?\d+[\.,\d]*?[\.,]\d\d$/]
-      money_score += 10 if entry[/\d+[\.,\d]*?[\.,]\d\d$/]
-      money_score += entry.gsub(/[^\d\.\-\+,\(\)]/, '').length if entry.length < 7
-      money_score -= entry.length if entry.length > 12
-      money_score -= 20 if (entry !~ /^[\$\+\.\-,\d\(\)]+$/) && entry.length > 0
-      money_score
-    end
   end
 
   class MoneyColumn < Array

data/lib/reckon/options.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Reckon
+  # Singleton class for parsing command line flags
   class Options
-    @@cli = HighLine.new
-
-    def self.parse(args = ARGV, stdin = $stdin)
+    def self.parse_command_line_options(args = ARGV, stdin = $stdin)
+      cli = HighLine.new
       options = { output_file: $stdout }
       OptionParser.new do |opts|
         opts.banner = "Usage: Reckon.rb [options]"
@@ -32,36 +34,52 @@ module Reckon
           options[:output_file] = File.open(o, 'a')
         end
 
-        opts.on("-l", "--learn-from FILE", "An existing ledger file to learn accounts from") do |l|
+        opts.on("-l", "--learn-from FILE",
+                "An existing ledger file to learn accounts from") do |l|
           options[:existing_ledger_file] = l
         end
 
-        opts.on("", "--ignore-columns 1,2,5", "Columns to ignore, starts from 1") do |ignore|
+        opts.on("", "--ignore-columns 1,2,5",
+                "Columns to ignore, starts from 1") do |ignore|
           options[:ignore_columns] = ignore.split(",").map(&:to_i)
         end
 
-        opts.on("", "--money-column 2", Integer, "Column number of the money column, starts from 1") do |col|
+        opts.on("", "--money-column 2", Integer,
+                "Column number of the money column, starts from 1") do |col|
           options[:money_column] = col
         end
 
+        opts.on("", "--money-columns 2,3",
+                "Column number of the money columns, starts from 1 (1 or 2 columns)") do |ignore|
+          options[:money_columns] = ignore.split(",").map(&:to_i)
+        end
+
         opts.on("", "--raw-money", "Don't format money column (for stocks)") do |n|
           options[:raw] = n
         end
 
-        opts.on("", "--date-column 3", Integer, "Column number of the date column, starts from 1") do |col|
+        opts.on("", "--date-column 3", Integer,
+                "Column number of the date column, starts from 1") do |col|
           options[:date_column] = col
         end
 
-        opts.on("", "--contains-header [N]", Integer, "Skip N header rows - default 1") do |hdr|
+        opts.on("", "--contains-header [N]", Integer,
+                "Skip N header rows - default 1") do |hdr|
           options[:contains_header] = 1
           options[:contains_header] = hdr.to_i
         end
 
+        opts.on("", "--contains-footer [N]", Integer,
+                "Skip N footer rows - default 0") do |hdr|
+          options[:contains_footer] = hdr.to_i || 0
+        end
+
         opts.on("", "--csv-separator ','", "CSV separator (default ',')") do |sep|
           options[:csv_separator] = sep
         end
 
-        opts.on("", "--comma-separates-cents", "Use comma to separate cents ($100,50 vs. $100.50)") do |c|
+        opts.on("", "--comma-separates-cents",
+                "Use comma to separate cents ($100,50 vs. $100.50)") do |c|
           options[:comma_separates_cents] = c
         end
 
@@ -69,23 +87,28 @@ module Reckon
           options[:encoding] = e
         end
 
-        opts.on("-c", "--currency '$'", "Currency symbol to use - default $ (ex £, EUR)") do |e|
-          options[:currency] = e
+        opts.on("-c", "--currency '$'",
+                "Currency symbol to use - default $ (ex £, EUR)") do |e|
+          options[:currency] = e || '$'
         end
 
-        opts.on("", "--date-format FORMAT", "CSV file date format (see `date` for format)") do |d|
+        opts.on("", "--date-format FORMAT",
+                "CSV file date format (see `date` for format)") do |d|
           options[:date_format] = d
         end
 
-        opts.on("", "--ledger-date-format FORMAT", "Ledger date format (see `date` for format)") do |d|
+        opts.on("", "--ledger-date-format FORMAT",
+                "Ledger date format (see `date` for format)") do |d|
           options[:ledger_date_format] = d
         end
 
-        opts.on("-u", "--unattended", "Don't ask questions and guess all the accounts automatically. Use with --learn-from or --account-tokens options.") do |n|
+        opts.on("-u", "--unattended",
+                "Don't ask questions and guess all the accounts automatically. Use with --learn-from or --account-tokens options.") do |n|
           options[:unattended] = n
         end
 
-        opts.on("-t", "--account-tokens FILE", "YAML file with manually-assigned tokens for each account (see README)") do |a|
+        opts.on("-t", "--account-tokens FILE",
+                "YAML file with manually-assigned tokens for each account (see README)") do |a|
           options[:account_tokens_file] = a
         end
 
@@ -103,7 +126,8 @@ module Reckon
           options[:default_outof_account] = a
         end
 
-        opts.on("", "--fail-on-unknown-account", "Fail on unmatched transactions.") do |n|
+        opts.on("", "--fail-on-unknown-account",
+                "Fail on unmatched transactions.") do |n|
           options[:fail_on_unknown_account] = n
         end
 
@@ -111,6 +135,11 @@ module Reckon
           options[:suffixed] = e
         end
 
+        opts.on("", "--ledger-format FORMAT",
+                "Output/Learn format: BEANCOUNT or LEDGER. Default: LEDGER") do |n|
+          options[:format] = n
+        end
+
         opts.on_tail("-h", "--help", "Show this message") do
           puts opts
           exit
@@ -133,7 +162,7 @@ module Reckon
       end
 
       unless options[:file]
-        options[:file] = @@cli.ask("What CSV file should I parse? ")
+        options[:file] = cli.ask("What CSV file should I parse? ")
         unless options[:file].empty?
           puts "\nYou must provide a CSV file to parse.\n"
           puts parser
@@ -144,7 +173,7 @@ module Reckon
       unless options[:bank_account]
         raise "Must specify --account in unattended mode" if options[:unattended]
 
-        options[:bank_account] = @@cli.ask("What is this account named in Ledger?\n") do |q|
+        options[:bank_account] = cli.ask("What is this account named in Ledger?\n") do |q|
           q.readline = true
           q.validate = /^.{2,}$/
           q.default = "Assets:Bank:Checking"

data/lib/reckon/version.rb

@@ -1,3 +1,3 @@
 module Reckon
-  VERSION="0.8.1"
+  VERSION = "0.9.1"
 end

data/lib/reckon.rb

@@ -15,6 +15,7 @@ require_relative 'reckon/cosine_similarity'
 require_relative 'reckon/date_column'
 require_relative 'reckon/money'
 require_relative 'reckon/ledger_parser'
+require_relative 'reckon/beancount_parser'
 require_relative 'reckon/csv_parser'
 require_relative 'reckon/options'
 require_relative 'reckon/app'

data/spec/cosine_training_and_test.rb

@@ -8,7 +8,7 @@ ledger_file = ARGV[0]
 account = ARGV[1]
 seed = ARGV[2] ? ARGV[2].to_i : Random.new_seed
 
-ledger = Reckon::LedgerParser.new(File.read(ledger_file))
+ledger = Reckon::LedgerParser.new(File.new(ledger_file))
 matcher = Reckon::CosineSimilarity.new({})
 
 train = []

data/spec/data_fixtures/multi-line-field.csv

@@ -0,0 +1,5 @@
+,311053760,2002-09-10T23:00:04,Merchant Transaction,Complete,,,"Lyft, Inc",- $21.59,,,,,,Venmo balance,,,,,Venmo,,
+,,,,,,,,,,,,,,,,,$23.40,$0.00,,$0.00,"In case of errors or questions about your
+        electronic transfers:
+        This is a multi-line string
+        "

data/spec/integration/ask_for_account/cli_input.txt

@@ -0,0 +1 @@
+Test::Bank

data/spec/integration/invalid_header_example/output.ledger

@@ -1,8 +1,7 @@
-4016-02-18	
-	Assets:Bank:Checking			 $10.00
-	Income:Unknown			
-
-4016-02-19	
-	Income:Unknown			
-	Assets:Bank:Checking			 $0.00
+2016-02-18	COTISATION JAZZ; COTISATION JAZZ; EUR
+	Expenses:Unknown
+	Assets:Bank:Checking			-$8.10
 
+2016-02-19	VIR RECU 508160; VIR RECU 1234567834S DE: Francois REF: 123457891234567894561231 PROVENANCE: DE Allemagne; EUR
+	Assets:Bank:Checking			 $50.00
+	Expenses:Unknown

data/spec/integration/invalid_header_example/test_args

@@ -1 +1 @@
--f input.csv --unattended --account Assets:Bank:Checking --contains-header 4
+-f input.csv --unattended --account Assets:Bank:Checking --contains-header 4 --comma-separates-cents --verbose

data/spec/integration/tab_delimited_file/input.csv

@@ -0,0 +1,2 @@
+123456789	EUR	20160102	15,00	10,00	20160102	-5,00	DESCRIPTION
+123456789	EUR	20160102	10,00	0,00	20160102	-10,00	DESCRIPTION

data/spec/integration/tab_delimited_file/output.ledger

@@ -0,0 +1,8 @@
+2016-01-02	123456789; EUR; 20160102; DESCRIPTION
+	Expenses:Unknown			
+	Test::Account			-€5.00
+
+2016-01-02	123456789; EUR; 20160102; DESCRIPTION
+	Expenses:Unknown			
+	Test::Account			-€10.00
+

data/spec/integration/tab_delimited_file/test_args

@@ -0,0 +1 @@
+-f input.csv --unattended -c € --ignore-columns 4,5 --comma-separates-cents -v --date-format '%Y%m%d' --csv-separator '\t' -a Test::Account