ledger-rest 2.0.0

data/lib/ledger-rest/ledger/balance.rb

@@ -0,0 +1,44 @@
+module LedgerRest
+  class Ledger
+    class Balance
+
+      FORMAT = [
+                '{',
+                '  "total": %(quoted(display_total)),',
+                '  "name": %(quoted(partial_account)),',
+                '  "depth": %(depth), "fullname": %(quoted(account))',
+                '},%/',
+                '{ "total": %(quoted(display_total)) }'
+               ].join('\\n')
+
+      class << self
+
+        def get query = nil, params = {}
+          JSON.parse(json(query, params), :symbolize_names => true)
+        end
+
+        def json query = nil, params = {}
+          params = { '--format' => FORMAT }.merge(params)
+          result = Ledger.exec("bal #{query}", params)
+
+          total = nil
+          if result.end_with?(',')
+            result = result[0..-2]
+          else
+            match_total = result.match(/,\n.*?{ +"total": +("[0-9\.A-Za-z ]+") +}\z/)
+            if match_total
+              total = match_total[1]
+              result = result[0,match_total.offset(0)[0]]
+            end
+          end
+
+          json_str = "{"
+          json_str << " \"accounts\": [ #{result} ]"
+          json_str << ", \"total\": #{total}" if total
+          json_str << " }"
+        end
+
+      end
+    end
+  end
+end

data/lib/ledger-rest/ledger/budget.rb

@@ -0,0 +1,33 @@
+module LedgerRest
+  class Ledger
+    class Budget
+      FORMAT = [
+                '{',
+                '        "name": %(quoted(account)),',
+                '        "amount": %(quoted(get_at(T, 0))),',
+                '        "budget": %(quoted(-get_at(T, 1)))',
+                '      },%/',
+                '    ],',
+                '    "total_amount": %(quoted(get_at(T, 0))),',
+                '    "total_budget": %(quoted(-get_at(T, 1)))'
+               ].join('\\n')
+
+      class << self
+
+        def get(query = nil, params = {})
+          JSON.parse(json(query, params), :symbolize_names => true)
+        end
+
+        def json(query = nil, params = {})
+          params = { '--format' => FORMAT }.merge(params)
+          result = Ledger.exec("budget #{query}", params)
+          result.gsub!(/\},\n *?\]/, "}\n  ]")
+
+          "{\n  \"budget\": {\n    \"accounts\": [\n      #{result}\n  }\n}"
+        end
+
+      end
+
+    end
+  end
+end

data/lib/ledger-rest/ledger/entry.rb

@@ -0,0 +1,27 @@
+module LedgerRest
+  class Ledger
+
+    # Ledger offers a simple command to create a new entry based on
+    # previous entries in your ledger files. This class abstracts
+    # mentioned functionality for easy integration into ledger-rest.
+    class Entry
+
+      class << self
+
+        # Return a new transaction object based on previous transactions.
+        def get(desc, options = {})
+          result = Ledger.exec("entry #{desc}", options)
+          Transaction.parse(result)
+        end
+
+        # Appends a new transaction
+        def append(desc, options = {})
+          transaction = get(desc, options)
+          transaction.append_to(Ledger.append_file)
+          transaction
+        end
+
+      end
+    end
+  end
+end

