textrepo 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4d26af6dd86e8b79c9e50300f8c31102bf79d5c751e175740a7225c2ca4a9b33
+  data.tar.gz: 8d398c0848c0a4b06d2a775f3cb6bf1f49489be7f5ba5d8cf7eab2aad068b5c7
+SHA512:
+  metadata.gz: ef79855cd99ebc3baea4368c00cdc4d439478cfc9733d45eee1e7a08ca005bf0dc15824cb57b46326c982e724acc762b25b722c112f19ae4f67349d575fffdcb
+  data.tar.gz: 4af657999971e6d3cef41dc5d3ef7ea1017a536b772372d38e79ffb91196c239585a0c932fe10e42f9d7ccbfee8fa477ec31bd97afa9cd4e1c31f0c894772110

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

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

data/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+
+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.4.0] - 2020-10-14
+### Added
+- Released to rubygems.org.
+
+### Changed
+- Rename the method, `Repository#notes` to `entries`.
+- Modify the instruction to install
+
+## [0.3.0] - 2020-10-11
+### Added
+- Go public onto GitHub.
+- Add an example (`rbnotes`) to demonstrate how to use `textrepo`.
+
+### Changed
+- Modify not to handle fraction of time in Timestamp.
+- Instead, Timestamp can have a suffix to distinguish 2 stamps those
+  represent the same time.
+
+## [0.2.0] - 2020-09-28
+### Changed
+- Modify to handle millisecond in Timestamp
+
+## [0.1.0] - 2020-09-23
+### Added
+- Add some target in Rakefile to run test easily.
+- Add error classes
+- Add Timestamp class, it will be an identifier of each text in the repo.
+- Add Repository class (an abstract base class for concrete repository
+  implementations)
+- Implement API for FileSystemRepository class (create/read/update/delete).
+- Add tests.

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in textrepo.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    textrepo (0.4.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.14.2)
+    rake (13.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.1)
+  minitest (~> 5.0)
+  rake (~> 13.0)
+  textrepo!
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 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
+in the Software without restriction, including without limitation the rights
+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 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.

data/README.md

@@ -0,0 +1,77 @@
+# Textrepo
+
+[![Build Status](https://travis-ci.org/mnbi/textrepo.svg?branch=main)](https://travis-ci.org/mnbi/textrepo)
+
+Textrepo is a repository to store a note with a timestamp.  Each note
+in the repository operates with the associated timestamp.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'textrepo'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install textrepo
+
+## Usage
+
+Here is a very short sample to use `textrepo`.  It will make
+`~/textrepo_sample` directory and store some text into it.
+
+``` ruby
+#!/usr/bin/env ruby
+
+require "textrepo"
+
+conf = {
+  :repository_type => :file_system,
+  :repository_name => "textrepo_sample",
+  :repository_base => File.expand_path("~"),
+}
+
+repo = Textrepo.init(conf)
+
+t0 = Time.now
+
+stamps = []
+stamps << repo.create(Textrepo::Timestamp.new(t0), ["jan", "feb", "mar"])
+stamps << repo.create(Textrepo::Timestamp.new(t0, 1), ["apr", "may", "jun"])
+stamps << repo.create(Textrepo::Timestamp.new(t0, 2), ["jul", "aug", "sep"])
+stamps << repo.create(Textrepo::Timestamp.new(t0, 3), ["oct", "nov", "dec"])
+
+entries = repo.notes
+puts entries
+
+stamps.each { |stamp|
+  text = repo.read(stamp)
+  puts "----"
+  puts stamp
+  puts text
+}
+```
+
+Also see `examples` directory.  There is a small tool to demonstrate
+how to use `textrepo`.
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mnbi/textrepo.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,37 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test
+
+desc 'Setup test data'
+task :setup_test do
+  print "Setting up to execute tests..."
+  load('test/fixtures/setup_test_repo.rb', true)
+  puts "done."
+end
+
+task test: [:setup_test, :clean_sandbox]
+
+require "fileutils"
+
+desc "Clean up test/sandbox"
+task :clean_sandbox do
+  sandbox = File.expand_path('test/sandbox', __dir__)
+  entries = Dir.entries(sandbox).filter_map { |e|
+    File.expand_path(e, sandbox) unless e == '.' or e == '..'
+  }
+  entries.each { |e|
+    next if File.basename(e) == '.gitkeep'
+    FileUtils.remove_entry_secure(e) if FileTest.exist?(e)
+  }
+end
+
+task :clobber => :clean_sandbox
+CLOBBER << 'test/fixtures/notes'
+CLOBBER << 'test/fixtures/test_repo'

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "textrepo"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/rbnotes/lib/rbnotes.rb

@@ -0,0 +1,8 @@
+require "textrepo"
+
+module Rbnotes
+  class Error < StandardError; end
+
+  require_relative "rbnotes/version"
+  require_relative "rbnotes/commands"
+end

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

@@ -0,0 +1,118 @@
+module Rbnotes
+  module Commands
+    class Command
+      def execute(args, conf)
+        Builtins::DEFAULT_CMD.new.execute(args, conf)
+      end
+    end
+
+    # Built-in commands:
+    # - repo: prints the absolute path of the repository.
+    # - conf: prints all of the current configuration settings.
+    # - stamp: converts given TIME_STR into a timestamp.
+    # - time: converts given STAMP into a time string.
+    module Builtins
+      class Help < Command
+        def execute(_, _)
+          puts <<USAGE
+usage: rbnotes [command] [args]
+
+command:
+    import FILE     : import a FILE into the repository
+    list NUM        : list NUM notes
+    show STAMP      : show the note specified with STAMP
+
+    repo            : print the repository path
+    stamp  TIME_STR : convert TIME_STR into a timestamp
+    time   STAMP    : convert STAMP into a time string
+    version         : print version
+    help            : show help
+USAGE
+        end
+      end
+
+      class Version < Command
+        def execute(_, _)
+          rbnotes_version = "rbnotes #{Rbnotes::VERSION} (#{Rbnotes::RELEASE})"
+          textrepo_version = "textrepo #{Textrepo::VERSION}"
+          puts "#{rbnotes_version} (#{textrepo_version})"
+        end
+      end
+
+      class Repo < Command
+        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
+        end
+      end
+
+      class Conf < Command
+        def execute(_, conf)
+          conf.keys.sort.each { |k|
+            puts "#{k}=#{conf[k]}"
+          }
+        end
+      end
+
+      require "time"
+
+      class Stamp < Command
+        def execute(args, _)
+          time_str = args.shift
+          unless time_str.nil?
+            puts Textrepo::Timestamp.new(::Time.parse(time_str)).to_s
+          else
+            puts "not specified TIME_STR"
+            super
+          end
+        end
+      end
+
+      class Time < Command
+        def execute(args, _)
+          stamp = args.shift
+          unless stamp.nil?
+            puts ::Time.new(*Textrepo::Timestamp.split_stamp(stamp).map(&:to_i)).to_s
+          else
+            puts "not specified STAMP"
+            super
+          end
+        end
+      end
+
+      DEFAULT_CMD = Help
+    end
+
+    DEFAULT_CMD_NAME = "help"
+
+    class << self
+      def load(cmd_name)
+        cmd_name ||= DEFAULT_CMD_NAME
+        klass_name =  cmd_name.capitalize
+
+        klass = nil
+        if Builtins.const_defined?(klass_name, false)
+          klass = Builtins::const_get(klass_name, false)
+        else
+          begin
+            require_relative "commands/#{cmd_name}"
+            klass = const_get(klass_name, false)
+          rescue LoadError => _
+            STDERR.puts "unknown command: #{cmd_name}"
+            klass = Builtins::DEFAULT_CMD
+          end
+        end
+        klass.new
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,62 @@
+module Rbnotes
+  class Commands::Import < Commands::Command
+    def execute(args, conf)
+      file = args.shift
+      unless file.nil?
+        st = File::Stat.new(file)
+        btime = st.respond_to?(:birthtime) ? st.birthtime : st.mtime
+        stamp = Textrepo::Timestamp.new(btime)
+        puts "Import [%s] (timestamp [%s]) ..." % [file, stamp]
+
+        repo = Textrepo.init(conf)
+        content = nil
+        File.open(file, "r") {|f| content = f.readlines(chomp: true)}
+
+        count = 0
+        while count <= 999
+          begin
+            repo.create(stamp, content)
+            break               # success to create a note
+          rescue Textrepo::DuplicateTimestampError => e
+            puts "A text with the timestamp [%s] has been already exists" \
+                 " in the repository." % stamp
+
+            repo_text = repo.read(stamp)
+            if content == repo_text
+              # if the content is the same to the target file,
+              # the specified file has been already imported.
+              # Then, there is nothing to do.  Just exit.
+              puts "The note [%s] in the repository exactly matches" \
+                   " the specified file." % stamp
+              puts "It seems there is no need to import the file [%s]." % file
+              exit              # normal end
+            else
+              puts "The text in the repository does not match the" \
+                   " specified file."
+              count += 1
+              stamp = Textrepo::Timestamp.new(stamp.time, count)
+              puts "Try to create a note again with a new " \
+                   "timestamp [%s]." % stamp
+            end
+          rescue Textrepo::EmptyTextError => e
+            puts "... aborted."
+            puts "The specified file is empyt."
+            exit 1              # error
+          end
+        end
+        if count > 999
+          puts "Cannot create a text into the repository with the" \
+               " specified file [%s]."  % file
+          puts "For, the birthtime [%s] is identical to some notes" \
+               " already exists in the reopsitory." % btime
+          puts "Change the birthtime of the target file, then retry."
+        else
+          puts "... Done."
+        end
+      else
+        puts "not supecified FILE"
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require "io/console/size"
+
+module Rbnotes
+  class Commands::List < Commands::Command
+    def execute(args, conf)
+      @row, @column = IO.console_size
+      max = (args.shift || @row - 3).to_i
+
+      @repo = Textrepo.init(conf)
+      notes = @repo.entries.sort{|a, b| b <=> a}
+      notes[0, max].each { |timestamp_str|
+        puts make_headline(timestamp_str)
+      }
+    end
+
+    private
+    TIMESTAMP_STR_MAX_WIDTH = "yyyymoddhhmiss_sfx".size
+    # Makes a headline with the timestamp and subject of the notes, it
+    # looks like as follows:
+    #
+    # |<------------------ console column size --------------------->|
+    # +-- timestamp ---+  +--- subject (the 1st line of each note) --+
+    # |                |  |                                          |
+    # 20101010001000_123: # I love Macintosh.                        [EOL]
+    # 20100909090909_999: # This is very very long long loooong subje[EOL]
+    #                   ++
+    #                    ^--- delimiter (2 characters)
+    #
+    # The subject part will truncate when it is long.
+    def make_headline(timestamp_str)
+
+      delimiter = ": "
+      subject_width = @column - TIMESTAMP_STR_MAX_WIDTH - delimiter.size - 1
+
+      subject = @repo.read(Textrepo::Timestamp.parse_s(timestamp_str))[0]
+      prefix = '# '
+      subject = prefix + subject.lstrip if subject[0, 2] != prefix
+
+      ts_part = "#{timestamp_str}    "[0..(TIMESTAMP_STR_MAX_WIDTH - 1)] 
+      sj_part = truncate_str(subject, subject_width)
+
+      ts_part + delimiter + sj_part
+    end
+
+    def truncate_str(str, size)
+      count = 0
+      result = ""
+      str.each_char { |c|
+        # TODO: fix
+        # This code is ugly.  It assumes that each non-ascii character
+        # always occupy the width of 2 ascii characters in a terminal.
+        # I am not sure the assumption is appropriate or not.
+        count += c.ascii_only? ? 1 : 2
+        break if count > size
+        result << c
+      }
+      result
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Rbnotes
+  class Commands::Show < Commands::Command
+    def execute(args, conf)
+      stamp_str = args.shift
+      unless stamp_str.nil?
+        repo = Textrepo.init(conf)
+        stamp = Textrepo::Timestamp.parse_s(stamp_str)
+        content = repo.read(stamp)
+
+        pager = conf[:pager]
+        unless pager.nil?
+          require 'open3'
+          Open3.pipeline_w(pager) { |stdin|
+            stdin.puts content
+            stdin.close
+          }
+        else
+          puts content
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/examples/rbnotes/lib/rbnotes/version.rb

@@ -0,0 +1,4 @@
+module Rbnotes
+  VERSION = '0.1.0'
+  RELEASE = '2020-10-02'
+end

data/examples/rbnotes/rbnotes

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
+$LOAD_PATH.unshift File.expand_path("lib", __dir__)
+
+require "rbnotes"
+
+DEBUG = true
+
+module Rbnotes
+  class App
+    def initialize
+      @conf = default_conf
+    end
+
+    def default_conf
+      {
+        :repository_type => :file_system,
+        :repository_name => DEBUG ? "sandbox/notes_dev" : "notes",
+        :repository_base => File.expand_path("~"),
+        :pager => "bat",
+      }
+    end
+
+    def run(args)
+      cmd = args.shift
+      Rbnotes::Commands.load(cmd).execute(args, @conf)
+    end
+  end
+end
+
+app = Rbnotes::App.new
+app.run(ARGV)

data/lib/textrepo.rb

@@ -0,0 +1,6 @@
+module Textrepo
+  require_relative 'textrepo/version'
+  require_relative 'textrepo/error'
+  require_relative 'textrepo/timestamp'
+  require_relative 'textrepo/repository'
+end

data/lib/textrepo/error.rb

@@ -0,0 +1,50 @@
+module Textrepo
+  class Error < StandardError; end
+
+  module ErrMsg
+    UNKNOWN_REPO_TYPE   = 'unknown type for repository: %s'
+    DUPLICATE_TIMESTAMP = 'duplicate timestamp: %s'
+    EMPTY_TEXT          = 'empty text'
+    MISSING_TIMESTAMP   = 'missing timestamp: %s'
+  end
+
+  class UnknownRepoTypeError < Error
+    def initialize(type)
+      super(ErrMsg::UNKNOWN_REPO_TYPE % type)
+    end
+  end
+
+  # Following errors might occur in repository operations:
+  # +--------------------------+---------------------+
+  # | operation (args)         | error type          |
+  # +--------------------------+---------------------+
+  # | create (timestamp, text) | Duplicate timestamp |
+  # |                          | Empty text          |
+  # +--------------------------+---------------------+
+  # | read   (timestamp)       | Missing timestamp   |
+  # +--------------------------+---------------------+
+  # | update (timestamp, text) | Mssing timestamp    |
+  # |                          | Empty text          |
+  # +--------------------------+---------------------+
+  # | delete (timestamp)       | Missing timestamp   |
+  # +--------------------------+---------------------+
+
+  class DuplicateTimestampError < Error
+    def initialize(timestamp)
+      super(ErrMsg::DUPLICATE_TIMESTAMP % timestamp)
+    end
+  end
+
+  class EmptyTextError < Error
+    def initialize
+      super(ErrMsg::EMPTY_TEXT)
+    end
+  end
+
+  class MissingTimestampError < Error
+    def initialize(timestamp)
+      super(ErrMsg::MISSING_TIMESTAMP % timestamp)
+    end
+  end
+
+end

data/lib/textrepo/file_system_repository.rb

@@ -0,0 +1,148 @@
+require 'fileutils'
+
+module Textrepo
+  # A concrete repository which uses the default file system as a storage.
+  class FileSystemRepository < Repository
+    attr_reader :path, :extname
+
+    FAVORITE_REPOSITORY_NAME = 'notes'
+    FAVORITE_EXTNAME = 'md'
+
+    # `conf` must be a Hash object.  It must hold the follwoing
+    # values:
+    #
+    # - :repository_type (:file_system)
+    # - :repository_name => basename of the root path for the repository
+    # - :repository_base => the parent directory path for the repository
+    # - :default_extname => extname for a file stored into in the repository
+    #
+    # 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`.
+    def initialize(conf)
+      super
+      base = conf[:repository_base]
+      @name ||= FAVORITE_REPOSITORY_NAME
+      @path = File.expand_path("#{name}", base)
+      FileUtils.mkdir_p(@path)
+      @extname = conf[:default_extname] || FAVORITE_EXTNAME
+    end
+
+    #
+    # repository operations
+    #
+
+    # Creates a file into the repository, which contains the specified
+    # text and is associated to the timestamp.
+    def create(timestamp, text)
+      abs = abspath(timestamp)
+      raise DuplicateTimestampError, timestamp if FileTest.exist?(abs)
+      raise EmptyTextError if text.nil? || text.empty?
+
+      write_text(abs, text)
+      timestamp
+    end
+
+    # Reads the file content in the repository.  Then, returns its
+    # content.
+    def read(timestamp)
+      abs = abspath(timestamp)
+      raise MissingTimestampError, timestamp unless FileTest.exist?(abs)
+      content = nil
+      File.open(abs, 'r') { |f|
+        content = f.readlines(chomp: true)
+      }
+      content
+    end
+
+    # Updates the file content in the repository.  A new timestamp
+    # will be attached to the text.
+    def update(timestamp, text)
+      raise EmptyTextError if text.empty?
+      org_abs = abspath(timestamp)
+      raise MissingTimestampError, timestamp unless FileTest.exist?(org_abs)
+
+      # the text must be stored with the new timestamp
+      new_stamp = Timestamp.new(Time.now)
+      new_abs = abspath(new_stamp)
+      write_text(new_abs, text)
+
+      # delete the original file in the repository
+      FileUtils.remove_file(org_abs)
+
+      new_stamp
+    end
+
+    # Deletes the file in the repository.
+    def delete(timestamp)
+      abs = abspath(timestamp)
+      raise MissingTimestampError, timestamp unless FileTest.exist?(abs)
+      content = read(timestamp)
+
+      FileUtils.remove_file(abs)
+
+      content
+    end
+
+    # Finds entries of text those timestamp matches the specified pattern.
+    def entries(stamp_pattern = nil)
+      results = []
+
+      case stamp_pattern.to_s.size
+      when "yyyymoddhhmiss_lll".size
+        stamp = Timestamp.parse_s(stamp_pattern)
+        if exist?(stamp)
+          results << stamp.to_s
+        end
+      when 0, "yyyymoddhhmiss".size, "yyyymodd".size
+        results += find_entries(stamp_pattern)
+      when 4                    # "yyyy" or "modd"
+        pat = nil
+        # The following distinction is practically correct, but not
+        # perfect.  It simply assumes that a year is greater than
+        # 1231.  For, a year before 1232 is too old for us to create
+        # any text (I believe...).
+        if stamp_pattern.to_i > 1231
+          # yyyy
+          pat = stamp_pattern
+        else
+          # modd
+          pat = "*#{stamp_pattern}"
+        end
+        results += find_entries(pat)
+      end
+
+      results
+    end
+
+    private
+    def abspath(timestamp)
+      filename = timestamp.to_pathname + ".#{@extname}"
+      File.expand_path(filename, @path)
+    end
+
+    def write_text(abs, text)
+      FileUtils.mkdir_p(File.dirname(abs))
+      File.open(abs, 'w') { |f|
+        text.each {|line| f.puts(line) }
+      }
+    end
+
+    def timestamp_str(text_path)
+      File.basename(text_path).delete_suffix(".#{@extname}")
+    end
+
+    def exist?(timestamp)
+      FileTest.exist?(abspath(timestamp))
+    end
+
+    def find_entries(stamp_pattern)
+      Dir.glob("#{@path}/**/#{stamp_pattern}*.#{@extname}").map { |e|
+        timestamp_str(e)
+      }
+    end
+
+  end
+end

data/lib/textrepo/repository.rb

@@ -0,0 +1,62 @@
+module Textrepo
+  class Repository
+    attr_reader :type, :name
+
+    def initialize(conf)
+      @type = conf[:repository_type]
+      @name = conf[:repository_name]
+    end
+
+    # Stores text data into the repository with the specified timestamp.
+    # Returns the timestamp.
+    def create(timestamp, text); timestamp; end
+
+    # Reads text data from the repository, which is associated to the
+    # timestamp.  Returns an array which contains the text.
+    def read(timestamp); []; end
+
+    # Updates the content with text in the repository, which is
+    # associated to the timestamp.  Returns the timestamp.
+    def update(timestamp, text); timestamp; end
+
+    # Deletes the content in the repository, which is associated to
+    # the timestamp.  Returns an array which contains the deleted text.
+    def delete(timestamp); []; end
+
+    # Finds all entries of text those have timestamps which mathes the
+    # specified pattern of timestamp.  Returns an array which contains
+    # timestamps.  A pattern must be one of the following:
+    #
+    #     - yyyymoddhhmiss_lll : whole stamp
+    #     - yyyymoddhhmiss     : omit millisecond part
+    #     - yyyymodd           : date part only
+    #     - yyyymo             : month and year
+    #     - yyyy               : year only
+    #     - modd               : month and day
+    #
+    # If `stamp_pattern` is omitted, the recent entries will be listed.
+    # Then, how many entries are listed depends on the implementaiton
+    # of the concrete repository class.
+    def entries(stamp_pattern = nil); []; end
+
+  end
+
+  require_relative 'file_system_repository'
+
+  # Returns an instance which derived from Textrepo::Repository class.
+  # `conf` must be a Hash object which has a value of
+  # `:repository_type` and `:repository_name` at least.  Some concrete
+  # class derived from Textrepo::Repository may require more key-value
+  # pairs in `conf`.
+  def init(conf)
+    type = conf[:repository_type]
+    klass_name = type.to_s.split(/_/).map(&:capitalize).join + "Repository"
+    if Textrepo.const_defined?(klass_name)
+      klass = Textrepo.const_get(klass_name, false)
+    else
+      raise UnknownRepoTypeError, type.nil? ? "(nil)" : type
+    end
+    klass.new(conf)
+  end
+  module_function :init
+end

data/lib/textrepo/timestamp.rb

@@ -0,0 +1,63 @@
+module Textrepo
+  class Timestamp
+    include Comparable
+
+    attr_reader :time, :suffix
+
+    # time: a Time instance
+    # suffix: an Integer instance
+    def initialize(time, suffix = nil)
+      @time = time
+      @suffix = suffix
+    end
+
+    def <=>(other)
+      result = (self.time <=> other.time)
+
+      sfx = self.suffix || 0
+      osfx = other.suffix || 0
+
+      result == 0 ? (sfx <=> osfx) : result
+    end
+
+    #  %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
+      s = @time.strftime("%Y%m%d%H%M%S")
+      s += "_#{"%03u" % @suffix}" unless @suffix.nil? || @suffix == 0
+      s
+    end
+
+    #  %Y   %m %d %H %M %S  suffix        %Y/%m/  %Y%m%d%H%M%S %L
+    # "2020-12-30 12:34:56  (0 | nil)" => "2020/12/20201230123456"
+    # "2020-12-30 12:34:56  (7)"       => "2020/12/20201230123456_007"
+    def to_pathname
+      @time.strftime("%Y/%m/") + self.to_s
+    end
+
+    class << self
+      #  yyyymoddhhmiss sfx      yyyy    mo    dd    hh    mi    ss    sfx
+      # "20201230123456"     => "2020", "12", "30", "12", "34", "56"
+      # "20201230123456_789" => "2020", "12", "30", "12", "34", "56", "789"
+      def split_stamp(stamp_str)
+        #    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
+      end
+
+      def parse_s(stamp_str)
+        year, mon, day, hour, min, sec , sfx = split_stamp(stamp_str).map(&:to_i)
+        Timestamp.new(Time.new(year, mon, day, hour, min, sec), sfx)
+      end
+
+      #                      (-2)
+      #  0       8           |(-1)
+      #  V       V           VV
+      # "2020/12/20201230123456" => "2020-12-30 12:34:56"
+      def parse_pathname(pathname)
+        parse_s(pathname[8..-1])
+      end
+    end
+  end
+end

data/lib/textrepo/version.rb

@@ -0,0 +1,3 @@
+module Textrepo
+  VERSION = '0.4.1'
+end

data/textrepo.gemspec

@@ -0,0 +1,29 @@
+require_relative 'lib/textrepo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "textrepo"
+  spec.version       = Textrepo::VERSION
+  spec.authors       = ["mnbi"]
+  spec.email         = ["mnbi@users.noreply.github.com"]
+
+  spec.summary       = %q{A repository to store text with timestamp.}
+  spec.description   = %q{Textrepo is a repository to store text with timestamp.  It can manage text with the attached timestamp (read/update/delte).}
+  spec.homepage      = "https://github.com/mnbi/textrepo"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/mnbi/textrepo"
+  spec.metadata["changelog_uri"] = "https://github.com/mnbi/textrepo/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.1"
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: textrepo
+version: !ruby/object:Gem::Version
+  version: 0.4.1
+platform: ruby
+authors:
+- mnbi
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: Textrepo is a repository to store text with timestamp.  It can manage
+  text with the attached timestamp (read/update/delte).
+email:
+- mnbi@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/rbnotes/lib/rbnotes.rb
+- examples/rbnotes/lib/rbnotes/commands.rb
+- examples/rbnotes/lib/rbnotes/commands/import.rb
+- examples/rbnotes/lib/rbnotes/commands/list.rb
+- examples/rbnotes/lib/rbnotes/commands/show.rb
+- examples/rbnotes/lib/rbnotes/version.rb
+- examples/rbnotes/rbnotes
+- lib/textrepo.rb
+- lib/textrepo/error.rb
+- lib/textrepo/file_system_repository.rb
+- lib/textrepo/repository.rb
+- lib/textrepo/timestamp.rb
+- lib/textrepo/version.rb
+- textrepo.gemspec
+homepage: https://github.com/mnbi/textrepo
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/mnbi/textrepo
+  source_code_uri: https://github.com/mnbi/textrepo
+  changelog_uri: https://github.com/mnbi/textrepo/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: A repository to store text with timestamp.
+test_files: []