ledger-rest 2.0.3 → 3.0.0

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

@@ -1,23 +1,29 @@
+# -*- coding: utf-8 -*-
 module LedgerRest
   class Ledger
     class Balance
-
       FORMAT = [
                 '{',
-                '  "total": %(quoted(display_total)),',
-                '  "name": %(quoted(partial_account)),',
-                '  "depth": %(depth), "fullname": %(quoted(account))',
+                '"total":%(quoted(display_total)),',
+                '"name":%(quoted(partial_account)),',
+                '"depth":%(depth), "fullname": %(quoted(account))',
                 '},%/',
-                '{ "total": %(quoted(display_total)) }'
-               ].join('\\n')
+                '{"total":%(quoted(display_total))}'
+               ].join
 
       class << self
+        def get(query = nil, params = {})
+          data = JSON.parse(json(query, params), symbolize_names: true)
+
+          data[:accounts] = expand_accounts(data[:accounts])
+          unless query =~ /--flat/
+            data[:accounts] = wrap_accounts(data[:accounts])
+          end
 
-        def get query = nil, params = {}
-          JSON.parse(json(query, params), :symbolize_names => true)
+          data
         end
 
-        def json query = nil, params = {}
+        def json(query = nil, params = {})
           params = { '--format' => FORMAT }.merge(params)
           result = Ledger.exec("bal #{query}", params)
 
@@ -25,19 +31,46 @@ module LedgerRest
           if result.end_with?(',')
             result = result[0..-2]
           else
-            match_total = result.match(/,\n.*?{ +"total": +("[0-9\.A-Za-z ]+") +}\z/)
+            match_total = result.match(/,{"total":("[0-9\.A-Za-z ]+")}\z/)
             if match_total
               total = match_total[1]
-              result = result[0,match_total.offset(0)[0]]
+              result = result[0, match_total.offset(0)[0]]
             end
           end
 
-          json_str = "{"
-          json_str << " \"accounts\": [ #{result} ]"
-          json_str << ", \"total\": #{total}" if total
-          json_str << " }"
+          json_str = '{'
+          json_str << "\"accounts\":[#{result}]"
+          json_str << ",\"total\":#{total}" if total
+          json_str << '}'
+        end
+
+        def expand_accounts(accounts)
+          accounts.inject([]) do |acc, elem|
+            fullname = elem[:fullname].gsub(/:?#{elem[:name]}/, '')
+            acc + elem[:name].split(':').map do |name|
+              fullname << "#{':' unless fullname.empty?}#{name}"
+              parent = elem.dup
+              parent[:fullname], parent[:name], parent[:depth] =
+                fullname.dup, name.dup, fullname.count(':')+1
+              parent
+            end
+          end
         end
 
+        def wrap_accounts(accounts)
+          stack = []
+          accounts.inject([]) do |acc, elem|
+            stack.pop while stack.last && stack.last[:depth] >= elem[:depth]
+            if stack.empty?
+              stack << elem
+              acc << elem
+            else
+              (stack.last[:accounts] ||= []) << elem
+              stack << elem
+            end
+            acc
+          end
+        end
       end
     end
   end

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

@@ -1,33 +1,52 @@
+# -*- coding: utf-8 -*-
 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')
+                '%(scrub(get_at(display_total, 0)))\n',
+                '%(-scrub(get_at(display_total, 1)))\n',
+                '%(scrub(get_at(display_total, 1) + get_at(display_total, 0)))\n',
+                '%(get_at(display_total, 1) ? (100% * scrub(get_at(display_total, 0))) / -scrub(get_at(display_total, 1)) : 0)\n',
+                '%(account)\n',
+                '---\n',
+                '%/---\n',
+                '%$1\n',
+                '%$2\n',
+                '%$3\n',
+                '%$4\n',
+                '%/'
+               ].join
 
       class << self
-
         def get(query = nil, params = {})
-          JSON.parse(json(query, params), :symbolize_names => true)
+          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}"
+          budget = {}
+          accounts, total = result.split("---\n---\n")
+          budget['accounts'] = accounts.split("---\n").map do |str|
+            val = str.split("\n")
+            {
+              'total'      => val[0].empty? ? '0' : val[0],
+              'budget'     => val[1].empty? ? '0' : val[1],
+              'difference' => val[2].empty? ? '0' : val[2],
+              'percentage' => val[3].empty? ? '0' : val[3],
+              'account'    => val[4].empty? ? '0' : val[4]
+            }
+          end
+          if total
+            val = total.split("\n")
+            budget['total']      = val[0].empty? ? '0' : val[0]
+            budget['budget']     = val[1].empty? ? '0' : val[1]
+            budget['difference'] = val[2].empty? ? '0' : val[2]
+            budget['percentage'] = val[3].empty? ? '0' : val[3]
+          end
+          budget.to_json
         end
-
       end
-
     end
   end
 end

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

@@ -1,13 +1,11 @@
+# -*- coding: utf-8 -*-
 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)
@@ -20,7 +18,6 @@ module LedgerRest
           transaction.append_to(Ledger.append_file)
           transaction
         end
