textrepo 0.5.2 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c33d87733a93d357237cf217161c5d56c37e9b48d4f9a52b9a59ec8a945f6377
-  data.tar.gz: 2c8969d2ee93dfb1f6b84e49be43eb81630e63341ad77da2fbed3c59be465b78
+  metadata.gz: b85b70f9d672503576cbce911f202dac9d00cf8af3915109f304c4c2745ce32f
+  data.tar.gz: 9ca1decf965281c4f1a34b908a919478aafc915293412b3a9fa6e4903f57de45
 SHA512:
-  metadata.gz: 711e6b19e280887f6558ecd62e39abf6146efbafe817ad9db329dd33c9fdd0e4b5d5feef4c8a246872c748142daee96518030ab378c2756dd1eb66ca40dbbade
-  data.tar.gz: 3b129941b8df7f41540a5088357bd562a11c3567635e8e26002a2a4222850b89a58d1147d0b3305b17835f0e720b86bf3a8b4ea0dccbfb01d098d00962bbe42d
+  metadata.gz: 6c24a75691c34d72dae4e33c13a22c7dc4a04539d29edcfafa31b93815b8fada5b0c7840f0c90b32b461eb925d28c32d0918dc65a5bda05592379d6f02ddd4bc
+  data.tar.gz: bc16b111bf4bc9cc7ca62942025961ac572ee892925bcce0f6a6b8c2e78ea664affbbcb18d79832cd4168fcaf62b57410f0c058c315e600750e6e348d5541153

data/CHANGELOG.md

@@ -7,8 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 ## [Unreleased]
 Nothing to record here.
 
+## [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
+- Add a feature for `Repository#update` to keep timestamp unchanged
+  - add the third argument as:
+    - `Repository#update(timestamp, text, keep_stamp = false)`
+
+## [0.5.3] - 2020-11-03
+### 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.
@@ -16,7 +43,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/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

@@ -130,30 +130,32 @@ module Textrepo
     end
 
     ##
-    # Updates the file content in the repository.  A new timestamp
-    # will be attached to the text.
+    # Updates the file content in the repository.  A new Timestamp
+    # object will be attached to the text.  Then, returns the new
+    # Timestamp object.
+    #
+    # When true is passed as the third argument, keeps the Timestamp
+    # unchanged, though updates the content.  Then, returns the given
+    # Timestamp object.
     #
     # See the documentation of Repository#update to know about errors
     # and constraints of this method.
     #
     # :call-seq:
-    #     update(Timestamp, Array) -> Timestamp
+    #     update(Timestamp, Array, true or false) -> Timestamp
 
-    def update(timestamp, text)
+    def update(timestamp, text, keep_stamp = false)
       raise EmptyTextError if text.empty?
       raise MissingTimestampError, timestamp unless exist?(timestamp)
 
       # does nothing if given text is the same in the repository one
       return timestamp if read(timestamp) == text
 
-      # the text must be stored with the new timestamp
-      new_stamp = Timestamp.new(Time.now)
-      write_text(abspath(new_stamp), text)
-
-      # delete the original text file in the repository
-      FileUtils.remove_file(abspath(timestamp))
+      stamp = keep_stamp ? timestamp : Timestamp.new(Time.now)
+      write_text(abspath(stamp), text)
+      FileUtils.remove_file(abspath(timestamp)) unless keep_stamp
 
-      new_stamp
+      stamp
     end
 
     ##
@@ -188,7 +190,7 @@ module Textrepo
           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
@@ -197,10 +199,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
@@ -268,7 +270,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,20 +317,7 @@ module Textrepo
     def invoke_searcher_for_entries(searcher, pattern, entries)
       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
@@ -338,7 +327,7 @@ module Textrepo
         files = find_files(entries)
         o, s = Open3.capture2(searcher, *find_searcher_options(searcher),
                               pattern, *files)
-        if s.success? && (! o.empty)
+        if s.success? && (! o.empty?)
           output += o.lines.map(&:chomp)
         end
       end
@@ -347,14 +336,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
@@ -44,11 +46,16 @@ module Textrepo
 
     ##
     # Updates the content with given text in the repository, which is
-    # associated to the given timestamp.  Returns the timestamp newly
-    # generated during the execution.
+    # associated to the given Timestamp object.  Returns the Timestamp
+    # newly generated during the execution.
+    #
+    # When true is passed as the third argument, keeps the Timestamp
+    # unchanged, though updates the content.  Then, returns the given
+    # Timestamp object.
     #
-    # If the given Timestamp is not existed as a Timestamp attached to
-    # text in the repository, raises MissingTimestampError.
+    # If the given Timestamp object is not existed as a Timestamp
+    # attached to text in the repository, raises
+    # MissingTimestampError.
     #
     # If the given text is empty, raises EmptyTextError.
     #
@@ -56,9 +63,9 @@ module Textrepo
     # does nothing.  Returns the given timestamp itself.
     #
     # :call-seq:
-    #     update(Timestamp, Array) -> Timestamp
+    #     update(Timestamp, Array, true or false) -> Timestamp
 
-    def update(timestamp, text); timestamp; end
+    def update(timestamp, text, keep_stamp = false); timestamp; end
 
     ##
     # Deletes the content in the repository, which is associated to
@@ -120,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
@@ -79,7 +332,8 @@ module Textrepo
         raise InvalidTimestampStringError, stamp_str 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
       end
 
       ##
@@ -97,7 +351,7 @@ module Textrepo
         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 => e
+        rescue InvalidTimestampStringError, ArgumentError => _
           emsg = if stamp_str.nil?
             "(nil)"
           elsif stamp_str.empty?
@@ -108,7 +362,7 @@ module Textrepo
           raise InvalidTimestampStringError, emsg
         end
       end
-
     end
+
   end
 end

data/lib/textrepo/version.rb

@@ -1,3 +1,3 @@
 module Textrepo
-  VERSION = '0.5.2'
+  VERSION = '0.5.7'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: textrepo
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.7
 platform: ruby
 authors:
 - mnbi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-03 00:00:00.000000000 Z
+date: 2020-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler