lucabook 0.2.7

data/exe/luca-book

@@ -0,0 +1,54 @@
+#!/usr/bin/ruby
+
+require "optparse"
+require "luca_book/console"
+
+def list(args, params)
+  if params["c"] or params["code"]
+    code = params["c"] || params["code"]
+    LucaBookConsole.new.by_code(code, args.dig(0), args.dig(1))
+  elsif args.length > 0
+    LucaBookConsole.new.by_month(args[0], args.dig(1))
+  else
+    LucaBookConsole.new.all
+  end
+end
+
+def report(args, params)
+  if params['bs']
+    LucaBook::State.term(*args).bs.to_yaml
+  elsif params['pl']
+    LucaBook::State.term(*args).pl.to_yaml
+  else
+    LucaBook::State.term(*args).to_yaml
+  end
+end
+
+cmd = ARGV.shift
+
+case cmd
+when "list"
+  params = {}
+  OptionParser.new do |opt|
+    opt.banner = 'Usage: luca list [year month]'
+    opt.on('-c', '--code VAL', 'search with code'){|v| params["code"] = v }
+    opt.on_tail('List records. If you specify code and/or month, search on each criteria.')
+    args = opt.parse!(ARGV)
+    list(args, params)
+  end
+when "report"
+  params = {}
+  OptionParser.new do |opt|
+    opt.banner = 'Usage: luca report'
+    opt.on('--bs', 'show Balance sheet'){|v| params["bs"] = v }
+    opt.on('--pl', 'show Income statement'){|v| params["pl"] = v }
+    args = opt.parse!(ARGV)
+    report(args, params)
+  end
+when "--help"
+  puts 'Usage: luca subcommand'
+  puts '  list: list records'
+  puts '  report: show reports'
+else
+  puts 'Invalid subcommand'
+end

data/lib/luca_book.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'luca_book/version'
+
+module LucaBook
+  autoload :Journal, 'luca_book/journal'
+  autoload :State, 'luca_book/state'
+end

data/lib/luca_book/console.rb

@@ -0,0 +1,134 @@
+require 'luca_book'
+
+class LucaBookConsole
+
+  def initialize(dir_path=nil)
+    @report = LucaBookReport.new(dir_path)
+  end
+
+  def all
+    array = @report.scan_terms(@report.book.pjdir).map{|y,m| y}.uniq.map{|year|
+      @report.book.search(year)
+    }.flatten
+    show_records(array)
+  end
+
+  def by_code(code, year=nil, month=nil)
+    array = @report.by_code(code, year, month)
+    show_records(array)
+  end
+
+  def by_month(year, month)
+    array = @report.book.search(year, month)
+    show_records(array)
+  end
+
+  def show_records(records)
+    print "#{cnsl_fmt("ID")} #{cnsl_fmt("debit")} #{cnsl_fmt("credit")} #{cnsl_fmt("")*2}"
+    print "#{cnsl_fmt("balance")}" unless records.first.dig(:balance).nil?
+    puts
+    records.each do |h|
+      puts "#{cnsl_fmt(h.dig(:id))} #{"-"*85}"
+      lines = [h.dig(:debit)&.length, h.dig(:credit)&.length]&.max || 0
+      lines.times do |i|
+        puts "#{cnsl_fmt("")} #{cnsl_fmt(h.dig(:debit, i, :amount))}   #{cnsl_code(h.dig(:debit, i))}" if h.dig(:debit, i, :amount)
+        puts "#{cnsl_fmt("")*2} #{cnsl_fmt(h.dig(:credit, i, :amount))}   #{cnsl_code(h.dig(:credit, i))}" if h.dig(:credit, i, :amount)
+      end
+      puts "#{cnsl_fmt(""*15)*5}   #{cnsl_fmt(h.dig(:balance))}" unless h.dig(:balance).nil?
+      puts "#{cnsl_fmt(""*15)}   #{h.dig(:note)}"
+    end
+  end
+
+  def bs
+    target = []
+    report = []
+    output = @report.accumulate_all do |f|
+      target << f[:target]
+      report << f[:current]
+      #diff << f[:diff]
+    end
+    puts "---- BS ----"
+    target.each_slice(6) do |v|
+      puts "#{cnsl_fmt("", 14)} #{v.map{|v| cnsl_fmt(v, 14)}.join}"
+    end
+    convert_collection(report).each do |h|
+      if /^[0-9]/.match(h[:code])
+        if /[^0]$/.match(h[:code])
+          print "  "
+          print "  " if h[:code].length > 3
+        end
+        puts cnsl_label(h[:label], h[:code])
+        h[:value].each_slice(6) do |v|
+          puts "#{cnsl_fmt("", 14)} #{v.map{|v| cnsl_fmt(v, 14)}.join}"
+        end
+      end
+    end
+    puts "----  ----"
+  end
+
+  def pl
+    target = []
+    report = []
+    output = @report.accumulate_all do |f|
+      target << f[:target]
+      report << f[:diff]
+      #current << f[:current]
+    end
+    puts "---- PL ----"
+    target.each_slice(6) do |v|
+      puts "#{cnsl_fmt("", 14)} #{v.map{|v| cnsl_fmt(v, 14)}.join}"
+    end
+    convert_collection(report).each do |h|
+      if /^[A-Z]/.match(h[:code])
+        total = [h[:value].inject(:+)] + Array.new(h[:value].length)
+        if /[^0]$/.match(h[:code])
+          print "  "
+          print "  " if h[:code].length > 3
+        end
+        puts cnsl_label(h[:label], h[:code])
+        h[:value].each_slice(6).with_index(0) do |v, i|
+          puts "#{cnsl_fmt(total[i], 14)} #{v.map{|v| cnsl_fmt(v, 14)}.join}"
+        end
+      end
+    end
+    puts "----  ----"
+  end
+
+  def convert_collection(obj)
+    {}.tap {|res|
+      obj.each do |month|
+        month.each do |k,v|
+          if res.has_key?(k)
+            res[k] << v
+          else
+            res[k] = [v]
+          end
+        end
+      end
+    }.sort.map do |k,v|
+      {code: k, label: @report.dict.dig(k, :label), value: v}
+    end
+  end
+
+  def cnsl_label(label, code)
+        if /[0]$/.match(code)
+          cnsl_bold(label) + " " + "-"*80
+        else
+          label
+        end
+  end
+
+  def cnsl_bold(str)
+    "\e[1m#{str}\e[0m"
+  end
+
+  def cnsl_code(obj)
+    code = @report.dict.dig(obj&.dig(:code))&.dig(:label) || ""
+  end
+
+  def cnsl_fmt(str, width=15, length=nil)
+    length ||= width
+    sprintf("%#{width}.#{length}s", str)
+  end
+
+end

