lucabook 0.2.26 → 0.2.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 933e3d04315c04b7f6e998b16499b458ceeeafe8bfae9ce4ef4422018eb17040
-  data.tar.gz: 2e243b4e85cdc50bd45e39ed311cf78a8aa12e1956be0d0273c2a634147be16c
+  metadata.gz: ad4b1eba3419508d64bfeade5f776ed2ca0f32313deab25660864aff47767787
+  data.tar.gz: 57aef956cbc763dbf4d089d5745c9cc4d6a6ed44dd3ff726b9c80fbc6b29629d
 SHA512:
-  metadata.gz: b2292a4972ce1fcf883a828d17479f1580e3145e0db2d26ff6044a73495d2e151d60f0bd98fd5b2f945c3b74cdff879f9f7779073487c05c70a078306b069bbe
-  data.tar.gz: 27bf6b4bcea1b2eb9d5dac761d5465ce478af02a4074f0a20038b7f8a21c528b66faf399d4364702ebf22f06cc0a0112d13a4ee2e10acb22eb16b52859aaf4b6
+  metadata.gz: 317b373f1a31c85c107dfa294ec6df0dcc89f13b8ab10277bb004b3bdceaaf0ec58cfa5c2220a088932965b5b156fd71fef1ce67be67c330857bbcea127de365
+  data.tar.gz: e7456d393a4309bafb9a3622c28da10067e1483c80b0bbbd73a05508bb3d9a6742051e2d190870a1f6e39df5ec10b5dd7d1de698faef969a3bc54efa7b46b153

data/exe/luca-book

@@ -24,7 +24,7 @@ class LucaCmd
         if params['headers']
           render(LucaBook::ListByHeader.term(*args, code: params['code'], header: params['headers']).list_by_code, params)
         else
-          render(LucaBook::List.term(*args, code: params['code']).list_by_code, params)
+          render(LucaBook::List.term(*args, code: params['code'], recursive: params[:recursive]).list_by_code(params[:recursive]), params)
         end
       else
         render(LucaBook::List.term(*args).list_journals, params)
@@ -34,7 +34,7 @@ class LucaCmd
     def self.stats(args, params)
       args = gen_range(params[:n]) if args.empty?
       if params['code']
-        render(LucaBook::State.by_code(params['code'], *args), params)
+        render(LucaBook::State.by_code(params['code'], *args, recursive: params[:recursive]), params)
       else
         render(LucaBook::State.range(*args).stats(params[:level]), params)
       end
@@ -124,9 +124,11 @@ when /journals?/, 'j'
       LucaCmd::Journal.import(args, params)
     end
   when 'list'
+    params[:recursive] = false
     OptionParser.new do |opt|
       opt.banner = 'Usage: luca-book journals list [options] [YYYY M]'
       opt.on('-c', '--code VAL', 'filter with code or label') { |v| params['code'] = v }
+      opt.on('-r', '--recursive', 'include subaccounts') { |_v| params[:recursive] = true }
       opt.on('--customer', 'categorize by x-customer header') { |_v| params['headers'] = 'x-customer' }
       opt.on('-n VAL', 'report count') { |v| params[:n] = v.to_i }
       opt.on('--nu', 'show table in nushell') { |_v| params[:output] = 'nu' }
@@ -146,9 +148,11 @@ when /journals?/, 'j'
       LucaCmd::Journal.add_header(args, params)
     end
   when 'stats'
+    params[:recursive] = false
     OptionParser.new do |opt|
       opt.banner = 'Usage: luca-book journals stats [options] [YYYY M]'
       opt.on('-c', '--code VAL', 'filter with code or label') { |v| params['code'] = v }
+      opt.on('-r', '--recursive', 'include subaccounts') { |_v| params[:recursive] = true }
       opt.on('-n VAL', 'report count') { |v| params[:n] = v.to_i }
       opt.on('--nu', 'show table in nushell') { |_v| params[:output] = 'nu' }
       opt.on('-o', '--output VAL', 'output serialized data') { |v| params[:output] = v }

data/lib/luca_book/accumulator.rb

@@ -74,7 +74,7 @@ module LucaBook
 
       # for assert purpose
       #
-      def gross(start_year, start_month, end_year = nil, end_month = nil,  code:  nil, date_range: nil, rows: 4)
+      def gross(start_year, start_month, end_year = nil, end_month = nil,  code:  nil, date_range: nil, rows: 4, recursive: false)
         if ! date_range.nil?
           raise if date_range.class != Range
           # TODO: date based range search
@@ -92,14 +92,14 @@ module LucaBook
             case i
             when 0
               idx_memo = row.map(&:to_s)
