reckon 0.5.0 → 0.6.0

data/spec/reckon/date_column_spec.rb

@@ -20,23 +20,22 @@ describe Reckon::DateColumn do
   end
   describe "for" do
     it "should detect the date" do
-      Reckon::DateColumn.new( ["13/12/2013"] ).for( 0 ).should ==
-        Time.new( 2013, 12, 13, 12 )
-      Reckon::DateColumn.new( ["01/14/2013"] ).for( 0 ).should ==
-        Time.new( 2013, 01, 14, 12 )
-      Reckon::DateColumn.new( ["13/12/2013", "21/11/2013"] ).for( 1 ).should ==
-        Time.new( 2013, 11, 21, 12 )
-      Reckon::DateColumn.new( ["2013-11-21"] ).for( 0 ).should ==
-        Time.new( 2013, 11, 21, 12 )
+      expect(Reckon::DateColumn.new(%w[13/12/2013]).for(0))
+        .to eq(Date.new(2013, 12, 13))
+      expect(Reckon::DateColumn.new(%w[01/14/2013]).for(0))
+        .to eq(Date.new(2013, 1, 14))
+      expect(Reckon::DateColumn.new(%w[13/12/2013 21/11/2013]).for(1))
+        .to eq(Date.new(2013, 11, 21))
+      expect(Reckon::DateColumn.new( ["2013-11-21"] ).for( 0 ))
+        .to eq(Date.new(2013, 11, 21))
 
     end
 
     it "should correctly use endian_precedence" do
-      Reckon::DateColumn.new( ["01/02/2013", "01/14/2013"] ).for(0).should ==
-        Time.new( 2013, 01, 02, 12 )
-      Reckon::DateColumn.new( ["01/02/2013", "14/01/2013"] ).for(0).should ==
-        Time.new( 2013, 02, 01, 12 )
+      expect(Reckon::DateColumn.new(%w[01/02/2013 01/14/2013]).for(0))
+        .to eq(Date.new(2013, 1, 2))
+      expect(Reckon::DateColumn.new(%w[01/02/2013 14/01/2013]).for(0))
+        .to eq(Date.new(2013, 2, 1))
     end
   end
 end
-

data/spec/reckon/ledger_parser_spec.rb

@@ -20,14 +20,16 @@ describe Reckon::LedgerParser do
       formats = ["%Y/%m/%d", "%Y-%m-%d"]
       types = [' ! ', ' * ', ' ']
       delimiters = ["  ", "\t", "\t\t"]
+      comment_chars = ';#%*|'
       currency_delimiters = delimiters + ['']
       currencies = ['', '$', '£']
       property_of do
         Rantly do
           description = Proc.new do
