lucarecord 0.2.14 → 0.2.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b2e7e80da19b8c0adaebc6272a05e26f66c2e6a989fa416bfd77951ac5f88a0
-  data.tar.gz: 699708346c68e5fa32105eec0d8a82aae8fd85c452f005a402f80a9ff7b19b95
+  metadata.gz: e5d79527ced912cddc0f5d33e7d557dd23fb2e2ae0ed0437f7c90eb44095469e
+  data.tar.gz: ce8fc1c4ec1264913024981a6769a36d6439d6d5b89a820bcfa7fcb6991151bb
 SHA512:
-  metadata.gz: 59217fdab9258c37ceab07e35118961ae3ac6d6d1587f84235b31169dacf8a82f968a2e8b00f0710c0f7e587836d7d4834f4bf8d2f51e5fbd6f30d1a3100ea7b
-  data.tar.gz: edbc54ec5c66e422a6975c8e53a33b32a063304d5c582ebf4f22596151d141de7d90404eaff8cdd7e8b10264f195da67803ba48a2e4426c6629d995f6cc03507
+  metadata.gz: f4f62de1a08971733954c469d2572f6aab8018379de928ab2413aca14d9123b08da67e5f85dcd8bf632c646732cf5c534f259bd83fb5eeff0d851e4d444b7e1c
+  data.tar.gz: 2ef832f91abef366760fbff0157c97c9e43a814b1df6f1c5244e0e0f7ad32db8459f2abee51fd1fd40812283b87b6b2a1140d6668b98ab98d86088d17d3bb0e4

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+## LucaRecord 0.2.19
+
+* `LucaSupport::Code.decode_id()`
+* `LucaSupport::Code.encode_term()` for multiple months search. Old `scan_term()` removed.
+
+## LucaRecord 0.2.18
+
+* `find()`, `create()`, `save()` now supports both of uuid / historical records. If specified `date:` keyword option to `create()`, then generate historical record. `find()`, `save()` identifies with 'id' attribute.
+
+## LucaRecord 0.2.17
+
+* Change internal number format to BigDecimal.
+* Number of Decimal is configurable through `decimal_number` in config.yml(default = 2). `country` setting can also affect.

data/lib/luca_record.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require 'luca_support'
+require 'luca_support/config'
 require 'luca_record/version'
 
 module LucaRecord

data/lib/luca_record/dict.rb

@@ -14,13 +14,13 @@ module LucaRecord
     include LucaSupport::Code
 
     def initialize(file = @filename)
-      @path = file
-      #@path = dict_path(file)
+      #@path = file
+      @path = self.class.dict_path(file)
       set_driver
     end
 
     def search(word, default_word = nil)
-      res = max_score_code(word)
+      res = max_score_code(word.gsub(/[[:space:]]/, ''))
       if res[1] > 0.4
         res[0]
       else
@@ -65,7 +65,7 @@ module LucaRecord
         config[:type] ||= 'invalid'
         config[:debit_value] = @config['debit_value'].to_i if @config.dig('debit_value')
         config[:credit_value] = @config['credit_value'].to_i if @config.dig('credit_value')
-        config[:note] = @config['note'].to_i if @config.dig('note')
+        config[:note] = @config['note'] if @config.dig('note')
         config[:encoding] = @config['encoding'] if @config.dig('encoding')
 
         config[:year] = @config['year'] if @config.dig('year')

data/lib/luca_record/io.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'bigdecimal'
 require 'csv'
 require 'date'
 require 'fileutils'
@@ -20,24 +21,24 @@ module LucaRecord # :nodoc:
     end
 
     module ClassMethods
-      #-----------------------------------------------------------------
+      # ----------------------------------------------------------------
       # :section: Query Methods
       # Provide sematic search interfaces.
       # <tt>basedir</tt> is set by class instance variable <tt>@dirname</tt>
       # of each concrete class.
-      #-----------------------------------------------------------------
+      # ----------------------------------------------------------------
 
       # find ID based record. Support uuid and encoded date.
       def find(id, basedir = @dirname)
-        return enum_for(:find, id, basedir) unless block_given?
+        return enum_for(:find, id, basedir).first unless block_given?
 
         if id.length >= 40
           open_hashed(basedir, id) do |f|
             yield load_data(f)
           end