data/lib/luca_book/dict.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'luca_support/config'
+require 'luca_record/dict'
+
+module LucaBook
+  class Dict < LucaRecord::Dict
+
+    @filename = 'dict.tsv'
+
+    Data = load
+  end
+end

data/lib/luca_book/import.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'json'
+require 'luca_book'
+require 'luca_support'
+#require 'luca_book/dict'
+require 'luca_record'
+
+module LucaBook
+  class Import
+    DEBIT_DEFAULT = '仮払金'
+    CREDIT_DEFAULT = '仮受金'
+
+    def initialize(path)
+      raise 'no such file' unless FileTest.file?(path)
+
+      @target_file = path
+      # TODO: yaml need to be configurable
+      @dict = LucaRecord::Dict.new('import.yaml')
+      @code_map = LucaRecord::Dict.reverse(LucaRecord::Dict.load('base.tsv'))
+      @config = @dict.csv_config
+    end
+
+    # === JSON Format:
+    #   {
+    #     "date": "2020-05-04",
+    #     "debit" : [
+    #       {
+    #         "label": "savings accounts",
+    #         "value": 20000
+    #       }
+    #     ],
+    #     "credit" : [
+    #       {
+    #         "label": "trade notes receivable",
+    #         "value": 20000
+    #       }
+    #     ],
+    #     "note": "settlement for the last month trade"
+    #   }
+    #
+    def import_json(io)
+      d = JSON.parse(io)
+      validate(d)
+
+      # dict = LucaBook::Dict.reverse_dict(LucaBook::Dict::Data)
+      d['debit'].each { |h| h['code'] = @dict.search(h['label'], DEBIT_DEFAULT) }
+      d['credit'].each { |h| h['code'] = @dict.search(h['label'], CREDIT_DEFAULT) }
+
+      LucaBook.new.create!(d)
+    end
+
+    def import_csv
+      @dict.load_csv(@target_file) do |row|
+        if @config[:type] == 'single'
+          LucaBook::Journal.create!(parse_single(row))
+        elsif @config[:type] == 'double'
+          p parse_double(row)
+        else
+          p row
+        end
+      end
+    end
+
+    #
+    # convert single entry data
+    #
+    def parse_single(row)
+      value = row.dig(@config[:credit_value])&.empty? ? row[@config[:debit_value]] : row[@config[:credit_value]]
+      {}.tap do |d| 
+        d['date'] = parse_date(row)
+        if row.dig(@config[:credit_value])&.empty?
+          d['debit'] = [
+            { 'code' => search_code(row[@config[:label]], DEBIT_DEFAULT) }
+          ]
+          d['credit'] = [
+            { 'code' => @code_map.dig(@config[:counter_label]) }
+          ]
+        else
+          d['debit'] = [
+            { 'code' => @code_map.dig(@config[:counter_label]) }
+          ]
+          d['credit'] = [
+            { 'code' => search_code(row[@config[:label]], CREDIT_DEFAULT) }
+          ]
+        end
+        d['debit'][0]['value'] = value
+        d['credit'][0]['value'] = value
+        d['note'] = row[@config[:note]]
+      end
+    end
+
+    #
+    # convert double entry data
+    #
+    def parse_double(row)
+      {}.tap do |d|
+        d['date'] = parse_date(row)
+        d['debit'] = {
+          'code' => search_code(row[@config[:debit_label]], DEBIT_DEFAULT),
+          'value' => row.dig(@config[:debit_value])
+        }
+        d['credit'] = {
+          'code' => search_code(row[@config[:credit_label]], CREDIT_DEFAULT),
+          'value' => row.dig(@config[:credit_value])
+        }
+        d['note'] = row[@config[:note]]
+      end
+    end
+
+    def search_code(label, default_label)
+      @code_map.dig(@dict.search(label, default_label))
+    end
+
+    def parse_date(row)
+      return nil if row.dig(@config[:year]).empty?
+
+      "#{row.dig(@config[:year])}-#{row.dig(@config[:month])}-#{row.dig(@config[:day])}"
+    end
+
+    def validate(obj)
+      raise 'NoDateKey' if ! obj.has_key?('date')
+      raise 'NoDebitKey' if ! obj.has_key?('debit')
+      raise 'NoDebitValue' if obj['debit'].length < 1
+      raise 'NoCreditKey' if ! obj.has_key?('credit')
+      raise 'NoCreditValue' if obj['credit'].length < 1
+    end
+  end
+end