data/lib/ledger-rest/ledger/parser.rb

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+module LedgerRest
+  class Ledger
+
+    # A very simple parser for single legder format transactions.
+    # There has to be a better way ... This does not implement the
+    # whole ledger format. Tragically ... someone told me it´s the
+    # essence of evil to do parser duplication. We need to use the
+    # ledger parser. Maybe we can use the ledger code base and
+    # integrate it into a ruby gem ... I don´t know.
+    #
+    # This works for `ledger entry` with my transactions ...
+    class Parser
+
+      class << self
+
+        def parse(str)
+          parser = Parser.new
+          parser.parse(str)
+        end
+
+      end
+
+      def initialize
+        @transaction = Transaction.new
+      end
+
+      # Begins to parse a whole
+      def parse(str)
+        @str = str
+        @transaction[:postings] = []
+
+        @transaction[:date],str = parse_date(str)
+
+        effective_date, str = parse_effective_date(str)
+        @transaction[:effective_date] = effective_date if effective_date
+
+        @transaction[:cleared],str = parse_cleared(str)
+        @transaction[:pending],str = parse_pending(str)
+
+        code, str = parse_code(str)
+        @transaction[:code] = code if code
+
+        @transaction[:payee],str = parse_payee(str)
+
+        comments,str = parse_comments(str)
+        @transaction[:comments] = comments if comments
+
+        str.split("\n").each do |line|
+          posting = parse_posting(line)
+          @transaction[:postings] << posting
+        end
+
+        @transaction
+      rescue Exception => e
+        puts e
+        puts "In: \n#{@str}"
+      end
+
+      def parse_date(str)
+        if match = str.match(/\A(\d{4}\/\d{1,2}\/\d{1,2})(.*)/m)
+          [ match[1], match[2] ]
+        else
+          raise "Date was expected."
+        end
+      end
+
+      def parse_effective_date(str)
+        if match = str.match(/\A=(\d{4}\/\d{1,2}\/\d{1,2})(.*)/m)
+          [ match[1], match[2] ]
+        else
+          [ nil, str ]
+        end
+      end
+
+      def parse_pending(str)
+        if match = str.match(/\A ! (.*)/m)
+          [ true, match[1] ]
+        else
+          [ false, str]
+        end
+      end
+
+      def parse_cleared(str)
+        if match = str.match(/\A \* (.*)/m)
+          [ true, match[1] ]
+        else
+          [ false, str]
+        end
+      end
+
+      def parse_code(str)
+        if match = str.match(/\A *?\(([^\(\)]+)\) (.*)/m)
+          [ match[1], match[2] ]
+        else
+          [ nil, str ]
+        end
+      end
+
+      def parse_payee(str)
+        if match = str.match(/\A *?([^ ][^\n]+)\n(.*)/m)
+          [ match[1], match[2] ]
+        else
+          raise "No payee given."
+        end
+      end
+
+      def parse_comments(str)
+        comments = ""
+        while str && match = str.match(/\A +;(.*?)(\n|$)(.*)/m)
+          comments << match[1].strip << "\n"
+          str = match[3]
+        end
+        [ comments.empty? ? nil : comments, str ]
+      end
+
+      # parses a ledger posting line
+      def parse_posting(str)
+        posting = {}
+
+        account, virtual, balanced, str = parse_account(str)
+        posting[:account] = account if account
+        posting[:virtual] = virtual if virtual
+        posting[:balanced] = balanced if balanced
+
+        amount, posting_cost, per_unit_cost, str = parse_amount(str)
+        posting[:amount] = amount if amount
+        posting[:posting_cost] = posting_cost if posting_cost
+        posting[:per_unit_cost] = per_unit_cost if per_unit_cost
+
+        comment, actual_date, effective_date = parse_posting_comment(str)
+        posting[:comment] = comment if comment
+        posting[:actual_date] = actual_date if actual_date
+        posting[:effective_date] = effective_date if effective_date
+
+        posting
+      end
+
+      def parse_account(str)
+        return [] if str.nil? or str.empty?
+        if match = str.match(/\A +([\w:]+)(\n|$|  )(.*)/m)
+          [ match[1], false, false , match[3] ]
+        elsif match = str.match(/\A +\(([\w:]+)\)(\n|$|  )(.*)/m)
+          [ match[1], true, false , match[3] ]
+        elsif match = str.match(/\A +\[([\w:]+)\](\n|$|  )(.*)/m)
+          [ match[1], true, true , match[3] ]
+        else
+          [ nil, false, false, str ]
+        end
+      end
+
+      def parse_amount(str)
+        if match = str.match(/\A(.*?)@@([^;]*?)(;(.*)|\n(.*)|$(.*))/m)
+          amount = match[1].strip
+          [ amount.empty? ? nil : amount, nil, match[2].strip, match[3] ]
+        elsif match = str.match(/\A(.*?)@([^;]*)(;(.*)|\n(.*)|$(.*))/m)
+          amount = match[1].strip
+          [ amount.empty? ? nil : amount, match[2].strip, nil, match[3] ]
+        elsif match = str.match(/\A([^;]*?)(;(.*)|\n(.*)|$(.*))/m)
+          amount = match[1].strip
+          [ amount.empty? ? nil : amount, nil, nil, match[2] ]
+        end
+      end
+
+      def parse_posting_comment(str)
+        comment, actual_date, effective_date = nil, nil, nil
+
+        if match = str.match(/\A *?; \[(.*)\]/)
+          actual_date, effective_date = match[1].split('=')
+        elsif match = str.match(/\A *?; (.*)/)
+          comment = match[1]
+        end
+
+        [ comment, actual_date, effective_date ]
+      end
+    end
+  end
+end