-        elsif id.length >= 9
-          # TODO: need regexp match for more flexible coding(after AD9999)
-          open_records(basedir, id[0, 5], id[5, 6]) do |f, path|
+        elsif id.length >= 7
+          parts = id.split('/')
+          open_records(basedir, parts[0], parts[1]) do |f, path|
             yield load_data(f, path)
           end
         else
@@ -53,8 +54,22 @@ module LucaRecord # :nodoc:
       def asof(year, month = nil, day = nil, basedir = @dirname)
         return enum_for(:search, year, month, day, nil, basedir) unless block_given?
 
-        search(year, month, day, nil, basedir) do |data, path|
-          yield data, path
+        search(year, month, day, nil, basedir) { |data, path| yield data, path }
+      end
+
+      # scan ranging data on multiple months
+      #
+      def term(start_year, start_month, end_year, end_month, code = nil, basedir = @dirname)
+        return enum_for(:term, start_year, start_month, end_year, end_month, code, basedir) unless block_given?
+
+        LucaSupport::Code.encode_term(start_year, start_month, end_year, end_month).each do |subdir| 
+          open_records(basedir, subdir, nil, code) do |f, path|
+            if @record_type == 'raw'
+              yield f, path
+            else
+              yield load_data(f, path)
+            end
+          end
         end
       end
 
@@ -78,65 +93,117 @@ module LucaRecord # :nodoc:
       def all(basedir = @dirname)
         return enum_for(:all, basedir) unless block_given?
 
-        open_all(basedir) do |f| 
+        open_all(basedir) do |f|
           yield load_data(f)
         end
       end
 
-      #-----------------------------------------------------------------
+      # ----------------------------------------------------------------
       # :section: Write Methods
       # <tt>basedir</tt> is set by class instance variable <tt>@dirname</tt>
       # of each concrete class.
-      #-----------------------------------------------------------------
-
-      # create hash based record
-      def create(obj, basedir = @dirname)
-        id = LucaSupport::Code.issue_random_id
-        obj['id'] = id
-        open_hashed(basedir, id, 'w') do |f|
-          f.write(YAML.dump(obj.sort.to_h))
-        end
-        id
-      end
+      # ----------------------------------------------------------------
 
-      # define new transaction ID & write data at once
-      def create_record!(obj, date_obj, codes = nil, basedir = @dirname)
-        gen_record_file!(basedir, date_obj, codes) do |f|
-          f.write(YAML.dump(obj.sort.to_h))
+      # create record both of uuid/date identified.
+      #
+      def create(obj, date: nil, codes: nil, basedir: @dirname)
+        validate_keys(obj)
+        if date
+          create_record(obj, date, codes, basedir)
+        else
+          obj['id'] = LucaSupport::Code.issue_random_id
+          open_hashed(basedir, obj['id'], 'w') do |f|
+            f.write(YAML.dump(LucaSupport::Code.readable(obj.sort.to_h)))
+          end
+          obj['id']
         end
       end
 
       def prepare_dir!(basedir, date_obj)
-        dir_name = (Pathname(basedir) + encode_dirname(date_obj)).to_s
+        dir_name = (Pathname(basedir) + LucaSupport::Code.encode_dirname(date_obj)).to_s
         FileUtils.mkdir_p(dir_name) unless Dir.exist?(dir_name)
         dir_name
       end
 
       def add_status!(id, status, basedir = @dirname)
         path = abs_path(basedir) / id2path(id)
-        origin = YAML.load_file(path, {})
+        origin = YAML.load_file(path, **{})
         newline = { status => DateTime.now.to_s }
         origin['status'] = [] if origin['status'].nil?
         origin['status'] << newline
         File.write(path, YAML.dump(origin.sort.to_h))
       end
 