-
       end
     end
   end

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

@@ -1,7 +1,6 @@
 # -*- 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
@@ -11,14 +10,11 @@ module LedgerRest
     #
     # 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
@@ -30,20 +26,20 @@ module LedgerRest
         @str = str
         @transaction[:postings] = []
 
-        @transaction[:date],str = parse_date(str)
+        @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)
+        @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)
+        @transaction[:payee], str = parse_payee(str)
 
-        comments,str = parse_comments(str)
+        comments, str = parse_comments(str)
         @transaction[:comments] = comments if comments
 
         str.split("\n").each do |line|
@@ -58,60 +54,60 @@ module LedgerRest
       end
 
       def parse_date(str)
-        if match = str.match(/\A(\d{4}\/\d{1,2}\/\d{1,2})(.*)/m)
-          [ match[1], match[2] ]
+        if match = str.match(%r{\A(\d{4}/\d{1,2}/\d{1,2})(.*)}m)
+          [match[1], match[2]]
         else
-          raise "Date was expected."
+          fail '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] ]
+        if match = str.match(%r{\A=(\d{4}/\d{1,2}/\d{1,2})(.*)}m)
+          [match[1], match[2]]
         else
-          [ nil, str ]
+          [nil, str]
         end
       end
 
       def parse_pending(str)
         if match = str.match(/\A ! (.*)/m)
-          [ true, match[1] ]
+          [true, match[1]]
         else
-          [ false, str]
+          [false, str]
         end
       end
 
       def parse_cleared(str)
         if match = str.match(/\A \* (.*)/m)
-          [ true, match[1] ]
+          [true, match[1]]
         else
-          [ false, str]
+          [false, str]
         end
       end
 
       def parse_code(str)
         if match = str.match(/\A *?\(([^\(\)]+)\) (.*)/m)
-          [ match[1], match[2] ]
+          [match[1], match[2]]
         else
-          [ nil, str ]
+          [nil, str]
         end
       end
 
       def parse_payee(str)
         if match = str.match(/\A *?([^ ][^\n]+)\n(.*)/m)
-          [ match[1], match[2] ]
+          [match[1], match[2]]
         else
-          raise "No payee given."
+          fail 'No payee given.'
         end
       end
 
       def parse_comments(str)
-        comments = ""
+        comments = ''
         while str && match = str.match(/\A +;(.*?)(\n|$)(.*)/m)
           comments << match[1].strip << "\n"
           str = match[3]
         end
-        [ comments.empty? ? nil : comments, str ]
+        [comments.empty? ? nil : comments, str]
       end
 
       # parses a ledger posting line
@@ -124,9 +120,9 @@ module LedgerRest
         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
+        posting[:amount], posting[:commodity] = parse_amount_parts(amount) if amount
+        posting[:posting_cost], posting[:posting_cost_commodity] = parse_amount_parts(posting_cost) if posting_cost
+        posting[:per_unit_cost], posting[:per_unit_commodity] = parse_amount_parts(per_unit_cost) if per_unit_cost
 
         comment, actual_date, effective_date = parse_posting_comment(str)
         posting[:comment] = comment if comment
@@ -137,28 +133,36 @@ module LedgerRest
       end
 
       def parse_account(str)
-        return [] if str.nil? or str.empty?
+        return [] if str.nil? || str.empty?
         if match = str.match(/\A +([\w:]+)(\n|$|  )(.*)/m)
-          [ match[1], false, false , match[3] ]
+          [match[1], false, false , match[3]]
         elsif match = str.match(/\A +\(([\w:]+)\)(\n|$|  )(.*)/m)
-          [ match[1], true, false , match[3] ]
+          [match[1], true, false , match[3]]
         elsif match = str.match(/\A +\[([\w:]+)\](\n|$|  )(.*)/m)
-          [ match[1], true, true , match[3] ]
+          [match[1], true, true , match[3]]
         else
-          [ nil, false, false, str ]
+          [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] ]
+          [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] ]
+          [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] ]
+          [amount.empty? ? nil : amount, nil, nil, match[2]]
+        end
+      end
+
+      def parse_amount_parts(str)
+        if match = str.match(/^(.*?)(\d+(\.\d+)?)(.*?)$/)
+          [match[2].to_f, match[1].strip + match[4].strip]
+        else
+          [str, nil]
         end
       end
 
@@ -171,7 +175,7 @@ module LedgerRest
           comment = match[1]
         end
 
-        [ comment, actual_date, effective_date ]
+        [comment, actual_date, effective_date]
       end
     end
   end

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

@@ -1,38 +1,45 @@
+# -*- coding: utf-8 -*-
 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 format(query)