-              next if code && !idx_memo.include?(code)
+              next if code && idx_memo.select { |idx| /^#{code}/.match(idx) }.empty?
 
               idx_memo.each do |r|
                 sum[:debit][r] ||= BigDecimal('0')
                 sum[:debit_count][r] ||= 0
               end
             when 1
-              next if code && !idx_memo.include?(code)
+              next if code && idx_memo.select { |idx| /^#{code}/.match(idx) }.empty?
 
               row.each_with_index do |r, j|
                 sum[:debit][idx_memo[j]] += BigDecimal(r.to_s)
@@ -107,7 +107,7 @@ module LucaBook
               end
             when 2
               idx_memo = row.map(&:to_s)
-              break if code && !idx_memo.include?(code)
+              break if code && idx_memo.select { |idx| /^#{code}/.match(idx) }.empty?
 
               idx_memo.each do |r|
                 sum[:credit][r] ||= BigDecimal('0')
@@ -123,13 +123,21 @@ module LucaBook
             end
           end
         end
-        if code
-          sum[:debit] = sum[:debit][code] || BigDecimal('0')
-          sum[:credit] = sum[:credit][code] || BigDecimal('0')
-          sum[:debit_count] = sum[:debit_count][code] || 0
-          sum[:credit_count] = sum[:credit_count][code] || 0
+        return sum if code.nil?
+
+        codes = if recursive
+                  sum[:debit].keys.concat(sum[:credit].keys).uniq.select { |k| /^#{code}/.match(k) }
+                else
+                  Array(code)
+                end
+        res = { debit: 0, credit: 0, debit_count: 0, credit_count: 0 }
+        codes.each do |code|
+          res[:debit] += sum[:debit][code] || BigDecimal('0')
+          res[:credit] += sum[:credit][code] || BigDecimal('0')
+          res[:debit_count] += sum[:debit_count][code] || 0
+          res[:credit_count] += sum[:credit_count][code] || 0
         end
-        sum
+        res
       end
 
       # netting vouchers in specified term

data/lib/luca_book/list.rb

@@ -21,13 +21,17 @@ module LucaBook #:nodoc:
       @start = start_date
     end
 
-    def self.term(from_year, from_month, to_year = from_year, to_month = from_month, code: nil, basedir: @dirname)
+    def self.term(from_year, from_month, to_year = from_year, to_month = from_month, code: nil, basedir: @dirname, recursive: false)
       code = search_code(code) if code
       data = LucaBook::Journal.term(from_year, from_month, to_year, to_month, code).select do |dat|
         if code.nil?
           true
         else
-          [:debit, :credit].map { |key| serialize_on_key(dat[key], :code) }.flatten.include?(code)
+          if recursive
+            ! [:debit, :credit].map { |key| serialize_on_key(dat[key], :code) }.flatten.select { |idx|  /^#{code}/.match(idx) }.empty?
+          else
+            [:debit, :credit].map { |key| serialize_on_key(dat[key], :code) }.flatten.include?(code)
+          end
         end
       end
       new data, Date.new(from_year.to_i, from_month.to_i, 1), code
@@ -43,13 +47,13 @@ module LucaBook #:nodoc:
       end
     end
 
-    def list_by_code
-      calc_code
+    def list_by_code(recursive = false)
+      calc_code(recursive: recursive)
       convert_label
       @data = [code_header] + @data.map do |dat|
         date, txid = LucaSupport::Code.decode_id(dat[:id])
         {}.tap do |res|
-          res['code'] = dat[:code]
+          res['code'] = dat[:code].length == 1 ? dat[:code].first : dat[:code]
           res['date'] = date
           res['no'] = txid
           res['id'] = dat[:id]
@@ -99,30 +103,22 @@ module LucaBook #:nodoc:
 
     private
 
-    def set_balance
+    def set_balance(recursive = false)
       return BigDecimal('0') if @code.nil? || /^[A-H]/.match(@code)
 
-      balance_dict = Dict.latest_balance(@start)
-      start_balance = BigDecimal(balance_dict.dig(@code.to_s, :balance) || '0')
-      start = Dict.issue_date(balance_dict)&.next_month
-      last = @start.prev_month
-      if last.year >= start.year && last.month >= start.month
-        start_balance + self.class.term(start.year, start.month, last.year, last.month, code: @code).accumulate_code
-      else
-        start_balance
-      end
+      LucaBook::State.start_balance(@start.year, @start.month, recursive: recursive)
     end
 
-    def calc_code
-      @balance = set_balance
+    def calc_code(recursive: false)
+      @balance = set_balance(recursive)[@code] || BigDecimal('0')
       if @code
         balance = @balance
         @data.each do |dat|
           dat[:diff] = Util.diff_by_code(dat[:debit], @code) - Util.diff_by_code(dat[:credit], @code)
           balance += dat[:diff]
           dat[:balance] = balance
-          dat[:code] = @code
-          counter = dat[:diff] * Util.pn_debit(@code) > 0 ? :credit : :debit
+          target, counter = dat[:diff] * Util.pn_debit(@code) > 0 ? [:debit, :credit] : [:credit, :debit]
+          dat[:code] = dat[target].map { |d| d[:code] }
           dat[:counter_code] = dat[counter].map { |d| d[:code] }
         end
       end
@@ -132,7 +128,7 @@ module LucaBook #:nodoc:
     def convert_label
       @data.each do |dat|
         if @code
-          dat[:code] = "#{dat[:code]} #{@@dict.dig(dat[:code], :label)}"
+          dat[:code] = dat[:code].map { |target| "#{target} #{@@dict.dig(target, :label)}" }
           dat[:counter_code] = dat[:counter_code].map { |counter| "#{counter} #{@@dict.dig(counter, :label)}" }
         else
           dat[:debit].each { |debit| debit[:code] = "#{debit[:code]} #{@@dict.dig(debit[:code], :label)}" }

data/lib/luca_book/state.rb

@@ -27,7 +27,7 @@ module LucaBook
       @count = count
       @start_date = start_d
       @end_date = end_d
-      @start_balance = set_balance
+      set_balance
     end
 
     def self.range(from_year, from_month, to_year = from_year, to_month = from_month)
@@ -50,25 +50,29 @@ module LucaBook
          )
     end
 
-    def self.by_code(code, from_year, from_month, to_year = from_year, to_month = from_month)
+    def self.by_code(code, from_year, from_month, to_year = from_year, to_month = from_month, recursive: false)
       code = search_code(code) if code
       date = Date.new(from_year.to_i, from_month.to_i, -1)
       last_date = Date.new(to_year.to_i, to_month.to_i, -1)
       raise 'invalid term specified' if date > last_date
 
-      reports = [].tap do |r|
+      balance = start_balance(date.year, date.month, recursive: recursive)[code] || 0
+      first_line = { 'code' => nil, 'label' => nil, 'debit_amount' => nil, 'debit_count' => nil, 'credit_amount' => nil, 'credit_count' => nil, 'net' => nil, 'balance' => balance, '_d' => nil }
+      reports = [first_line].tap do |r|
         while date <= last_date do
           diff = {}.tap do |h|
-            g = gross(date.year, date.month, code: code)
+            g = gross(date.year, date.month, code: code, recursive: recursive)
             sum = g.dig(:debit).nil? ? BigDecimal('0') : Util.calc_diff(g[:debit], code)
             sum -= g.dig(:credit).nil? ? BigDecimal('0') : Util.calc_diff(g[:credit], code)
+            balance += sum
             h['code'] = code
-            h['label'] = LucaRecord::Dict.load('base.tsv').dig(code, :label)
-            h['net'] = sum
+            h['label'] = @@dict.dig(code, :label)
             h['debit_amount'] = g[:debit]
             h['debit_count'] = g[:debit_count]
             h['credit_amount'] = g[:credit]
             h['credit_count'] = g[:credit_count]
+            h['net'] = sum
+            h['balance'] = balance
             h['_d'] = date.to_s
           end
           r << diff
@@ -205,25 +209,28 @@ module LucaBook
     end
 
     def set_balance
-      pre_last = @start_date.prev_month
-      start_year = if @start_date.month > CONFIG['fy_start'].to_i
-                     pre_last.year
-                   else
-                     pre_last.year - 1
-                   end
-      pre = self.class.accumulate_term(start_year, CONFIG['fy_start'], pre_last.year, pre_last.month)
-
-      base = Dict.latest_balance(@start_date).each_with_object({}) do |(k, v), h|
+      @start_balance = self.class.start_balance(@start_date.year, @start_date.month)
+    end
+
+    def self.start_balance(year, month, recursive: true)
+      start_date = Date.new(year, month, 1)
+      base = Dict.latest_balance(start_date).each_with_object({}) do |(k, v), h|
         h[k] = BigDecimal(v[:balance].to_s) if v[:balance]
         h[k] ||= BigDecimal('0') if k.length == 2
       end
-      if pre
-        idx = (pre.keys + base.keys).uniq
-        base = {}.tap do |h|
-          idx.each { |k| h[k] = (base[k] || BigDecimal('0')) + (pre[k] || BigDecimal('0')) }
+      if month == CONFIG['fy_start'].to_i
+        return recursive ? total_subaccount(base) : base
+      end
+
+      pre_last = start_date.prev_month
+      year -= 1 if month <= CONFIG['fy_start'].to_i
+      pre = accumulate_term(year, CONFIG['fy_start'], pre_last.year, pre_last.month)
+      total = {}.tap do |h|
+        (pre.keys + base.keys).uniq.each do |k|
+          h[k] = (base[k] || BigDecimal('0')) + (pre[k] || BigDecimal('0'))
         end
       end
-      self.class.total_subaccount(base)
+      recursive ? total_subaccount(total) : total
     end
 
     def render_xbrl(filename = nil)

data/lib/luca_book/util.rb

@@ -24,7 +24,7 @@ module LucaBook
 
     def amount_by_code(items, code)
       items
-        .select { |item| item.dig(:code) == code }
+        .select { |item| /^#{code}/.match(item[:code]) }
         .inject(BigDecimal('0')) { |sum, item| sum + item[:amount] }
     end
 

data/lib/luca_book/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LucaBook
-  VERSION = '0.2.26'
+  VERSION = '0.2.27'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lucabook
 version: !ruby/object:Gem::Version
-  version: 0.2.26
+  version: 0.2.27
 platform: ruby
 authors:
 - Chuma Takahiro