textrepo 0.5.4 → 0.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa38f5fbd3d1fd393eeb4ac200d1c051d8ff082cd92beaf0ab1b3756efd79e92
-  data.tar.gz: 70107459347c9685f722a4aa2367c1f04ec3257c12c489a1436d242e2f322f4f
+  metadata.gz: 9e4c8bee5a07bd1bd578fa838c0897358a7436c76246e672f555b7cc88540323
+  data.tar.gz: 2e7894038fdf7d8e3ffde5993d37d83b574861195e4df1bbc3494bae26937dc0
 SHA512:
-  metadata.gz: 19e12a6e1ac352a005aca887e887089a8daa8ae8fa0573e3d640803f19950747addd52ed77ddb9da9534f7b9596cc125917c9892ea2a14a031aaae33df753e01
-  data.tar.gz: 3c304dbd6330719398ee377183ac26f29ffdfa89b279ff12fac795e9ad664e7b3b249c8f79d36e3bae215e7e114064dd01d3bb23b6652cd2147c8c09382d01ff
+  metadata.gz: bc3ada372e37db9a400c69c7fc5cbfbb59fb2e54878cc5d51e51f31ae6769fd79ef6e4871e1a27c1f3901442aae4c3e683722fa957a4a714f96bdbbf133693b5
+  data.tar.gz: 11b86ca186db89e6c68909be0dfd0a1fc1b27203fec77bad6f6b3a93f69328eff83b7796a458eb4e8a9c6fad0febed554571f828eea68c7a1c9cf582d64bcfce

data/.github/workflows/main.yml

@@ -0,0 +1,18 @@
+name: Build
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.0.0
+    - name: Run the default task
+      run: |
+        gem install bundler -v 2.2.3
+        bundle install
+        bundle exec rake

data/CHANGELOG.md