+          format = '{'
+          if query =~ /-D|--daily|-W|--weekly|-M|--monthly|--quarterly|-Y|--yearly/
+            format << '"beginning": %(quoted(format_date(date))),'
+            format << '"end": %(quoted(payee)),'
+          elsif query =~ /--by-payee/
+            format << '"payee": %(quoted(payee)),'
+          else
+            format << '"date": %(quoted(format_date(date))),'
+            format << '"effective_date": %(effective_date ? quoted(format_date(effective_date)) : "null"),'
+            format << '"code": %(code ? quoted(code) : "null"),'
+            format << '"cleared": %(cleared ? "true" : "false"),'
+            format << '"pending": %(pending ? "true" : "false"),'
+            format << '"payee": %(quoted(payee)),'
+          end
+          format << '"postings": ['
+          format << '{ "account": %(quoted(display_account)), "amount": %(quoted(quantity(scrub(display_amount)))), "total": %(quoted(quantity(scrub(display_amount)))), "commodity": %(quoted(commodity)) },%/'
+          format << '{ "account": %(quoted(display_account)), "amount": %(quoted(quantity(scrub(display_amount)))), "total": %(quoted(quantity(scrub(display_amount)))), "commodity": %(quoted(commodity)) },%/'
+          format << ']},'
+          format
+        end
 
         def get(query = nil, params = {})
-          JSON.parse(json(query, params), :symbolize_names => true)
+          JSON.parse(json(query, params), symbolize_names: true)
         end
 
         def json(query = nil, params = {})
-          params = { '--format' => FORMAT }.merge(params)
+          params = {
+            '--format' => format(query),
+            '--date-format' => '%Y/%m/%d'
+          }.merge(params)
           result = Ledger.exec("reg #{query}", params)
-          result << "\n]\n}"
-          result.gsub! /\},\n *?\]/m, "}\n     \]"
-
-          "{\"transactions\":[#{result}]}"
+          result << "]}"
+          result.gsub! '"end": "- ', '"end": "'
+          result.gsub! /\},\n? *?\]/m, "}]"
+          "[#{result}]"
         end
-
       end
     end
   end

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

@@ -2,14 +2,11 @@
 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 = {})
@@ -18,31 +15,39 @@ module LedgerRest
 
       # 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
+        result = IO.popen("#{Ledger.bin} -f - stats 2>&1", 'r+') do |f|
+          f.write to_ledger
           f.close_write
           f.readlines
         end
 
-        $?.success? and not result.empty?
+        $?.success? && !result.empty?
+      end
+
+      def check
+        IO.popen("#{Ledger.bin} -f - stats 2>&1", 'r+') do |f|
+          f.write to_ledger
+          f.close_write
+          f.readlines
+        end
       end
 
       def to_ledger
-        if self[:date].nil? or
-            self[:payee].nil? or
-            self[:postings].nil?
+        if self[:date].nil? || self[:payee].nil? || self[:postings].nil?
           return nil
         end
 
-        result = ""
+        result = ''
 
         result << self[:date]
-        result << "=#{self[:effective_date]}" if self[:effective_date]
+        if self[:effective_date]
+          result << "=#{self[:effective_date]}"
+        end
 
         if self[:cleared]
-          result << " *"
+          result << ' *'
         elsif self[:pending]
-          result << " !"
+          result << ' !'
         end
 
         result << " (#{self[:code]})" if self[:code]
@@ -51,7 +56,7 @@ module LedgerRest
 
         self[:postings].each do |posting|
           if posting[:comment]
-            result << "  ; #{posting[:comment]}\n"
+            result << "    ; #{posting[:comment]}\n"
             next
           end
 
@@ -59,12 +64,12 @@ module LedgerRest
 
           if posting[:virtual]
             if posting[:balance]
-              result << "  [#{posting[:account]}]"
+              result << "    [#{posting[:account]}]"
             else
-              result << "  (#{posting[:account]})"
+              result << "    (#{posting[:account]})"
             end
           else
-            result << "  #{posting[:account]}"
+            result << "    #{posting[:account]}"
           end
 
           if posting[:amount].nil?
@@ -72,26 +77,26 @@ module LedgerRest
             next
           end
 
-          result << "  #{posting[:amount]}"
+          result << "  #{'%.2f' % posting[:amount]}#{posting[:commodity]}"
 
-          if(posting[:per_unit_cost])
-            result << " @@ #{posting[:per_unit_cost]}"
-          elsif(posting[:posting_cost])
-            result << " @ #{posting[:posting_cost]}"
+          if posting[:per_unit_cost]
+            result << " @@ #{'%.2f' % posting[:per_unit_cost]}#{posting[:per_unit_commodity]}"
+          elsif posting[:posting_cost]
+            result << " @ #{'%.2f' % posting[:posting_cost]}#{posting[:posting_cost_commodity]}"
           end
 
-          if posting[:actual_date] or posting[:effective_date]
-            result << "  ; ["
+          if posting[:actual_date] || posting[:effective_date]
+            result << '  ; ['
             result << posting[:actual_date] if posting[:actual_date]
-            result << "=#{posting[:effective_date]}" if posting[:effective_date]
-            result << "]"
+            if posting[:effective_date]
+              result << "=#{posting[:effective_date]}"
+            end
+            result << ']'
           end
 
           result << "\n"
         end
 
-        result << "\n"
-
         result
       end
     end