data/lib/luca_book/journal.rb

@@ -0,0 +1,80 @@
+#
+# manipulate files based on transaction date
+#
+
+require 'csv'
+require 'date'
+require 'luca_record'
+
+module LucaBook
+  class Journal < LucaRecord::Base
+    @dirname = 'journals'
+
+    #
+    # create journal from hash
+    #
+    def self.create!(d)
+      date = Date.parse(d['date'])
+
+      debit_amount = serialize_on_key(d['debit'], 'value')
+      credit_amount = serialize_on_key(d['credit'], 'value')
+      raise 'BalanceUnmatch' if debit_amount.inject(:+) != credit_amount.inject(:+)
+
+      debit_code = serialize_on_key(d['debit'], 'code')
+      credit_code = serialize_on_key(d['credit'], 'code')
+
+      # TODO: limit code length for filename
+      codes = (debit_code + credit_code).uniq
+      create_record!(date, codes) do |f|
+        f << debit_code
+        f << debit_amount
+        f << credit_code
+        f << credit_amount
+        f << []
+        f << [d.dig('note')]
+      end
+    end
+
+    #
+    # collect values on specified key
+    #
+    def self.serialize_on_key(array_of_hash, key)
+      array_of_hash.map { |h| h[key] }
+    end
+
+    #
+    # override de-serializing journal format
+    #
+    def self.load_data(io, path)
+      {}.tap do |record|
+        body = false
+        record[:id] = path[0] + path[1]
+        CSV.new(io, headers: false, col_sep: "\t", encoding: 'UTF-8')
+          .each.with_index(0) do |line, i|
+          case i
+          when 0
+            record[:debit] = line.map { |row| { code: row } }
+          when 1
+            line.each_with_index do |amount, i|
+              record[:debit][i][:amount] = amount.to_i # TODO: bigdecimal support
+            end
+          when 2
+            record[:credit] = line.map { |row| { code: row } }
+          when 3
+            line.each_with_index do |amount, i|
+              record[:credit][i][:amount] = amount.to_i # TODO: bigdecimal support
+            end
+          else
+            if line.empty?
+              record[:note] ||= []
+              body = true
+              next
+            end
+            record[:note] << line.join(' ') if body
+          end
+          record[:note]&.join('\n')
+        end
+      end
+    end
+  end
+end