-      #-----------------------------------------------------------------
+      # update file with obj['id']
+      def save(obj, basedir = @dirname)
+        if obj['id'].nil?
+          create(obj, basedir)
+        else
+          validate_keys(obj)
+          if obj['id'].length < 40
+            parts = obj['id'].split('/')
+            raise 'invalid ID' if parts.length != 2
+
+            open_records(basedir, parts[0], parts[1], nil, 'w') do |f, path|
+              f.write(YAML.dump(LucaSupport::Code.readable(obj.sort.to_h)))
+            end
+          else
+            open_hashed(basedir, obj['id'], 'w') do |f|
+              f.write(YAML.dump(LucaSupport::Code.readable(obj.sort.to_h)))
+            end
+          end
+        end
+        obj['id']
+      end
+
+      # delete file by id
+      def delete(id, basedir = @dirname)
+        FileUtils.rm(Pathname(abs_path(basedir)) / id2path(id))
+        id
+      end
+
+      # change filename with new code set
+      #
+      def change_codes(id, new_codes, basedir = @dirname)
+        raise 'invalid id' if id.split('/').length != 2
+
+        newfile = new_codes.empty? ? id : id + '-' + new_codes.join('-')
+        Dir.chdir(abs_path(basedir)) do
+          origin = Dir.glob("#{id}*")
+          raise 'duplicated files' if origin.length != 1
+
+          File.rename(origin.first, newfile)
+        end
+        newfile
+      end
+
+      # ----------------------------------------------------------------
       # :section: Path Utilities
-      #-----------------------------------------------------------------
+      # ----------------------------------------------------------------
 
-      # convert ID to file path. Normal argument is as follows:
+      # Convert ID to file directory/filename path.
+      # 1st element of Array is used as directory, the others as filename.
+      # String without '/' is converted as git-like structure.
+      # Normal argument is as follows:
       #
-      #   [2020H, V001]
-      #   "2020H/V001"
-      #   "a7b806d04a044c6dbc4ce72932867719"
+      #   ['2020H', 'V001', 'a7b806d04a044c6dbc4ce72932867719']
+      #     => '2020H/V001-a7b806d04a044c6dbc4ce72932867719'
+      #   'a7b806d04a044c6dbc4ce72932867719'
+      #     => 'a7b/806d04a044c6dbc4ce72932867719'
+      #   '2020H/V001'
+      #     => '2020H/V001'
       def id2path(id)
         if id.is_a?(Array)
-          id.join('/')
+          case id.length
+          when 0..2
+            id.join('/')
+          else
+            [id[0], id[1..-1].join('-')].join('/')
+          end
         elsif id.include?('/')
           id
         else
-          encode_hashed_path(id)
+          encode_hashed_path(id).join('/')
         end
       end
 
@@ -150,10 +217,6 @@ module LucaRecord # :nodoc:
         end
       end
 
-      def encode_dirname(date_obj)
-        date_obj.year.to_s + LucaSupport::Code.encode_month(date_obj)
-      end
-
       # test if having required dirs/files under exec path
       def valid_project?(path = LucaSupport::Config::Pjdir)
         project_dir = Pathname(path)
@@ -166,6 +229,29 @@ module LucaRecord # :nodoc:
 
       private
 
+      # define new transaction ID & write data at once
+      # ID format is like '2020H/A001', which means record no.1 of 2020/10/10.
+      # Any data format can be written with block.
+      #
+      def create_record(obj, date_obj, codes = nil, basedir = @dirname)
+        FileUtils.mkdir_p(abs_path(basedir)) unless Dir.exist?(abs_path(basedir))
+        subdir = "#{date_obj.year}#{LucaSupport::Code.encode_month(date_obj)}"
+        filename = LucaSupport::Code.encode_date(date_obj) + new_record_id(basedir, date_obj)
+        obj['id'] = "#{subdir}/#{filename}" if obj.is_a? Hash
+        filename += '-' + codes.join('-') if codes
+        Dir.chdir(abs_path(basedir)) do
+          FileUtils.mkdir_p(subdir) unless Dir.exist?(subdir)
+            File.open(Pathname(subdir) / filename, 'w') do |f|
+              if block_given?
+                yield(f)
+              else
+                f.write(YAML.dump(LucaSupport::Code.readable(obj.sort.to_h)))
+              end
+            end
+        end
+        "#{subdir}/#{filename}"
+      end
+
       # open records with 'basedir/month/date-code' path structure.
       # Glob pattern can be specified like folloing examples.
       #
@@ -181,6 +267,7 @@ module LucaRecord # :nodoc:
 
         file_pattern = filename.nil? ? '*' : "#{filename}*"
         Dir.chdir(abs_path(basedir)) do
+          FileUtils.mkdir_p(subdir) if mode == 'w' && !Dir.exist?(subdir)
           Dir.glob("#{subdir}*/#{file_pattern}").sort.each do |subpath|
             next if skip_on_unmatch_code(subpath, code)
 
@@ -212,6 +299,17 @@ module LucaRecord # :nodoc:
         end
       end
 
