lucabook 0.2.8 → 0.2.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a024fa5882d001a6fce7d60863cf0d5d1fefbb4ae92dc0a774a5ce79eeb5749
-  data.tar.gz: 7ce4e31ef3c99a02790a462a5db798fd65c9248ef1b2e467ad6a6920f0fa8cee
+  metadata.gz: 5b204a2ed70889d0750a6883de424ceb3b7e335cce99262eb98e288db6962cbd
+  data.tar.gz: e19db20331a4edce1ea02ffb47495c3f849f74ba0bf78b13c7cf0562207fc0d2
 SHA512:
-  metadata.gz: 911cd82032b9d138e356d5a1d1fd7ca95c396ae953426071fd7334ec33cae25882746a5f4b353396211b24de3c79c16a2b8767f172e6368dc1dc0d5195b8a278
-  data.tar.gz: eda9e10010600b88708b08d5b099d18f870b73dea3d59d6ea7f8ac216588d4c4335846a4c084c90a470dad90facfa0aa076cfa625ddc6615c65302d834162006
+  metadata.gz: 16800a60362abcc56adb26ed60611a98a5ec5c3545143b4a0c4a379aac3988952e733dac19bf5c2188ce9e7c244dff1b4d6269635a226eeda51ec85c4ab2178f
+  data.tar.gz: f60f61de1a1c18df3db8c1bc5278ae084089137b15ee88f198ff17c6418917c6adebb634820dcd9979b42a9ecf7e902329c7bb14fb950f5270154492a2b0d8b2

data/exe/luca-book

@@ -2,68 +2,112 @@
 
 require 'optparse'
 require 'luca_book'
-require 'luca_book/console'
 
-def import(args, params)
-  LucaBook::Import.new(args[0]).import_csv
-end
+module LucaCmd
+  class Journal
+    def self.import(args, params)
+      if params['config']
+        LucaBook::Import.new(args[0], params['config']).import_csv
+      elsif params['json']
+        LucaBook::Import.import_json(STDIN.read)
+      else
+        puts 'Usage: luca-book import -c import_config'
+      end
+    end
+
+    def self.list(args, params)
+      if params['code']
+        LucaBook::List.term(*args, code: params['code']).list_on_code.to_yaml
+      elsif args.length > 0
+        LucaBook::List.term(*args).list_journals.to_yaml
+      else
+        # TODO: define default function
+      end
+    end
 
-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
+    def self.stats(args, params)
+      LucaBook::State.term(*args).stats(params[:level])
+    end
   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
+  class Report
+    def self.balancesheet(args, params)
+      level = params[:level] || 2
+      legal = params[:legal] || false
+      LucaBook::State.term(*args).bs(level, legal: legal)
+    end
+
+    def self.profitloss(args, params)
+      LucaBook::State.term(*args).pl.to_yaml
+    end
   end
 end
 
+def new_pj(args = nil, params = {})
+  LucaBook::Setup.create_project params['country'], args[0]
+end
+
 LucaRecord::Base.valid_project?
 cmd = ARGV.shift
+params = {}
 
 case cmd
-when 'import'
-  params = {}
-  OptionParser.new do |opt|
-    opt.banner = 'Usage: luca import filepath'
-    # TODO: need to handle import config
-    args = opt.parse!(ARGV)
-    import(args, params)
+when /journals?/, 'j'
+  subcmd = ARGV.shift
+  case subcmd
+  when 'import'
+    OptionParser.new do |opt|
+      opt.banner = 'Usage: luca-book journals import filepath'
+      opt.on('-c', '--config VAL', 'import definition'){ |v| params['config'] = v }
+      opt.on('-j', '--json', 'import via json format'){ |_v| params['json'] = true }
+      args = opt.parse!(ARGV)
+      LucaCmd::Journal.import(args, params)
+    end
+  when 'list'
+    OptionParser.new do |opt|
+      opt.banner = 'Usage: luca-book journals 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)
+      LucaCmd::Journal.list(args, params)
+    end
+  when 'stats'
+    OptionParser.new do |opt|
+      opt.banner = 'Usage: luca-book reports bs'
+      opt.on('-l', '--level VAL', 'account level') { |v| params[:level] = v.to_i }
+      args = opt.parse!(ARGV)
+      LucaCmd::Journal.stats(args, params)
+    end
   end
-when 'list'
-  params = {}
+when 'new'
   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)