data/lib/ledger-rest/ledger/register.rb

@@ -0,0 +1,39 @@
+module LedgerRest
+  class Ledger
+    class Register
+
+      FORMAT = [
+                "{",
+                '  "date": %(quoted(date)),',
+                '  "effective_date": %(effective_date ? quoted(effective_date) : "null"),',
+                '  "code": %(code ? quoted(code) : "null"),',
+                '  "cleared": %(cleared ? "true" : "false"),',
+                '  "pending": %(pending ? "true" : "false"),',
+                '  "payee": %(quoted(payee)),',
+                '  "postings":',
+                '    [',
+                '      { "account": %(quoted(display_account)), "amount": %(quoted(amount)) },%/',
+                '      { "account": %(quoted(display_account)), "amount": %(quoted(amount)) },%/',
+                '    ]',
+                '},'
+               ].join('\\n')
+
+      class << self
+
+        def get(query = nil, params = {})
+          JSON.parse(json(query, params), :symbolize_names => true)
+        end
+
+        def json(query = nil, params = {})
+          params = { '--format' => FORMAT }.merge(params)
+          result = Ledger.exec("reg #{query}", params)
+          result << "\n]\n}"
+          result.gsub! /\},\n *?\]/m, "}\n     \]"
+
+          "{\"transactions\":[#{result}]}"
+        end
+
+      end
+    end
+  end
+end

data/lib/ledger-rest/ledger/transaction.rb

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+module LedgerRest
+  class Ledger
+    class Transaction < Hash
+
+      class << self
+
+        # Parse a ledger transaction string into a `Transaction` object.
+        def parse(str)
+          LedgerRest::Ledger::Parser.parse(str)
+        end
+
+      end
+
+      def initialize(params = {})
+        self.merge!(params)
+      end
+
+      # Return true if the `Transaction#to_ledger` is a valid ledger string.
+      def valid?
+        result = IO.popen("#{settings.ledger_bin} -f - stats 2>&1", "r+") do |f|
+          f.write self.to_ledger
+          f.close_write
+          f.readlines
+        end
+
+        $?.success? and not result.empty?
+      end
+
+      def to_ledger
+        if self[:date].nil? or
+            self[:payee].nil? or
+            self[:postings].nil?
+          return nil
+        end
+
+        result = ""
+
+        result << self[:date]
+        result << "=#{self[:effective_date]}" if self[:effective_date]
+
+        if self[:cleared]
+          result << " *"
+        elsif self[:pending]
+          result << " !"
+        end
+
+        result << " (#{self[:code]})" if self[:code]
+        result << " #{self[:payee]}"
+        result << "\n"
+
+        self[:postings].each do |posting|
+          if posting[:comment]
+            result << "  ; #{posting[:comment]}\n"
+            next
+          end
+
+          next unless posting[:account]
+
+          if posting[:virtual]
+            if posting[:balance]
+              result << "  [#{posting[:account]}]"
+            else
+              result << "  (#{posting[:account]})"
+            end
+          else
+            result << "  #{posting[:account]}"
+          end
+
+          if posting[:amount].nil?
+            result << "\n"
+            next
+          end
+
+          result << "  #{posting[:amount]}"
+
+          if(posting[:per_unit_cost])
+            result << " @@ #{posting[:per_unit_cost]}"
+          elsif(posting[:posting_cost])
+            result << " @ #{posting[:posting_cost]}"
+          end
+
+          if posting[:actual_date] or posting[:effective_date]
+            result << "  ; ["
+            result << posting[:actual_date] if posting[:actual_date]
+            result << "=#{posting[:effective_date]}" if posting[:effective_date]
+            result << "]"
+          end
+
+          result << "\n"
+        end
+
+        result << "\n"
+
+        result
+      end
+    end
+  end
+end