+      # parse data dir and respond existing months
+      #
+      def scan_terms(query = nil, base_dir = @dirname)
+        pattern = query.nil? ? "*" : "#{query}*"
+        Dir.chdir(abs_path(base_dir)) do
+          Dir.glob(pattern).select { |dir|
+            FileTest.directory?(dir) && /^[0-9]/.match(dir)
+          }.sort.map { |str| decode_term(str) }
+        end
+      end
+
       # Decode basic format.
       # If specific decode is needed, override this method in each class.
       #
@@ -223,18 +321,18 @@ module LucaRecord # :nodoc:
         when 'json'
         # TODO: implement JSON parse
         else
-          YAML.load(io.read)
+          LucaSupport::Code.decimalize(YAML.load(io.read)).tap { |obj| validate_keys(obj) }
         end
       end
 
-      def gen_record_file!(basedir, date_obj, codes = nil)
-        d = prepare_dir!(abs_path(basedir), date_obj)
-        filename = LucaSupport::Code.encode_date(date_obj) + new_record_id(abs_path(basedir), date_obj)
-        if codes
-          filename += codes.inject('') { |fragment, code| "#{fragment}-#{code}" }
+      def validate_keys(obj)
+        return nil unless @required
+
+        keys = obj.keys
+        [].tap do |errors|
+          @required.each { |r| errors << r unless keys.include?(r) }
+          raise "Missing keys: #{errors.join(' ')}" unless errors.empty?
         end
-        path = Pathname(d) + filename
-        File.open(path.to_s, 'w') { |f| yield(f) }
       end
 
       # TODO: replace with data_dir method
@@ -254,8 +352,10 @@ module LucaRecord # :nodoc:
 
       # AUTO INCREMENT
       def new_record_no(basedir, date_obj)
-        dir_name = (Pathname(basedir) + encode_dirname(date_obj)).to_s
-        raise 'No target dir exists.' unless Dir.exist?(dir_name)
+        raise 'No target dir exists.' unless Dir.exist?(abs_path(basedir))
+
+        dir_name = (Pathname(abs_path(basedir)) / LucaSupport::Code.encode_dirname(date_obj)).to_s
+        return 1 unless Dir.exist?(dir_name)
 
         Dir.chdir(dir_name) do
           last_file = Dir.glob("#{LucaSupport::Code.encode_date(date_obj)}*").max
@@ -287,17 +387,6 @@ module LucaRecord # :nodoc:
       end
     end
 
-    # parse data dir and respond existing months
-    #
-    def scan_terms(base_dir, query = nil)
-      pattern = query.nil? ? "*" : "#{query}*"
-      Dir.chdir(base_dir) do
-        Dir.glob(pattern).select { |dir|
-          FileTest.directory?(dir) && /^[0-9]/.match(dir)
-        }.sort.map { |str| decode_term(str) }
-      end
-    end
-
     def load_config(path = nil)
       path = path.to_s
       if File.exist?(path)

data/lib/luca_record/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LucaRecord
-  VERSION = '0.2.14'
+  VERSION = '0.2.19'
 end

data/lib/luca_support/code.rb

@@ -3,16 +3,24 @@
 require 'date'
 require 'securerandom'
 require 'digest/sha1'
+require 'luca_support/config'
 
 # implement Luca IDs convention
 module LucaSupport
   module Code
     module_function
 
+    # Parse historical id into Array of date & transaction id.
+    #
+    def decode_id(id_str)
+      m = %r(^(?<year>[0-9]+)(?<month>[A-L])/?(?<day>[0-9A-V])(?<txid>[0-9A-Z]{,3})).match(id_str)
+      ["#{m[:year]}-#{decode_month(m[:month])}-#{decode_date(m[:day])}", decode_txid(m[:txid])]
+    end
+
     def encode_txid(num)
       txmap = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
       l = txmap.length
-      txmap[num / (l**2)] + txmap[(num%(l**2)) / l] + txmap[num % l]
+      txmap[num / (l**2)] + txmap[(num % (l**2)) / l] + txmap[num % l]
     end
 
     def decode_txid(id)
@@ -44,7 +52,12 @@ module LucaSupport
       num.to_s.reverse.gsub!(/(\d{3})(?=\d)/, '\1,').reverse!
     end
 
+    # encode directory name from year and month.
     #