+    opt.banner = 'Usage: luca-book new Dir'
+    opt.on('-c', '--country VAL', 'specify country code') { |v| params['coountry'] = v }
+    args = opt.parse(ARGV)
+    new_pj(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)
+when /reports?/, 'r'
+  subcmd = ARGV.shift
+  case subcmd
+  when 'bs'
+    OptionParser.new do |opt|
+      opt.banner = 'Usage: luca-book reports bs'
+      opt.on('-l', '--level VAL', 'account level') { |v| params[:level] = v.to_i }
+      opt.on('--legal', 'show legal mandatory account') { |_v| params[:legal] = true }
+      args = opt.parse!(ARGV)
+      LucaCmd::Report.balancesheet(args, params)
+    end
+  when 'pl'
+    OptionParser.new do |opt|
+      opt.banner = 'Usage: luca-book reports pl'
+      args = opt.parse!(ARGV)
+      LucaCmd::Report.profitloss(args, params)
+    end
   end
 when '--help'
-  puts 'Usage: luca subcommand'
-  puts '  import: import records'
-  puts '  list: list records'
-  puts '  report: show reports'
+  puts 'Usage: luca-book subcommand'
+  puts '  journals: operate journal records'
+  puts '  reports: show reports'
 else
   puts 'Invalid subcommand'
 end

data/lib/luca_book.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
+require 'csv'
 require 'luca_record'
 require 'luca_book/version'
 
 module LucaBook
+  autoload :Dict, 'luca_book/dict'
   autoload :Import, 'luca_book/import'
   autoload :Journal, 'luca_book/journal'
+  autoload :List, 'luca_book/list'
+  autoload :Setup, 'luca_book/setup'
   autoload :State, 'luca_book/state'
+  autoload :Util, 'luca_book/util'
 end

data/lib/luca_book/console.rb

@@ -1,25 +1,15 @@
 require 'luca_book'
 
+# This class will be deleted
+#
 class LucaBookConsole
 
   def initialize(dir_path=nil)
-    @report = LucaBookReport.new(dir_path)
+    @report = LucaBook::State.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)
+  def by_term(year, month, end_year = year, end_month = month)
+    array = @report.book.class.term(year, month, end_year, end_month)
     show_records(array)
   end
 
@@ -39,6 +29,7 @@ class LucaBookConsole
     end
   end
 
+  # TODO: deprecated. accumulate_all() already removed.
   def bs
     target = []
     report = []
@@ -66,6 +57,7 @@ class LucaBookConsole
     puts "----  ----"
   end
 
+  # TODO: deprecated. accumulate_all() already removed.
   def pl
     target = []
     report = []

data/lib/luca_book/dict.rb

@@ -2,12 +2,19 @@
 
 require 'luca_support/config'
 require 'luca_record/dict'
+require 'date'
+require 'pathname'
 
 module LucaBook
   class Dict < LucaRecord::Dict
+    def self.latest_balance
+      dict_dir = Pathname(LucaSupport::Config::Pjdir) / 'data' / 'balance'
+      # TODO: search latest balance dictionary
+      load_tsv_dict(dict_dir / 'start.tsv')
+    end
 
-    @filename = 'dict.tsv'
-
-    Data = load
+    def self.issue_date(obj)
+      Date.parse(obj.dig('_date', :label))
+    end
   end
 end

data/lib/luca_book/import.rb

@@ -9,70 +9,84 @@ require 'luca_record'
 
 module LucaBook
   class Import
-    DEBIT_DEFAULT = '仮払金'
-    CREDIT_DEFAULT = '仮受金'
+    DEBIT_DEFAULT = '10XX'
+    CREDIT_DEFAULT = '50XX'
 
-    def initialize(path)
+    def initialize(path, dict)
       raise 'no such file' unless FileTest.file?(path)
 
       @target_file = path
       # TODO: yaml need to be configurable
-      @dict = LucaRecord::Dict.new('import.yaml')
+      @dict_name = dict
+      @dict = LucaRecord::Dict.new("import-#{dict}.yaml")
       @code_map = LucaRecord::Dict.reverse(LucaRecord::Dict.load('base.tsv'))
-      @config = @dict.csv_config
+      @config = @dict.csv_config if dict
     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"
-    #   }
+    #   [
+    #     {
+    #       "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)
+    def self.import_json(io)
+      JSON.parse(io).each do |d|
+        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) }
+        code_map = LucaRecord::Dict.reverse(LucaRecord::Dict.load('base.tsv'))
+        d['debit'].each { |h| h['code'] = code_map.dig(h['label']) || DEBIT_DEFAULT }
+        d['credit'].each { |h| h['code'] = code_map.dig(h['label']) || CREDIT_DEFAULT }
 
-      LucaBook.new.create!(d)
+        LucaBook::Journal.create(d)
+      end
     end
 
     def import_csv
       @dict.load_csv(@target_file) do |row|
         if @config[:type] == 'single'
-          LucaBook::Journal.create!(parse_single(row))
+          LucaBook::Journal.create(parse_single(row))
         elsif @config[:type] == 'double'