data/lib/luca_book/report.rb

@@ -0,0 +1,3 @@
+# move to LucaBook::State
+class LucaBookReport
+end

data/lib/luca_book/state.rb

@@ -0,0 +1,250 @@
+
+require 'csv'
+require 'pathname'
+require 'date'
+require 'luca_support'
+require 'luca_record'
+require 'luca_record/dict'
+require 'luca_book'
+
+#
+# Statement on specified term
+#
+module LucaBook
+  class State < LucaRecord::Base
+    @dirname = 'journals'
+    @record_type = 'raw'
+
+    attr_reader :statement
+
+    def initialize(data)
+      @data = data
+      @dict = LucaRecord::Dict.load('base.tsv')
+    end
+
+    # TODO: not compatible with LucaRecord::Base.open_records
+    def search_tag(code)
+      count = 0
+      Dir.children(LucaSupport::Config::Pjdir).sort.each do |dir|
+        next if ! FileTest.directory?(LucaSupport::Config::Pjdir+dir)
+
+        open_records(datadir, dir, 3) do |row, i|
+          next if i == 2
+          count += 1 if row.include?(code)
+        end
+      end
+      puts "#{code}: #{count}"
+    end
+
+    def self.term(from_year, from_month, to_year = from_year, to_month = from_month)
+      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|
+        while date <= last_date do
+          r << accumulate_month(date.year, date.month)
+          date = date.next_month
+        end
+      end
+      new reports
+    end
+
+    def by_code(code, year=nil, month=nil)
+      raise "not supported year range yet" if ! year.nil? && month.nil?
+
+      bl = @book.load_start.dig(code) || 0
+      full_term = scan_terms(LucaSupport::Config::Pjdir)
+      if ! month.nil?
+        pre_term = full_term.select{|y,m| y <= year.to_i && m < month.to_i }
+        bl += pre_term.map{|y,m| self.class.net(y, m)}.inject(0){|sum, h| sum + h[code]}
+        [{ code: code, balance: bl, note: "#{code} #{dict.dig(code, :label)}" }] + records_with_balance(year, month, code, bl)
+      else
+        start = { code: code, balance: bl, note: "#{code} #{dict.dig(code, :label)}" }
+        full_term.map {|y, m| y }.uniq.map {|y|
+          records_with_balance(y, nil, code, bl)
+        }.flatten.prepend(start)
+      end
+    end
+
+    def records_with_balance(year, month, code, balance)
+      @book.search(year, month, nil, code).each do |h|
+        balance += self.class.calc_diff(amount_by_code(h[:debit], code), code) - @book.calc_diff(amount_by_code(h[:credit], code), code)
+        h[:balance] = balance
+      end
+    end
+
+    #
+    # TODO: useless method. consider to remove
+    #
+    def accumulate_all
+      current = @book.load_start
+      target = []
+      Dir.chdir(@book.pjdir) do
+        net_records = scan_terms(@book.pjdir).map do |year, month|
+          target << [year, month]
+          accumulate_month(year, month)
+        end
+        all_keys = net_records.map{|h| h.keys}.flatten.uniq
+        net_records.each.with_index(0) do |diff, i|
+          all_keys.each {|key| diff[key] = 0 unless diff.has_key?(key)}
+          diff.each do |k,v|
+            if current[k]
+              current[k] += v
+            else
+              current[k] = v
+            end
+          end
+          f = { target: "#{target[i][0]}-#{target[i][1]}", diff: diff.sort, current: current.sort }
+          yield f
+        end
+      end
+    end
+
+    def to_yaml
+      YAML.dump(code2label).tap { |data| puts data }
+    end
+
+    def code2label
+      @statement ||= @data
+      @statement.map do |report|
+        {}.tap do |h|
+          report.each { |k, v| h[@dict.dig(k, :label)] = v }
+        end
+      end
+    end
+
+    def bs
+      @statement = @data.map do |data|
+        data.select { |k, v| /^[0-9].+/.match(k) }
+      end
+      self
+    end
+
+    def pl
+      @statement = @data.map do |data|
+        data.select { |k, v| /^[A-F].+/.match(k) }
+      end
+      self
+    end
+
+    def self.accumulate_month(year, month)
+      monthly_record = net(year, month)
+      total_subaccount(monthly_record)
+    end
+
+    def amount_by_code(items, code)
+      items
+        .select{|item| item.dig(:code) == code }
+        .inject(0){|sum, item| sum + item[:amount] }
+    end
+
+    def self.total_subaccount(report)
+      report.dup.tap do |res|
+        report.each do |k, v|
+          if k.length >= 4
+            if res[k[0, 3]]
+              res[k[0, 3]] += v
+            else
+              res[k[0, 3]] = v
+            end
+          end
+        end
+        res['10'] = sum_matched(report, /^[123].[^0]/)
+        res['40'] = sum_matched(report, /^[4].[^0]}/)
+        res['50'] = sum_matched(report, /^[56].[^0]/)
+        res['70'] = sum_matched(report, /^[78].[^0]/)
+        res['90'] = sum_matched(report, /^[9].[^0]/)
+        res['A0'] = sum_matched(report, /^[A].[^0]/)
+        res['B0'] = sum_matched(report, /^[B].[^0]/)
+        res['BA'] = res['A0'] - res['B0']
+        res['C0'] = sum_matched(report, /^[C].[^0]/)
+        res['CA'] = res['BA'] - res['C0']
+        res['D0'] = sum_matched(report, /^[D].[^0]/)
+        res['E0'] = sum_matched(report, /^[E].[^0]/)
+        res['EA'] = res['CA'] + res['D0'] - res['E0']
+        res['F0'] = sum_matched(report, /^[F].[^0]/)
+        res['G0'] = sum_matched(report, /^[G].[^0]/)
+        res['GA'] = res['EA'] + res['F0'] - res['G0']
+        res['HA'] = res['GA'] - sum_matched(report, /^[H].[^0]/)
+      end
+    end
+
+    def self.sum_matched(report, reg)
+      report.select { |k, v| reg.match(k)}.values.sum
+    end
+
+    # for assert purpose
+    def self.gross(year, month = nil, code = nil, date_range = nil, rows = 4)
+      if ! date_range.nil?
+        raise if date_range.class != Range
+        # TODO: date based range search
+      end
+
+      sum = { debit: {}, credit: {} }
+      idx_memo = []
+      asof(year, month) do |f, _path|
+        CSV.new(f, headers: false, col_sep: "\t", encoding: 'UTF-8')
+          .each_with_index do |row, i|
+          break if i >= rows
+          case i
+          when 0
+            idx_memo = row.map(&:to_s)
+            idx_memo.each { |r| sum[:debit][r] ||= 0 }
+          when 1
+            row.each_with_index { |r, i| sum[:debit][idx_memo[i]] += r.to_i } # TODO: bigdecimal support
+          when 2
+            idx_memo = row.map(&:to_s)
+            idx_memo.each { |r| sum[:credit][r] ||= 0 }
+          when 3
+            row.each_with_index { |r, i| sum[:credit][idx_memo[i]] += r.to_i } # TODO: bigdecimal support
+          else
+            puts row # for debug
+          end
+        end
+      end
+      sum
+    end
+
+    # netting vouchers in specified term
+    def self.net(year, month = nil, code = nil, date_range = nil)
+      g = gross(year, month, code, date_range)
+      idx = (g[:debit].keys + g[:credit].keys).uniq.sort
+      {}.tap do |sum|
+        idx.each do |code|
+          sum[code] = g.dig(:debit, code).nil? ? 0 : calc_diff(g[:debit][code], code)
+          sum[code] -= g.dig(:credit, code).nil? ? 0 : calc_diff(g[:credit][code], code)
+        end
+      end
+    end
+
+    def load_start
+      file = LucaSupport::Config::Pjdir + 'start.tsv'
+      {}.tap do |dic|
+        load_tsv(file) do |row|
+          dic[row[0]] = row[2].to_i if ! row[2].nil?
+        end
+      end
+    end
+
+    def self.calc_diff(num, code)
+      amount = /\./.match(num.to_s) ? BigDecimal(num) : num.to_i
+      amount * pn_debit(code.to_s)
+    end
+
+    def self.pn_debit(code)
+      case code
+      when /^[0-4BCEGH]/
+        1
+      when /^[5-9ADF]/
+        -1
+      else
+        nil
+      end
+    end
+
+    def dict
+      LucaBook::Dict::Data
+    end
+  end
+end