+    def encode_dirname(date_obj)
+      date_obj.year.to_s + encode_month(date_obj)
+    end
+
     # Month to code conversion.
     # Date, DateTime, String, Integer is valid input. If nil, returns empty String for consistency.
     #
@@ -63,6 +76,16 @@ module LucaSupport
       '0ABCDEFGHIJKL'.index(char)
     end
 
+    # Generate globbing phrase like ["2020[C-H]"] for range search.
+    #
+    def encode_term(start_year, start_month, end_year, end_month)
+      (start_year..end_year).to_a.map do |y|
+        g1 = y == start_year ? encode_month(start_month) : encode_month(1)
+        g2 = y == end_year ? encode_month(end_month) : encode_month(12)
+        "#{y}[#{g1}-#{g2}]"
+      end
+    end
+
     def decode_term(char)
       m = /^([0-9]{4})([A-La-l])/.match(char)
       [m[1].to_i, decode_month(m[2])]
@@ -72,8 +95,40 @@ module LucaSupport
       Digest::SHA1.hexdigest(SecureRandom.uuid)
     end
 
+    def decimalize(obj)
+      case obj.class.name
+      when 'Array'
+        obj.map { |i| decimalize(i) }
+      when 'Hash'
+        obj.inject({}) { |h, (k, v)| h[k] = decimalize(v); h }
+      when 'Integer'
+        BigDecimal(obj.to_s)
+      when 'String'
+        /^[0-9\.]+$/.match(obj) ? BigDecimal(obj) : obj
+      when 'Float'
+        raise 'already float'
+      else
+        obj
+      end
+    end
+
+    def readable(obj, len = LucaSupport::Config::DECIMAL_NUM)
+      case obj.class.name
+      when 'Array'
+        obj.map { |i| readable(i) }
+      when 'Hash'
+        obj.inject({}) { |h, (k, v)| h[k] = readable(v); h }
+      when 'BigDecimal'
+        parts = obj.round(len).to_s('F').split('.')
+        len < 1 ? parts.first : "#{parts[0]}.#{parts[1][0, len]}"
+      else
+        obj
+      end
+    end
+
     #
-    # convert effective/defunct data into current hash on @date
+    # convert effective/defunct data into current hash on @date.
+    # not parse nested children.
     #
     def parse_current(dat)
       {}.tap do |processed|
@@ -92,11 +147,11 @@ module LucaSupport
     #   - effective: 2020-1-1
     #     rank: 5
     #     point: 1000
-    #   => { 'effective' => 2020-1-1, 'rank' => 5, '' => 'point' => 1000 }
+    #   => { 'effective' => 2020-1-1, 'rank' => 5, 'point' => 1000 }
     #
     def take_current(dat, item)
       target = dat.dig(item)
-      if target.class.name == 'Array' && target.map(&:keys).flatten.include?('effective')
+      if target.is_a?(Array) && target.map(&:keys).flatten.include?('effective')
         latest = target
                  .filter { |a| Date.parse(a.dig('effective').to_s) < @date }
                  .max { |a, b| Date.parse(a.dig('effective').to_s) <=> Date.parse(b.dig('effective').to_s) }

data/lib/luca_support/config.rb

@@ -1,11 +1,20 @@
 # frozen_string_literal: true
 
+require 'pathname'
+require 'yaml'
+
 #
 # startup config
 #
 module LucaSupport
   module Config
     # Project top directory.
-    Pjdir = Dir.pwd.freeze
+    Pjdir = ENV['LUCA_TEST_DIR'] || Dir.pwd.freeze
+    if File.exist?(Pathname(Pjdir) / 'config.yml')
+      # DECIMAL_NUM = YAML.load_file(Pathname(Pjdir) / 'config.yml', **{})['decimal_number']
+      COUNTRY = YAML.load_file(Pathname(Pjdir) / 'config.yml', **{})['country']
+      DECIMAL_NUM ||= 0 if COUNTRY == 'jp'
+    end
+    DECIMAL_NUM ||= 2
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lucarecord
 version: !ruby/object:Gem::Version
-  version: 0.2.14
+  version: 0.2.19
 platform: ruby
 authors:
 - Chuma Takahiro
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-07 00:00:00.000000000 Z
+date: 2020-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mail
@@ -28,44 +28,44 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.17'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.17'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 12.3.3
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 12.3.3
+        version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 12.3.3
 description: 'ERP File operation framework
 
 '