data/lib/ledger-rest/version.rb

@@ -0,0 +1,3 @@
+module LedgerRest
+  VERSION = "2.0.0"
+end

data/spec/ledger-rest/ledger/parser_spec.rb

@@ -0,0 +1,364 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe LedgerRest::Ledger::Parser do
+  before :all do
+    @parser = LedgerRest::Ledger::Parser.new
+  end
+
+  context '#parse' do
+    subject {
+      LedgerRest::Ledger::Transaction.new(:date => "2012/03/01",
+                                          :effective_date => "2012/03/23",
+                                          :cleared => true,
+                                          :pending => false,
+                                          :code => "INV#23",
+                                          :payee => "me, myself and I",
+                                          :postings => [
+                                                        {
+                                                          :account => "Expenses:Imaginary",
+                                                          :amount => "€ 23",
+                                                          :per_unit_cost => "USD 2300",
+                                                          :actual_date => "2012/03/24",
+                                                          :effective_date => "2012/03/25"
+                                                        }, {
+                                                          :account => "Expenses:Magical",
+                                                          :amount => "€ 42",
+                                                          :posting_cost => "USD 23000000",
+                                                          :virtual => true
+                                                        }, {
+                                                          :account => "Assets:Mighty"
+                                                        }, {
+                                                          :comment => "This is a freeform comment"
+                                                        },
+                                                       ])
+    }
+
+    it 'should parse a to_ledger converted transaction into the same original hash' do
+      @parser.parse(subject.to_ledger).should == subject
+    end
+
+  end
+
+  context '#parse_date' do
+    before :all do
+      @ret = @parser.parse_date("2012/11/23 * Rest with\nAnd Stuff")
+    end
+
+    it 'should return the parsed date' do
+      @ret[0].should == '2012/11/23'
+    end
+
+    it 'should return the rest of the input' do
+      @ret[1].should == " * Rest with\nAnd Stuff"
+    end
+  end
+
+  context '#parse_effective_date' do
+    before :all do
+      @ret = @parser.parse_effective_date("=2012/11/24 * Rest with\nAnd Stuff")
+    end
+
+    it 'should return the parsed date' do
+      @ret[0].should == "2012/11/24"
+    end
+
+    it 'should return the rest of the input' do
+      @ret[1].should == " * Rest with\nAnd Stuff"
+    end
+  end
+
+  context '#parse_state' do
+    context 'given cleared transaction input' do
+      before :all do
+        @ret = @parser.parse_cleared(" * Rest with\nAnd Stuff")
+      end
+
+      it 'should return true' do
+        @ret[0].should == true
+      end
+
+      it 'should return the rest of the input' do
+        @ret[1].should == "Rest with\nAnd Stuff"
+      end
+    end
+
+    context 'unspecified transaction input' do
+      before :all do
+        @ret = @parser.parse_cleared("Rest with\nAnd Stuff")
+      end
+
+      it 'should return false' do
+        @ret[0].should == false
+      end
+
+      it 'should return the rest of the input' do
+        @ret[1].should == "Rest with\nAnd Stuff"
+      end
+    end
+  end
+
+  context '#parse_pending' do
+    context 'given pending transaction input' do
+      before :all do
+        @ret = @parser.parse_pending(" ! Rest with\nAnd Stuff")
+      end
+
+      it 'should return true' do
+        @ret[0].should == true
+      end
+
+      it 'should return the rest of the input' do
+        @ret[1].should == "Rest with\nAnd Stuff"
+      end
+    end
+
+    context 'unspecified transaction input' do
+      before :all do
+        @ret = @parser.parse_pending("Rest with\nAnd Stuff")
+      end
+
+      it 'should return false' do
+        @ret[0].should == false
+      end
+
+      it 'should return the rest of the input' do
+        @ret[1].should == "Rest with\nAnd Stuff"
+      end
+    end
+  end
+
+  context '#parse_code' do
+    context 'given a transaction with white-spaced code' do
+      subject { @parser.parse_code(" (#123) Rest with\nAnd Stuff") }
+
+      its(:first) { should == '#123' }
+      its(:last) { should == "Rest with\nAnd Stuff"}
+    end
+
+    context 'given a transaction with code' do
+      subject { @parser.parse_code("(#123) Rest with\nAnd Stuff") }
+
+      its(:first) { should == '#123' }
+      its(:last) { should == "Rest with\nAnd Stuff" }
+    end
+
+    context 'given a transaction without code' do
+      subject { @parser.parse_code("Rest with\nAnd Stuff") }
+
+      its(:first) { should == nil }
+      its(:last) { should == "Rest with\nAnd Stuff" }
+    end
+  end
+
+  context '#parse_payee' do
+    context 'given an unstripped line' do
+      subject { @parser.parse_payee("  Monsieur Le Payee\n  Some:Account  123EUR\n  Some:Other")}
+
+      its(:first) { should == "Monsieur Le Payee" }
+      its(:last) { should == "  Some:Account  123EUR\n  Some:Other"}
+    end
+
+    context 'given a stripped line' do
+      context 'given an unstripped line' do
+        subject { @parser.parse_payee("Monsieur Le Payee\n  Some:Account  123EUR\n  Some:Other")}
+
+        its(:first) { should == "Monsieur Le Payee" }
+        its(:last) { should == "  Some:Account  123EUR\n  Some:Other"}
+      end
+    end
+  end
+
+  context '#parse_comments' do
+    context 'given no comments' do
+      subject { @parser.parse_comments("  Assets:Some:Stuff  23EUR")}
+
+      it 'should return all comments' do
+        subject[0].should == nil
+      end
+
+      it 'should return the rest of the input' do
+        subject[1].should == "  Assets:Some:Stuff  23EUR"
+      end
+    end
+
+    context 'given one line of transaction comments' do
+      subject { @parser.parse_comments("  ; ABC\n  Assets:Some:Stuff  23EUR")}
+
+      it 'should return all comments' do
+        subject[0].should == "ABC\n"
+      end
+
+      it 'should return the rest of the input' do
+        subject[1].should == "  Assets:Some:Stuff  23EUR"
+      end
+    end
+
+    context 'given multiple lines of transaction comments' do
+      subject { @parser.parse_comments("  ; ABC\n  ;DEF\n  Assets:Some:Stuff  23EUR")}
+
+      it 'should return all comments' do
+        subject[0].should == "ABC\nDEF\n"
+      end
+
+      it 'should return the rest of the input' do
+        subject[1].should == "  Assets:Some:Stuff  23EUR"
+      end
+    end
+  end
+
+  context '#parse_account' do
+    context 'given normal' do
+      subject { @parser.parse_account("  Assets:Some:Nice  200EUR\n  Assets:Account")}
+
+      it 'should return the account' do
+        subject[0].should == "Assets:Some:Nice"
+      end
+
+      it 'should not be virtual' do
+        subject[1].should == false
+      end
+
+      it 'should not be balanced virtual' do
+        subject[2].should == false
+      end
+
+      it 'should return the rest of the input' do
+        subject[3].should == "200EUR\n  Assets:Account"
+      end
+    end
+
+    context 'given input without amount' do
+      subject { @parser.parse_account("  Assets:Some:Nice")}
+
+      it 'should return the account' do
+        subject[0].should == "Assets:Some:Nice"
+      end
+
+      it 'should not be virtual' do
+        subject[1].should == false
+      end
+
+      it 'should not be balanced virtual' do
+        subject[2].should == false
+      end
+
+      it 'should return the rest of the input' do
+        subject[3].should == ""
+      end
+    end
+
+    context 'given virtual' do
+      subject { @parser.parse_account("  (Assets:Some:Nice)  200EUR\n  Assets:Account")}
+
+      it 'should return the account' do
+        subject[0].should == "Assets:Some:Nice"
+      end
+
+      it 'should not be virtual' do
+        subject[1].should == true
+      end
+
+      it 'should not be balanced virtual' do
+        subject[2].should == false
+      end
+
+      it 'should return the rest of the input' do
+        subject[3].should == "200EUR\n  Assets:Account"
+      end
+    end
+
+    context 'given balanced virtual' do
+      subject { @parser.parse_account("  [Assets:Some:Nice]  200EUR\n  Assets:Account")}
+
+      it 'should return the account' do
+        subject[0].should == "Assets:Some:Nice"
+      end
+
+      it 'should not be virtual' do
+        subject[1].should == true
+      end
+
+      it 'should not be balanced virtual' do
+        subject[2].should == true
+      end
+
+      it 'should return the rest of the input' do
+        subject[3].should == "200EUR\n  Assets:Account"
+      end
+    end
+  end
+
+  context '#parse_amount' do
+    context 'given "23.00EUR"' do
+      subject { @parser.parse_amount("23.00EUR") }
+
+      it 'should return amount and commodity' do
+        subject[0].should == "23.00EUR"
+      end
+
+      it 'should return no posting_cost' do
+        subject[1].should == nil
+      end
+
+      it 'should return no per_unit_cost' do
+        subject[2].should == nil
+      end
+    end
+
+    context 'given "25 AAPL @ 10.00EUR"' do
+      subject { @parser.parse_amount("25 AAPL @ 10.00EUR") }
+
+      it 'should return amount and commodity' do
+        subject[0].should == "25 AAPL"
+      end
+
+      it 'should return correct posting_cost' do
+        subject[1].should == "10.00EUR"
+      end
+
+      it 'should return no per_unit_cost' do
+        subject[2].should == nil
+      end
+    end
+
+    context 'given "30Liters @@ 1.64EUR"' do
+      subject { @parser.parse_amount("30Liters @@ 1.64EUR") }
+
+      it 'should return amount and commodity' do
+        subject[0].should == "30Liters"
+      end
+
+      it 'should return no posting_cost' do
+        subject[1].should == nil
+      end
+
+      it 'should return correct per_unit_cost' do
+        subject[2].should == "1.64EUR"
+      end
+    end
+  end
+
+  context '#parse_posting' do
+    context 'given posting with comment' do
+      subject { @parser.parse_posting("  Assets:Test:Account  123EUR\n  ; Some comment") }
+
+      it 'should have parsed correctly' do
+        subject.should == {
+          :account => "Assets:Test:Account",
+          :amount => "123EUR"
+        }
+      end
+    end
+
+    context 'given source posting' do
+      subject { @parser.parse_posting("  Assets:Test:Account") }
+
+      it 'should have parsed correctly' do
+        subject.should == {
+          :account => "Assets:Test:Account"
+        }
+      end
+    end
+  end
+end