@@ -5,7 +5,39 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
-Nothing to record here.
+
+## [0.5.9] - 2021-05-25
+### Fixed
+- Fix issue #54: add check argument in some methods.
+- Fix issue #52: remove trailing spaces.
+
+### Changed
+- Update copyright year in `LICENSE`. (#53)
+- Use GitHub/Actions instead of Travis-CI.
+
+## [0.5.8] - 2021-03-23
+### Add
+- Add a section to describe about **text** into `README.md`.
+
+### Fixed
+- Fix issue #49: Timestamp.parse_s will cause a crash.
+
+## [0.5.7] - 2020-11-16
+### Fixed
+- Fix issue #47: mmdd pattern matches incorrectly (`#entries`).
+
+## [0.5.6] - 2020-11-11
+### Add
+- Change `Repository` to enumerable.
+  - add `#each` method to `Repository`, then include `Enumerable`.
+- Add "-H" option to some searcher default options.
+
+## [0.5.5] - 2020-11-10
+### Add
+- Add more methods for `Timestamp` class.
+  - most of them are delegated to Time class
+  - some of them are useful to manipulate `Timestamp` object as
+    `String`.
 
 ## [0.5.4] - 2020-11-05
 ### Add
@@ -14,11 +46,11 @@ Nothing to record here.
     - `Repository#update(timestamp, text, keep_stamp = false)`
 
 ## [0.5.3] - 2020-11-03
-### Changed
+### Fixed
 - Fix issue #38: fix typo in code for FileSystemRepository.
 
 ## [0.5.2] - 2020-11-03
-### Changed
+### Fixed
 - Fix issue #34:
   - fix FileSystemRepository#entries to accept "yyyymo" pattern as a
     Timestamp pattern.
@@ -26,7 +58,7 @@ Nothing to record here.
 - Fix issue #31: unfriendly error message of Timestamp.parse_s.
 
 ## [0.5.1] - 2020-11-02
-### Changed
+### Fixed
 - Fix issue #28.
   - Modify `Repository#update` to do nothing when the given text is
     identical to the one in the repository.

data/{LICENSE.txt → LICENSE}

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+MIT License
 
-Copyright (c) 2020 mnbi
+Copyright (c) 2020, 2021 mnbi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,13 +9,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,6 +1,7 @@
 # Textrepo
 
-[![Build Status](https://travis-ci.org/mnbi/textrepo.svg?branch=main)](https://travis-ci.org/mnbi/textrepo)
+[![Build Status](https://github.com/mnbi/textrepo/workflows/Build/badge.svg)](https://github.com/mnbi/textrepo/actions?query=workflow%3A"Build")
+[![CodeFactor](https://www.codefactor.io/repository/github/mnbi/textrepo/badge)](https://www.codefactor.io/repository/github/mnbi/textrepo)
 
 Textrepo is a repository to store a note with a timestamp.  Each note
 in the repository operates with the associated timestamp.
@@ -61,6 +62,32 @@ stamps.each { |stamp|
 Also see `examples` directory.  There is a small tool to demonstrate
 how to use `textrepo`.
 
+## What is TEXT?
+
+In macOS (or similar unix OS), text is a date stored into a regular
+file.  Its characteristics are;
+
+- a character stream coded in some encoding system (such UTF-8),
+- divided into multiple physical lines with newline character (`\n`).
+
+In `textrepo` and its client program, a **text** is usually generated
+from a text file mentioned above.  It is;
+
+- a character stream coded in UTF-8,
+- consists of multiple logical lines (each of them does not contain a
+  newline character).
+
+That is, newline characters are removed when text is read from a file
+and added appropriately when it is written into a file.
+
+So, **text** is represented with Ruby objects as follows:
+
+- **Text** is represented with an `Array` object which contains
+  multiple `String` objects.
+- A `String` object represents a **logical line** of **text**.
+- Each `String` does not contain a newline character.
+- An empty string ("") represents a empty line.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/examples/rbnotes/lib/rbnotes/commands.rb

@@ -43,14 +43,8 @@ USAGE
         def execute(_, conf)
           name = conf[:repository_name]
           base = conf[:repository_base]
-          type = conf[:repository_type]
 
-          puts case type
-               when :file_system
-                 "#{base}/#{name}"
-               else
-                 "#{base}/#{name}"
-               end
+          puts "#{base}/#{name}"
         end
       end
 

data/examples/rbnotes/lib/rbnotes/commands/import.rb

@@ -17,7 +17,7 @@ module Rbnotes
           begin
             repo.create(stamp, content)
             break               # success to create a note
-          rescue Textrepo::DuplicateTimestampError => e
+          rescue Textrepo::DuplicateTimestampError => _
             puts "A text with the timestamp [%s] has been already exists" \
                  " in the repository." % stamp
 
@@ -38,7 +38,7 @@ module Rbnotes
               puts "Try to create a note again with a new " \
                    "timestamp [%s]." % stamp
             end
-          rescue Textrepo::EmptyTextError => e
+          rescue Textrepo::EmptyTextError => _
             puts "... aborted."
             puts "The specified file is empyt."
             exit 1              # error

data/examples/rbnotes/lib/rbnotes/commands/list.rb

@@ -36,7 +36,7 @@ module Rbnotes
       prefix = '# '
       subject = prefix + subject.lstrip if subject[0, 2] != prefix
 
-      ts_part = "#{timestamp_str}    "[0..(TIMESTAMP_STR_MAX_WIDTH - 1)] 
+      ts_part = "#{timestamp_str}    "[0..(TIMESTAMP_STR_MAX_WIDTH - 1)]
       sj_part = truncate_str(subject, subject_width)
 
       ts_part + delimiter + sj_part

data/lib/textrepo/error.rb

@@ -22,15 +22,26 @@ module Textrepo
 
   # :stopdoc:
   module ErrMsg
-    UNKNOWN_REPO_TYPE   = 'unknown type for repository: %s'
-    DUPLICATE_TIMESTAMP = 'duplicate timestamp: %s'
-    EMPTY_TEXT          = 'empty text'
-    MISSING_TIMESTAMP   = 'missing timestamp: %s'
+    ARGUMENT_RANGE      = "argument out of range: %s"
+    UNKNOWN_REPO_TYPE   = "unknown type for repository: %s"
+    DUPLICATE_TIMESTAMP = "duplicate timestamp: %s"
+    EMPTY_TEXT          = "empty text"
+    MISSING_TIMESTAMP   = "missing timestamp: %s"
     INVALID_TIMESTAMP_STRING = "invalid string as timestamp: %s"
     INVALID_SEARCH_RESULT = "invalid result by searcher: %s"
   end
   # :startdoc:
 
+  ##
+  # An error raised if argument is out of range for Timestamp class.
+
+  class ArgumentRangeError < Error
+    def initialize(arg)
+      super(ErrMsg::ARGUMENT_RANGE % arg)
+    end
+  end
+
+
   ##
   # An error raised if unknown type was specified as the repository
   # type.

data/lib/textrepo/file_system_repository.rb

@@ -62,7 +62,7 @@ module Textrepo
     #
     # The root path of the repository looks like the following:
     # - conf[:repository_base]/conf[:repository_name]
-    # 
+    #
     # Default values are set when `:repository_name` and `:default_extname`
     # were not defined in `conf`.
     #
@@ -89,7 +89,7 @@ module Textrepo
       super
       base = conf[:repository_base]
       @name ||= FAVORITE_REPOSITORY_NAME
-      @path = File.expand_path("#{name}", base)
+      @path = File.expand_path(name, base)
       FileUtils.mkdir_p(@path)
       @extname = conf[:default_extname] || FAVORITE_EXTNAME
       @searcher = find_searcher(conf[:searcher])
@@ -181,16 +181,19 @@ module Textrepo
     #     entries(String = nil) -> Array of Timestamp instances
 
     def entries(stamp_pattern = nil)
+      size = stamp_pattern.to_s.size
+      return [] if size > 0 and !(/\A[\d_]+\Z/ === stamp_pattern)
+
       results = []
 
-      case stamp_pattern.to_s.size
+      case size
       when "yyyymoddhhmiss_lll".size
         stamp = Timestamp.parse_s(stamp_pattern)
         if exist?(stamp)
           results << stamp
         end
       when 0, "yyyymoddhhmiss".size, "yyyymodd".size, "yyyymo".size
-        results += find_entries(stamp_pattern)
+        results += find_entries("#{stamp_pattern}*")
       when 4                    # "yyyy" or "modd"
         pat = nil
         # The following distinction is practically correct, but not
@@ -199,10 +202,10 @@ module Textrepo
         # any text (I believe...).
         if stamp_pattern.to_i > 1231
           # yyyy
-          pat = stamp_pattern
+          pat = "#{stamp_pattern}*"
         else
           # modd
-          pat = "*#{stamp_pattern}"
+          pat = "????#{stamp_pattern}*"
         end
         results += find_entries(pat)
       end
@@ -270,7 +273,7 @@ module Textrepo
     end
 
     def find_entries(stamp_pattern)
-      Dir.glob("#{@path}/**/#{stamp_pattern}*.#{@extname}").map { |e|
+      Dir.glob("#{@path}/**/#{stamp_pattern}.#{@extname}").map { |e|
         begin
           Timestamp.parse_s(timestamp_str(e))
         rescue InvalidTimestampStringError => _
@@ -315,22 +318,10 @@ module Textrepo
     # one file.
 
     def invoke_searcher_for_entries(searcher, pattern, entries)
+      return [] if entries.empty?
       output = []
 
-      num_of_entries = entries.size
-      if num_of_entries == 1
-        # If the search taget is one file, the output needs special
-        # treatment.
-        file = abspath(entries[0])
-        o, s = Open3.capture2(searcher, *find_searcher_options(searcher),
-                              pattern, file)
-        if s.success? && (! o.empty?)
-          output += o.lines.map { |line|
-            # add filename at the beginning of the search result line
-            [file, line.chomp].join(":")
-          }
-        end
-      elsif num_of_entries > LIMIT_OF_FILES
+      if entries.size > LIMIT_OF_FILES
         output += invoke_searcher_for_entries(searcher, pattern, entries[0..(LIMIT_OF_FILES - 1)])
         output += invoke_searcher_for_entries(searcher, pattern, entries[LIMIT_OF_FILES..-1])
       else
@@ -349,14 +340,16 @@ module Textrepo
     end
 
     SEARCHER_OPTS = {
-      # case insensitive, print line number, recursive search, work as egrep
-      "grep"   => ["-i", "-n", "-R", "-E"],
-      # case insensitive, print line number, recursive search
-      "egrep"  => ["-i", "-n", "-R"],
-      # case insensitive, print line number, recursive search, work as gegrep
-      "ggrep"  => ["-i", "-n", "-R", "-E"],
-      # case insensitive, print line number, recursive search
-      "gegrep" => ["-i", "-n", "-R"],
+      # grep option meaning:
+      # - "-i": case insensitive,
+      # - "-n": print line number,
+      # - "-H": print file name,
+      # - "-R": recursive search,
+      # - "-E": work as egrep
+      "grep"   => ["-i", "-n", "-H", "-R", "-E"],
+      "egrep"  => ["-i", "-n", "-H", "-R"],
+      "ggrep"  => ["-i", "-n", "-H", "-R", "-E"],
+      "gegrep" => ["-i", "-n", "-H", "-R"],
       # smart case, print line number, no color
       "rg"     => ["-S", "-n", "--no-heading", "--color", "never"],
     }

data/lib/textrepo/repository.rb

@@ -1,6 +1,8 @@
 module Textrepo
   class Repository
 
+    include Enumerable
+
     ##
     # Repository type.  It specifies which concrete repository class
     # will instantiated.  For example, the type `:file_system` specifies
@@ -125,6 +127,65 @@ module Textrepo
 
     def search(pattern, stamp_pattern = nil); []; end
 
+    ##
+    # Calls the given block once for each pair of timestamp and text
+    # in self, passing those pair as parameter.  Returns the
+    # repository itself.
+    #
+    # If no block is given, an Enumerator is returned.
+
+    def each(&block)
+      if block.nil?
+        entries.lazy.map { |timestamp| pair(timestamp) }.to_enum(:each)
+      else
+        entries.each { |timestamp| yield pair(timestamp) }
+        self
+      end
+    end
+
+    alias each_pair each
+
+    ##
+    # Calls the given block once for each timestamp in self, passing
+    # the timestamp as a parameter.  Returns the repository itself.
+    #
+    # If no block is given, an Enumerator is returned.
+
+    def each_key(&block)
+      if block.nil?
+        entries.to_enum(:each)
+      else
+        entries.each(&block)
+      end
+    end
+
+    alias each_timestamp each_key
+
+    ##
+    # Calls the given block once for each timestamp in self, passing
+    # the text as a parameter.  Returns the repository itself.
+    #
+    # If no block is given, an Enumerator is returned.
+
+    def each_value(&block)
+      if block.nil?
+        entries.lazy.map { |timestamp| read(timestamp) }.to_enum(:each)
+      else
+        entries.each { |timestamp| yield read(timestamp) }
+      end
+    end
+
+    alias each_text each_value
+
+    # :stopdoc:
+
+    private
+
+    def pair(timestamp)
+      [timestamp, read(timestamp)]
+    end
+
+    # :startdoc:
   end
 
   require_relative 'file_system_repository'

data/lib/textrepo/timestamp.rb

@@ -1,3 +1,5 @@
+require "forwardable"
+
 module Textrepo
   ##
   # Timestamp is generated from a Time object.  It converts a time to
@@ -18,6 +20,7 @@ module Textrepo
 
   class Timestamp
     include Comparable
+    extend Forwardable
 
     ##
     # Time object which generates the Timestamp object.
@@ -29,16 +32,28 @@ module Textrepo
 
     attr_reader :suffix
 
+    ##
+    # String object which is regarded as a value of Timestamp object.
+    # The value is generated from @time and @suffix.
+
+    attr_reader :str
+
     ##
     # Creates a Timestamp object from a Time object.  In addition, an
     # Integer can be passed as a suffix use.
     #
+    # Since Textrepo adapts 1 second as the time resolution, the
+    # subsec part of a given time will be ignored.
+    #
     # :call-seq:
     #   new(Time, Integer = nil) -> Timestamp
 
     def initialize(time, suffix = nil)
-      @time = time
+      raise ArgumentRangeError, suffix unless is_valid_suffix?(suffix)
+      parts = [:year, :mon, :day, :hour, :min, :sec].map{ |s| time.send(s) }
+      @time = Time.new(*parts)
       @suffix = suffix
+      @str = time_to_str(@time, @suffix)
     end
 
     def <=>(other)              # :nodoc:
@@ -51,19 +66,257 @@ module Textrepo
     end
 
     ##
-    # Generate an obvious time string.
+    # Generates an obvious time string.
     #
     #    %Y   %m %d %H %M %S  suffix
     #   "2020-12-30 12:34:56  (0 | nil)" -> "20201230123456"
     #   "2020-12-30 12:34:56  (7)"       -> "20201230123456_007"
 
     def to_s
+      @str
+    end
+
+    alias to_str to_s
+
+    # :stopdoc:
+
+    # delegators to Time object
+
+    def_instance_delegators :@time, :year, :mon, :day, :hour, :min, :sec
+    def_instance_delegators :@time, :wday, :monday?, :tuesday?, :wednesday?, :thursday?, :friday?, :saturday?, :sunday?
+    def_instance_delegators :@time, :asctime, :ctime, :strftime
+    def_instance_delegators :@time, :subsec, :nsec, :usec
+    def_instance_delegators :@time, :tv_nsec, :tv_sec, :tv_usec
+    def_instance_delegators :@time, :to_f, :to_i, :to_r
+    def_instance_delegators :@time, :yday, :mday
+    def_instance_delegators :@time, :month
+
+    # :startdoc:
+
+    def hash                    # :nodoc:
+      @str[0, 14].to_i * 1000 + @suffix.to_i
+    end
+
+    def eql?(other)             # :nodoc:
+      other.is_a?(Timestamp) && @time == other.time && @suffix == other.suffix
+    end
+
+    ##
+    # Returns a new Timestamp object which is given seconds ahead.
+    # Even if the suffix is not nil, the new Timestamp object will
+    # always have nil as its suffix.
+    #
+    # :call-seq:
+    #     +(Integer) -> Timestamp
+
+    def +(seconds)
+      Timestamp.new(@time + seconds, nil)
+    end
+
+    ##
+    # Returns difference of seconds between self and an argument.  If
+    # the argument is an Integer object, returns a new Timestamp
+    # object which is the given seconds behind.
+    #
+    # Even if the suffix is not nil, the new Timestamp object will
+    # always have nil as its suffix.
+    #
+    # :call-seq:
+    #     -(Time) -> Float
+    #     -(Timetamp) -> Float
+    #     -(Integer) -> Timestamp
+
+    def -(arg)
+      case arg
+      when Time
+        @time - arg
+      when Timestamp
+        @time - arg.time
+      when Integer
+        Timestamp.new(@time - arg, nil)
+      when NilClass
+        raise TypeError, "can't convert nil into an exact number"
+      else
+        raise ArgumentError, arg
+      end
+    end
+
+    ##
+    # Generates an array contains components of the Timestamp object.
+    # Components means "year", "mon", "day", "hour", "min", "sec", and
+    # "suffix".
+
+    def to_a
+      a = [:year, :mon, :day, :hour, :min, :sec, :suffix].map { |s| self.send(s) }
+      a.delete_at(-1) if a[-1].nil?
+      a
+    end
+
+    # :stopdoc:
+
+    # delegators to String object
+
+    def_instance_delegators :@str, :size, :length
+    def_instance_delegators :@str, :include?, :match, :match?
+
+    # :startdoc:
+
+    ##
+    # Returns a character or sub-string specified with args.
+    #
+    # Following type of objects could be used as args:
+    #
+    # - Integer          : specifies an index
+    # - Integer, Integer : specified an start index and length of sub-string
+    # - Range            : specified range of sub-string
+    # - Symbol           : specified a type of part
+    #
+    # Following symbols could be specified:
+    #
+    # - :year
+    # - :mon, or :month
+    # - :day
+    # - :hour
+    # - :min
+    # - :sec
+    # - :suffix
+    #
+    # :call-seq:
+    #     self[nth as Integer] -> String | nil
+    #     self[nth as Integer, len as Integer] -> String | nil
+    #     self[range as Range] -> String
+    #     self[symbol as Symbol] -> String
+
+    def [](*args)
+      raise ArgumentError, "wrong number of arguments (given %s, execpted 1..2)" % args.size unless (1..2).include?(args.size)
+
+      arg = args[0]
+      case arg
+      when Symbol, String
+        key = arg.to_sym
+        if key == :suffix
+          @suffix.nil? ? nil : FMTSTRS[key] % @suffix
+        elsif FMTSTRS.keys.include?(key)
+          @time.strftime(FMTSTRS[key])
+        else
+          nil
+        end
+      else
+        @str[*args]
+      end
+    end
+
+    alias slice []
+
+    ##
+    # Returns a Timestamp object which has a next Time object.
+    #
+    # If true was passed as an argument, use incremented suffix as
+    # base instead of a next Time object.
+    #
+    # For example,
+    #
+    #     "20201110160100"     -> "20201110160101"     (false as arg)
+    #     "20201110160100"     -> "20201110160100_001" (true as arg)
+    #     "20201110160200_001" -> "20201110160201"     (false as arg)
+    #     "20201110160200_001" -> "20201110160200_002" (true as arg)
+    #
+    # If suffix was 999 before call this method, raises
+    # ArgumentRangeError.
+
+    def next(use_suffix = nil)
+      if use_suffix
+        Timestamp.new(@time, increase_suffix(@suffix.to_i, 1))
+      else
+        Timestamp.new(@time + 1, nil)
+      end
+    end
+
+    alias succ next
+
+    ##
+    # Updates the time value to a next Time destructively.  See the
+    # document for Timestamp#next for more details.
+    #
+    # If suffix was 999 before call this method, raises
+    # ArgumentRangeError.
+
+    def next!(use_suffix = nil)
+      if use_suffix
+        @suffix = increase_suffix(@suffix.to_i, 1)
+      else
+        @time += 1
+        @suffix = nil
+      end
+      @str = time_to_str(@time, @suffix)
+      self
+    end
+
+    alias succ! next!
+
+    ##
+    # Splits the timestamp string into array of time parts, such as
+    # year, month, day, hour, minute, and second.  Then, returns the
+    # array.
+    #
+    # When a block was passed, it would apply to each part of the
+    # array.  Then, returns self.
+
+    def split(_ = $;, _ = 0, &blk)
+      parts = Timestamp.split_stamp(@str)
+      if blk.nil?
+        parts
+      else
+        parts.each { |p| yield p }
+        self
+      end
+    end
+
+    # :stopdoc:
+
+    def initialize_copy(_)
+      @time = @time.dup
+      @suffix = @suffix
+      @str = @str.dup
+    end
+
+    def freeze;  @time.freeze;  @suffix.freeze;  @str.freeze;  end
+    def taint;   @time.taint;   @suffix.taint;   @str.taint;   end
+    def untaint; @time.untaint; @suffix.untaint; @str.untaint; end
+
+    private
+
+    def is_valid_suffix?(suffix)
+      suffix.nil? || (0..999).include?(suffix)
+    end
+
+    def increase_suffix(suffix, num)
+      increased = suffix + num
+      raise ArgumentRangeError, suffix unless is_valid_suffix?(increased)
+      increased
+    end
+
+    def time_to_str(time, suffix = nil)
       s = @time.strftime("%Y%m%d%H%M%S")
       s += "_#{"%03u" % @suffix}" unless @suffix.nil? || @suffix == 0
       s
     end
 
+    FMTSTRS = {
+      :year => "%Y", :mon => "%m", :month => "%m", :day => "%d",
+      :hour => "%H", :min => "%M", :sec => "%S", :suffix => "%03u",
+    }
+
+    # :startdoc:
     class << self
+
+      ##
+      # Returns a Timestamp object generated from the current time.
+
+      def now(suffix = nil)
+        Timestamp.new(Time.now, suffix)
+      end
+
       ##
       # Splits a string which represents a timestamp into components.
       # Each component represents a part of constructs to instantiate
@@ -76,10 +329,11 @@ module Textrepo
       # Raises InvalidTimestampStringError if nil was passed as an arguemnt.
 
       def split_stamp(stamp_str)
-        raise InvalidTimestampStringError, stamp_str if stamp_str.nil?
+        raise InvalidTimestampStringError, "(nil)" if stamp_str.nil?
         #    yyyy  mo    dd    hh    mi      ss      sfx
         a = [0..3, 4..5, 6..7, 8..9, 10..11, 12..13, 15..17].map {|r| stamp_str[r]}
-        a[-1].nil? ? a[0..-2] : a
+        a.delete_at(-1) if a[-1].nil?
+        a.map{|e| e || "" }
       end
 
       ##
@@ -94,21 +348,18 @@ module Textrepo
       #     parse_s("20201028163529_034") -> Timestamp
 
       def parse_s(stamp_str)
+        raise InvalidTimestampStringError, "(nil)" if stamp_str.nil?
+        raise InvalidTimestampStringError, "(empty string)" if stamp_str.empty?
+        raise InvalidTimestampStringError, stamp_str if stamp_str.size < 14
+
         begin
           ye, mo, da, ho, mi, se, sfx = split_stamp(stamp_str).map(&:to_i)
           Timestamp.new(Time.new(ye, mo, da, ho, mi, se), sfx)
-        rescue InvalidTimestampStringError, ArgumentError => _
-          emsg = if stamp_str.nil?
-            "(nil)"
-          elsif stamp_str.empty?
-            "(empty string)"
-          else
-            stamp_str
-          end
-          raise InvalidTimestampStringError, emsg
+        rescue ArgumentRangeError, ArgumentError => _
+          raise InvalidTimestampStringError, stamp_str
         end
       end
-
     end
+
   end
 end

data/lib/textrepo/version.rb

@@ -1,3 +1,3 @@
 module Textrepo
-  VERSION = '0.5.4'
+  VERSION = '0.5.9'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: textrepo
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.9
 platform: ruby
 authors:
 - mnbi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-05 00:00:00.000000000 Z
+date: 2021-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -32,11 +32,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/main.yml"
 - ".gitignore"
-- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
-- LICENSE.txt
+- LICENSE
 - README.md
 - Rakefile
 - bin/console
@@ -77,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
 summary: A repository to store text with timestamp.

data/.travis.yml

@@ -1,6 +0,0 @@
----
-language: ruby
-cache: bundler
-rvm:
-  - 2.7.2
-before_install: gem install bundler -v 2.1.4