-            sized(15){string}.tr(%q{'`:*\\},'').gsub(/\s+/, ' ').gsub(/^[!;<\[( ]+/, '')
+            sized(15){string}.tr(%q{'`:*\\},'').gsub(/\s+/, ' ').gsub(/^[!;<\[( #{comment_chars}]+/, '')
           end
           currency = choose(*currencies) # to be consistent within the transaction
+          single_line_comments = ";#|%*".split('').map { |n| "#{n} #{call(description)}" }
           comments = ['', ';   ', "\t;#{call(description)}", "  ; #{call(description)}"]
           date = Time.at(range(0, 1_581_389_644)).strftime(choose(*formats))
           codes = [' ', " (#{string(:alnum).tr('()', '')}) "]
@@ -48,23 +50,58 @@ describe Reckon::LedgerParser do
             ledger += "#{call(account_line)}\n"
           end
           ledger += "#{call(account)}\n"
+          ledger += choose(*single_line_comments) + "\n"
           ledger
         end
       end.check(1000) do |s|
         filter_format = lambda { |n| [n['date'], n['desc'], n['name'], sprintf("%.02f", n['amount'])] }
         headers = %w[date code desc name currency amount type commend]
         safe_s = Shellwords.escape(s)
-        ledger_csv = `echo #{safe_s} | ledger csv --date-format '%Y-%m-%d' -f - `
-        ledger_parser_csv = Reckon::LedgerParser.new(s, date_format: '%Y/%m/%d').to_csv.join("\n")
 
-        expected = CSV.parse(ledger_csv.gsub('\"', '""'), headers: headers).map &filter_format
-        actual = CSV.parse(ledger_parser_csv, headers: headers).map &filter_format
+        lp_csv = Reckon::LedgerParser.new(s, date_format: '%Y/%m/%d').to_csv.join("\n")
+        actual = CSV.parse(lp_csv, headers: headers).map(&filter_format)
+
+        ledger_csv = `echo #{safe_s} | ledger csv --date-format '%Y/%m/%d' -f - `
+        expected = CSV.parse(ledger_csv.gsub('\"', '""'), headers: headers).map(&filter_format)
         expected.length.times do |i|
           expect(actual[i]).to eq(expected[i])
         end
       end
     end
 
+    it 'should filter block comments' do
+      ledger = <<HERE
+1970/11/01 Dinner should show up
+  Assets:Checking  -123.00
+  Expenses:Restaurants
+
+comment
+
+1970/11/01 Lunch should NOT show up
+  Assets:Checking  -12.00
+  Expenses:Restaurants
+
+end comment
+HERE
+      l = Reckon::LedgerParser.new(ledger)
+      expect(l.entries.length).to eq(1)
+      expect(l.entries.first[:desc]).to eq('Dinner should show up')
+
+    end
+
+    it 'should transaction comments' do
+      ledger = <<HERE
+2020-03-27      AMZN Mktp USX999H3203; Shopping; Sale
+    Expenses:Household                                      $82.77
+    Liabilities:ChaseSapphire                                       -$81.77
+    # END FINANCE SCRIPT OUTPUT Thu 02 Apr 2020 12:05:54 PM EDT
+HERE
+      l = Reckon::LedgerParser.new(ledger)
+      expect(l.entries.first[:accounts].map { |n| n[:name] }).to eq(['Expenses:Household', 'Liabilities:ChaseSapphire'])
+      expect(l.entries.first[:accounts].size).to eq(2)
+      expect(l.entries.length).to eq(1)
+    end
+
     it "should ignore non-standard entries" do
       @ledger.entries.length.should == 7
     end

data/spec/reckon/money_spec.rb

@@ -8,79 +8,92 @@ require 'reckon'
 describe Reckon::Money do
   describe "from_s" do
     it "should handle currency indicators" do
-      Reckon::Money::from_s( "$2.00" ).should == 2.00
-      Reckon::Money::from_s( "-$1025.67" ).should == -1025.67 
-      Reckon::Money::from_s( "$-1025.67" ).should == -1025.67 
+      expect(Reckon::Money::from_s( "$2.00" )).to eq(2.00)
+      expect(Reckon::Money::from_s("-$1025.67")).to eq(-1025.67)
+      expect(Reckon::Money::from_s("$-1025.67")).to eq(-1025.67)
     end
 
     it "should handle the comma_separates_cents option correctly" do
-      Reckon::Money::from_s( "$2,00", :comma_separates_cents => true ).should == 2.00
-      Reckon::Money::from_s( "-$1025,67", :comma_separates_cents => true ).should == -1025.67 
-      Reckon::Money::from_s( "$-1025,67", :comma_separates_cents => true ).should == -1025.67 
+      expect(Reckon::Money::from_s("$2,00", :comma_separates_cents => true)).to eq(2.00)
+      expect(Reckon::Money::from_s("-$1025,67", :comma_separates_cents => true )).to eq(-1025.67)
+      expect(Reckon::Money::from_s("$-1025,67", :comma_separates_cents => true )).to eq(-1025.67)
     end
 
     it "should return 0 for an empty string" do
-      Reckon::Money::from_s( "" ).should == 0
+      expect(Reckon::Money::from_s("")).to eq(0)
     end
 
     it "should handle 1000 indicators correctly" do
-      Reckon::Money::from_s( "$2.000,00", :comma_separates_cents => true ).should == 2000.00
-      Reckon::Money::from_s( "-$1,025.67" ).should == -1025.67 
+      expect(Reckon::Money::from_s("$2.000,00", :comma_separates_cents => true)).to eq(2000.00)
+      expect(Reckon::Money::from_s("-$1,025.67")).to eq(-1025.67)
     end
 
     it "should keep numbers together" do
-      Reckon::Money::from_s( "1A1" ).should == 1
+      expect(Reckon::Money::from_s("1A1")).to eq(1)
     end
 
     it "should prefer numbers with precision of two" do
-      Reckon::Money::from_s( "1A2.00" ).should == 2
-      Reckon::Money::from_s( "2.00A1" ).should == 2
+      expect(Reckon::Money::from_s("1A2.00")).to eq(2)
+      expect(Reckon::Money::from_s("2.00A1")).to eq(2)
     end
 
     it "should handle arbitrary prefixes and postfixes" do
-      Reckon::Money::from_s( "AB1.00C" ).should == 1
-      Reckon::Money::from_s( "AB0C" ).should == 0
-      Reckon::Money::from_s( "AB-2.00C" ).should == -2
+      expect(Reckon::Money::from_s("AB1.00C")).to eq(1)
+      expect(Reckon::Money::from_s("AB0C")).to eq(0)
+      expect(Reckon::Money::from_s("AB-2.00C")).to eq(-2)
     end
 
     it "should return nil if no numbers are found" do
-      Reckon::Money::from_s( "BAC" ).should == nil
+      expect(Reckon::Money::from_s("BAC")).to be_nil()
     end
   end
 
   describe "pretty" do
     it "work with negative and positive numbers" do
-      Reckon::Money.new( -20.00 ).pretty.should == "-$20.00"
-      Reckon::Money.new( 1558.52 ).pretty.should == " $1558.52"
+      expect(Reckon::Money.new(-20.00).pretty).to eq("-$20.00")
+      expect(Reckon::Money.new(1558.52).pretty).to eq(" $1558.52")
     end
 
     it "work with other currencies such as €" do
-      Reckon::Money.new( -20.00, :currency => "€", :suffixed => false ).pretty.should == "-€20.00"
-      Reckon::Money.new( 1558.52, :currency => "€", :suffixed => false ).pretty.should == " €1558.52"
+      expect(Reckon::Money.new(-20.00, currency: "€", suffixed: false).pretty).to eq("-€20.00")
+      expect(Reckon::Money.new(1558.52, currency: "€", suffixed: false).pretty).to eq(" €1558.52")
     end
 
     it "work with suffixed currencies such as SEK" do
-      Reckon::Money.new( -20.00, :currency => "SEK", :suffixed => true ).pretty.should == "-20.00 SEK"
-      Reckon::Money.new( 1558.52, :currency => "SEK", :suffixed => true ).pretty.should == " 1558.52 SEK"
+      expect(Reckon::Money.new( -20.00, :currency => "SEK", :suffixed => true ).pretty).to eq("-20.00 SEK")
+      expect(Reckon::Money.new( 1558.52, :currency => "SEK", :suffixed => true ).pretty).to eq(" 1558.52 SEK")
     end
   end
 
   describe "likelihood" do
     it "should return the likelihood that a string represents money" do
-      Reckon::Money::likelihood( "$20.00" ).should == 45
+      expect(Reckon::Money::likelihood( "$20.00" )).to eq(65)
+    end
+
+    it "should return neutral for empty string" do
+      expect(Reckon::Money::likelihood("")).to eq(0)
+    end
+
+    it "should recognize non-us currencies" do
+      expect(Reckon::Money::likelihood("£480.00")).to eq(30)
+      expect(Reckon::Money::likelihood("£1.480,00")).to eq(30)
+    end
+
+    it 'should not identify date columns as money' do
+      expect(Reckon::Money::likelihood("22.01.2014")).to eq(0)
     end
   end
 
   describe "equality" do
     it "should be comparable to other money" do
-      Reckon::Money.new( 2.0 ).should == Reckon::Money.new( 2.0 )
-      Reckon::Money.new( 1.0 ).should <= Reckon::Money.new( 2.0 )
-      Reckon::Money.new( 3.0 ).should > Reckon::Money.new( 2.0 )
+      expect(Reckon::Money.new(2.0)).to eq(Reckon::Money.new(2.0))
+      expect(Reckon::Money.new(1.0)).to be <= Reckon::Money.new(2.0)
+      expect(Reckon::Money.new(3.0)).to be > Reckon::Money.new(2.0)
     end
     it "should be comparable to other float" do
-      Reckon::Money.new( 2.0 ).should == 2.0
-      Reckon::Money.new( 1.0 ).should <= 2.0
-      Reckon::Money.new( 3.0 ).should > 2.0
+      expect(Reckon::Money.new(2.0)).to eq(2.0)
+      expect(Reckon::Money.new(1.0)).to be <= 2.0
+      expect(Reckon::Money.new(3.0)).to be > 2.0
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,7 +3,26 @@ require 'rspec'
 require 'reckon'
 
 RSpec.configure do |config|
+  config.before(:all, &:silence_output)
+  config.after(:all,  &:enable_output)
   def fixture_path(file)
     File.expand_path(File.join(File.dirname(__FILE__), "data_fixtures", file))
   end
 end
+
+public
+
+# Redirects stderr and stout to /dev/null.txt
+def silence_output
+  # Store the original stderr and stdout in order to restore them later
+  @original_stdout = $stdout
+
+  # Redirect stderr and stdout
+  $stdout = File.new(File.join(File.dirname(__FILE__), 'test_log.txt'), 'w')
+end
+
+# Replace stderr and stdout so anything else is output correctly
+def enable_output
+  $stdout = @original_stdout
+  @original_stdout = nil
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reckon
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Andrew Cantino
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-19 00:00:00.000000000 Z
+date: 2020-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -82,20 +82,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.2
-- !ruby/object:Gem::Dependency
-  name: terminal-table
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.4.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.4.2
 - !ruby/object:Gem::Dependency
   name: rchardet
   requirement: !ruby/object:Gem::Requirement
@@ -135,12 +121,18 @@ files:
 - lib/reckon/app.rb
 - lib/reckon/cosine_similarity.rb
 - lib/reckon/csv_parser.rb
+- lib/reckon/date_column.rb
 - lib/reckon/ledger_parser.rb
+- lib/reckon/logger.rb
 - lib/reckon/money.rb
+- lib/reckon/version.rb
 - reckon.gemspec
+- spec/data_fixtures/51-sample.csv
+- spec/data_fixtures/51-tokens.yml
 - spec/data_fixtures/73-sample.csv
 - spec/data_fixtures/73-tokens.yml
 - spec/data_fixtures/73-transactions.ledger
+- spec/data_fixtures/85-date-example.csv
 - spec/data_fixtures/austrian_example.csv
 - spec/data_fixtures/bom_utf8_file.csv
 - spec/data_fixtures/broker_canada_example.csv
@@ -160,6 +152,7 @@ files:
 - spec/data_fixtures/some_other.csv
 - spec/data_fixtures/spanish_date_example.csv
 - spec/data_fixtures/suntrust.csv
+- spec/data_fixtures/test_money_column.csv
 - spec/data_fixtures/tokens.yaml
 - spec/data_fixtures/two_money_columns.csv
 - spec/data_fixtures/yyyymmdd_date_example.csv
@@ -172,7 +165,8 @@ files:
 - spec/spec.opts
 - spec/spec_helper.rb
 homepage: https://github.com/cantino/reckon
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -189,8 +183,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Utility for interactively converting and labeling CSV files for the Ledger