-          p parse_double(row)
+          p parse_double(row) # TODO: Not implemented yet
         else
           p row
         end
       end
     end
 
+    def self.validate(obj)
+      raise 'NoDateKey' unless obj.key?('date')
+      raise 'NoDebitKey' unless obj.key?('debit')
+      raise 'NoDebitValue' if obj['debit'].empty?
+      raise 'NoCreditKey' unless obj.key?('credit')
+      raise 'NoCreditValue' if obj['credit'].empty?
+    end
+
+    private
+
     #
     # 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| 
+      {}.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) }
+            { 'code' => search_code(row[@config[:label]], @config.dig(:default_debit)) || DEBIT_DEFAULT }
           ]
           d['credit'] = [
             { 'code' => @code_map.dig(@config[:counter_label]) }
@@ -82,12 +96,13 @@ module LucaBook
             { 'code' => @code_map.dig(@config[:counter_label]) }
           ]
           d['credit'] = [
-            { 'code' => search_code(row[@config[:label]], CREDIT_DEFAULT) }
+            { 'code' => search_code(row[@config[:label]], @config.dig(:default_credit)) || CREDIT_DEFAULT }
           ]
         end
         d['debit'][0]['value'] = value
         d['credit'][0]['value'] = value
-        d['note'] = row[@config[:note]]
+        d['note'] = Array(@config[:note]).map{ |col| row[col] }.join(' ')
+        d['x-editor'] = "LucaBook::Import/#{@dict_name}"
       end
     end
 
@@ -98,14 +113,15 @@ module LucaBook
       {}.tap do |d|
         d['date'] = parse_date(row)
         d['debit'] = {
-          'code' => search_code(row[@config[:debit_label]], DEBIT_DEFAULT),
+          'code' => search_code(row[@config[:label]], @config.dig(:default_debit)) || DEBIT_DEFAULT,
           'value' => row.dig(@config[:debit_value])
         }
         d['credit'] = {
-          'code' => search_code(row[@config[:credit_label]], CREDIT_DEFAULT),
+          'code' => search_code(row[@config[:label]], @config.dig(:default_credit)) || CREDIT_DEFAULT,
           'value' => row.dig(@config[:credit_value])
         }
-        d['note'] = row[@config[:note]]
+        d['note'] = Array(@config[:note]).map{ |col| row[col] }.join(' ')
+        d['x-editor'] = "LucaBook::Import/#{@dict_name}"
       end
     end
 
@@ -118,13 +134,5 @@ module LucaBook
 
       "#{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

@@ -10,77 +10,81 @@ module LucaBook
   class Journal < LucaRecord::Base
     @dirname = 'journals'
 
-    #
     # create journal from hash
     #
-    def self.create!(d)
+    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')
+      debit_amount = LucaSupport::Code.decimalize(serialize_on_key(d['debit'], 'value'))
+      credit_amount = LucaSupport::Code.decimalize(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
+      # TODO: need to sync filename & content. Limit code length for filename
+      # codes = (debit_code + credit_code).uniq
+      codes = nil
       create_record!(date, codes) do |f|
         f << debit_code
-        f << debit_amount
+        f << LucaSupport::Code.readable(debit_amount)
         f << credit_code
-        f << credit_amount
+        f << LucaSupport::Code.readable(credit_amount)
+        ['x-customer', 'x-editor'].each do |x_header|
+          f << [x_header, d[x_header]] if d.dig(x_header)
+        end
         f << []
         f << [d.dig('note')]
       end
     end
 
+    def self.update_codes(obj)
+      debit_code = serialize_on_key(obj[:debit], :code)
+      credit_code = serialize_on_key(obj[:credit], :code)
+      codes = (debit_code + credit_code).uniq.sort.compact
+      change_codes(obj[:id], codes)
+    end
+
     # define new transaction ID & write data at once
     def self.create_record!(date_obj, codes = nil)
-      gen_record_file!(@dirname, date_obj, codes) do |f|
+      create_record(nil, date_obj, codes) do |f|
         f.write CSV.generate('', col_sep: "\t", headers: false) { |c| yield(c) }
       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]
+        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
+            line.each_with_index { |amount, j| record[:debit][j][:amount] = BigDecimal(amount.to_s) }
           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
+            line.each_with_index { |amount, j| record[:credit][j][:amount] = BigDecimal(amount.to_s) }
           else
-            if line.empty?
+            if body == false && line.empty?
               record[:note] ||= []
               body = true
-              next
+            else
+              record[:note] << line.join(' ') if body
             end
-            record[:note] << line.join(' ') if body
           end
-          record[:note]&.join('\n')
         end
+        record[:note] = record[:note]&.join('\n')
       end
     end
   end