rbnotes 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e3b44e20631a0216391b389aee7faca4ecebe31502bbff92606c938023a98240
+  data.tar.gz: 4a39041ad77631da13be01ebde0745edd38f22f52b5c9ad2ae1a002053739c1b
+SHA512:
+  metadata.gz: e98fabf28f56131caf2ec40c1111aa74a0819d923937cd033eeed6921c5ce43102657e8c3d787a8b9718b3057e7505921d2f7d316a327a041e80dcc2bce4b2ae
+  data.tar.gz: 672cd941dd68c545056c752a714bc29df9a9de5b14ce00b8c6568562df619e796c7cea77b376380bb3c32c06d680f834552c3c6367033bf2ab02b7460c4e1b0f

data/.gitignore

@@ -0,0 +1,56 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

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.2.1] - 2020-10-25
+### Added
+- Add feature to load the configuration from an external file.
+- Add description about the configuration file in README.md
+
+## [0.2.0] - 2020-10-23
+### Added
+- Add more commands (add/update/delete).
+  - Add and update commands use a external editor to edit a note.
+  - Delete command remove the specified note from the repository.
+- Add a new task into `Rakefile` to generate RI docs.
+  - The intention of the task is to verify RI docs.
+
+### Fixed
+- Refactor some tests.
+
+## [0.1.3] - 2020-10-15
+### Fixed
+- Add help text for the `conf` command.
+
+## [0.1.2] - 2020-10-15
+### Fixed
+- Adapt the API change in `textrepo` (0.4.0).
+
+## [0.1.0] - 2020-10-12
+### Added
+- Import files those are part of `examples` in the `textrepo` gem.
+  - All commands in the example version works fine.
+  - Wrote tests for all commands.
+- All files those are generated by `bundler`.
+- Add CHANGELOG.md to start recording changes.

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    rbnotes (0.2.1)
+      textrepo (~> 0.4)
+      unicode-display_width (~> 1.7)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.14.2)
+    rake (13.0.1)
+    textrepo (0.4.2)
+    unicode-display_width (1.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  rake (~> 13.0)
+  rbnotes!
+  textrepo (~> 0.4)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+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,156 @@
+# Rbnotes
+
+[![Build Status](https://travis-ci.org/mnbi/rbnotes.svg?branch=main)](https://travis-ci.org/mnbi/rbnotes)
+
+Rbnotes is a simple utility to write a note in the single repository.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rbnotes, github: 'mnbi/rbnotes, branch: 'main'
+```
+
+And then execute:
+
+    $ bundle install
+
+## Usage
+
+General syntax is:
+
+``` shell
+rbnotes [global_opts] [command] [command_opts] [args]
+```
+
+### Commands
+
+- import
+  - imports existing files
+- list
+  - lists notes in the repository with their timestamps and subject
+- show
+  - shows the content of a note
+- add
+  - adds a new note to the repository using an external editor
+- update
+  - update the content of the specified note using an external editor
+- delete
+  - deletes the specified note form the repository
+
+### Configuration file
+
+The `rbnotes` command reads the configuration file during its startup.
+This section describes the specification of the configuration file.
+
+#### Location
+
+Searches the configuration file in the following order:
+
+1. `$XDG_CONFIG_HOME/rbnotes/config.yml`
+2. `$HOME/.config/rbnotes/config.yml`
+
+None of them is found, then the default configuration is used.
+
+#### Content
+
+The format of the configuration file must be written in YAML.
+
+The configuration of `rbnotes` is represented as a Hash object in the
+program code.  So, each line of the configuration YAML looks like:
+
+> name: value
+
+Name must be written as Ruby's symbol, such `:repository_type`.  On
+the other hand, value will be written in 2 types.  Some are Ruby's
+symbols, the others are strings surrounded with double/single
+quotations.
+
+A real example:
+
+``` yaml
+---
+:run_mode: :development
+:repository_type: :file_system
+:repository_name: "notes"
+:repository_base: "~"
+:pager: "bat"
+:editor: "/usr/local/bin/emacsclient"
+```
+
+#### Variables
+
+##### :run-mode (mandatory)
+
+- :production (default)
+- :development
+- :test
+
+The run-mode affects to behavior of `rbnotes`, such logging
+information, the location of the repository, ..., etc.
+
+##### :repository_type (mandatory)
+
+- :file_system (default)
+
+This value depends on classes those derived from
+`Textrepo::Repository` of `textrepo`.  Currently (`textrepo` 0.4.x),
+Textrepo::FileSystemRepository is the only one class usable for
+`rbnotes`.
+
+##### :repository_name (mandatory)
+
+User can set an arbitrary string as this value.  However, the value
+will be used as a part of the repository location in the file system.
+Some characters in the string may cause a problem.
+
+In addition to this, the run-mode affects the actual value when it is
+used in the program.
+
+| original | :production | :development | :test      |
+|:------   |:------------|:-------------|:-----------|
+| notes    | notes       | notes_dev    | notes_test |
+
+##### :repository_base (mandatory)
+
+This value is used as a base directory of the repository.  That is,
+the values constructs the root path of the repository with
+the `:repository_name` value.  It would be:
+
+> :repository_base/:repository_name
+
+The value must be an absolute path.  The short-hand notation of the
+home directory ("~") is usable.
+
+##### Miscellaneous variables (optional)
+
+- :pager : specify a pager program
+- :editor : specify a editor program
+
+##### Default values for mandatory variables
+
+All mandatory variables have their default values.  Here is the list
+of them:
+
+| variable         | default value |
+|:-----------------|:--------------|
+| :run_mode        | :production   |
+| :repository_type | :file_system  |
+| :repository_name | "notes"       |
+| :repository_base | "~"           |
+
+## 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/rbnotes.
+
+
+## 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,30 @@
+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
+
+task test: [:clean, :setup_test]
+
+desc "Setup test data"
+task :setup_test do
+  print "Set up to execute tests..."
+  load("test/fixtures/setup_test_repo.rb", true)
+  puts "done."
+end
+
+CLEAN << "test/sandbox"
+CLOBBER << "test/fixtures/test_repo"
+
+require "rdoc/task"
+
+RDoc::Task.new do |rdoc|
+  rdoc.generator = "ri"
+  rdoc.rdoc_dir = "doc"
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rbnotes"
+
+# 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/exe/rbnotes

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require "rbnotes"
+
+include Rbnotes
+
+DEBUG = true
+
+class App
+  def run(args)
+    cmd = args.shift
+    Commands.load(cmd).execute(args, Rbnotes.conf)
+  end
+end
+
+app = App.new
+begin
+  app.run(ARGV)
+rescue MissingArgumentError, MissingTimestampError,
+       NoEditorError, ProgramAbortError => e
+  puts e.message
+  exit 1
+end

data/lib/rbnotes.rb

@@ -0,0 +1,9 @@
+require "textrepo"
+
+module Rbnotes
+  require_relative "rbnotes/version"
+  require_relative "rbnotes/error"
+  require_relative "rbnotes/conf"
+  require_relative "rbnotes/utils"
+  require_relative "rbnotes/commands"
+end

data/lib/rbnotes/commands.rb

@@ -0,0 +1,144 @@
+module Rbnotes
+  ##
+  # This module defines all command classes of rbnotes.  Each command
+  # class must be derived from Rbnotes::Commands::Command class.
+  module Commands
+    ##
+    # The base class for a command class.
+    class Command
+      ##
+      # :call-seq:
+      #   Array, Hash -> nil
+      #   - Array: arguments for each command
+      #   - Hash : rbnotes configuration
+      #
+      def execute(args, conf)
+        Builtins::DEFAULT_CMD.new.execute(args, conf)
+      end
+    end
+
+    # :stopdoc:
+
+    # 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
+    delete STAMP    : delete the note specified with STAMP
+
+    conf            : print the current configuraitons
+    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"
+
+    # :startdoc:
+
+    class << self
+      ##
+      # Loads a class to perfom the command, then returns an instance
+      # of the class.
+      #
+      # :call-seq:
+      #   "import" -> an object of Rbnotes::Commnads::Import
+      #   "list"   -> an object of Rbnotes::Commands::List
+      #   "show"   -> an object of Rbnotes::Commands::Show
+      #
+      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/lib/rbnotes/commands/add.rb

@@ -0,0 +1,49 @@
+module Rbnotes::Commands
+  ##
+  # Adds a new note to the repository.  A new timestamp is generated
+  # at the execution time, then it is attached to the note.  If the
+  # timestamp has already existed in the repository, the command
+  # fails.
+  #
+  # This command starts the external editor program to prepare text to
+  # store.  The editor program will be searched in the following order:
+  #
+  # 1. conf[:editor] (conf is the 1st arg of execute method)
+  # 2. ENV["EDITOR"]
+  # 3. "nano"
+  # 4. "vi"
+  #
+  # If none of the above editor is available, the command fails.
+  #
+  class Add < Command
+    include ::Rbnotes::Utils
+
+    def execute(args, conf)
+      newstamp = Textrepo::Timestamp.new(Time.now)
+
+      candidates = [conf[:editor], ENV["EDITOR"], "nano", "vi"].compact
+      editor = find_program(candidates)
+      raise Rbnotes::NoEditorError, candidates if editor.nil?
+
+      tmpfile = run_with_tmpfile(editor, newstamp.to_s)
+      text = File.readlines(tmpfile)
+
+      repo = Textrepo.init(conf)
+      begin
+        repo.create(newstamp, text)
+      rescue Textrepo::DuplicateTimestampError => e
+        puts e.message
+        puts "Just wait a second, then retry."
+      rescue Textrepo::EmptyTextError => e
+        puts e.message
+      rescue StandardError => e
+        puts e.message
+      else
+        puts "Add a note [%s]" % newstamp.to_s
+      ensure
+        # Don't forget to remove the temporary file.
+        File.delete(tmpfile)
+      end
+    end
+  end
+end

data/lib/rbnotes/commands/delete.rb

@@ -0,0 +1,35 @@
+# :markup: markdown
+
+# Delete command deletes one note in the repository, which specified
+# with a given timestamp string.  The timestamp string must be a fully
+# qualified one, like "20201016165130".  The argument to specify a
+# note is mandatory.  If no argument was passed, it would print help
+# message and exit.
+#
+# It does nothing when the specified note does not exist except to
+# print error message.
+
+# :stopdoc: 
+
+module Rbnotes
+  class Commands::Delete < Commands::Command
+    def execute(args, conf)
+      stamp_str = args.shift
+      unless stamp_str.nil?
+        repo = Textrepo.init(conf)
+        begin
+          stamp = Textrepo::Timestamp.parse_s(stamp_str)
+          repo.delete(stamp)
+        rescue Textrepo::MissingTimestampError => e
+          puts e.message
+        rescue StandardError => e
+          puts e.message
+        else
+          puts "Delete [%s]" % stamp.to_s
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/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 => _
+            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 => _
+            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/lib/rbnotes/commands/list.rb

@@ -0,0 +1,57 @@
+require "unicode/display_width"
+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|
+        count += Unicode::DisplayWidth.of(c)
+        break if count > size
+        result << c
+      }
+      result
+    end
+  end
+end

data/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/lib/rbnotes/commands/update.rb

@@ -0,0 +1,75 @@
+module Rbnotes::Commands
+  ##
+  # Updates the content of the note associated with given timestamp.
+  # Actual modification is done interactively by the external editor.
+  # The timestamp associated with the note will be updated to new one,
+  # which is generated while the command exection.
+  #
+  # A timestamp string must be specified as the only argument.  It
+  # must exactly match to the one of the target note in the
+  # repository.  When the given timestamp was not found, the command
+  # fails.
+  #
+  # Timestamp which is associated to the target note will be newly
+  # generated with the command execution time.  That is, the timestamp
+  # before the command exection will be obsolete.
+  #
+  # This command starts the external editor program to edit the
+  # content of the note.  The editor program will be searched as same
+  # as add command.
+  #
+  # If none of editors is available, the command fails.
+  #
+  class Update < Command
+    include ::Rbnotes::Utils
+
+    ##
+    # The 1st and only one argument is the timestamp to speficy the
+    # note to update.  Returns the new timestamp which is associated
+    # to the note updated.
+    #
+    # :call-seq:
+    #     "20201020112233" -> "20201021123400"
+    #
+    def execute(args, conf)
+      raise Rbnotes::MissingArgumentError, args if args.size < 1
+
+      target_stamp = nil
+      begin
+        target_stamp = Textrepo::Timestamp.parse_s(args.shift)
+      rescue ArgumentError => e
+        raise Rbnotes::MissingArgumentError, args
+      end
+
+      editor = find_editor(conf[:editor])
+
+      repo = Textrepo.init(conf)
+
+      text = nil
+      begin
+        text = repo.read(target_stamp)
+      rescue Textrepo::MissingTimestampError => _
+        raise Rbnotes::MissingTimestampError, target_stamp
+      end
+
+      tmpfile = run_with_tmpfile(editor, target_stamp.to_s, text)
+      text = File.readlines(tmpfile)
+
+      unless text.empty?
+        newstamp = nil
+        begin
+          newstamp = repo.update(target_stamp, text)
+        rescue StandardError => e
+          puts e.message
+        else
+          puts "Update the note [%s -> %s]" % [target_stamp, newstamp]
+        ensure
+          # Don't forget to remove the temporary file.
+          File.delete(tmpfile)
+        end
+      else
+        puts "Nothing is updated, since the specified content is empty."
+      end
+    end
+  end
+end

data/lib/rbnotes/conf.rb

@@ -0,0 +1,118 @@
+require "forwardable"
+require "yaml"
+
+module Rbnotes
+  ##
+  # Holds the configuration settings.  Each value of setting can be
+  # retrieved like a Hash object.  Here is some examples.
+  #
+  #   conf = Rbnotes.conf
+  #   type = conf[:repository_type]
+  #   name = conf[:repository_name]
+  #   base = conf[:repository_base]
+
+  class Conf
+    extend Forwardable
+    include Enumerable
+
+    ##
+    # Name of the file to store configuration settings.
+
+    FILENAME_CONF = "config.yml"
+
+    ##
+    # Name of the directory indicates which belongs to "rbnotes".
+
+    DIRNAME_RBNOTES = "rbnotes"
+
+    ##
+    # Name of the directory which is used to indicate to put
+    # configuration files.  Many tools use this name as the role.
+
+    DIRNAME_COMMON_CONF = ".config"
+
+    def initialize(conf_path = nil)   # :nodoc:
+      @conf_path = conf_path || File.join(base_path, FILENAME_CONF)
+
+      @conf = {}
+      if FileTest.exist?(@conf_path)
+        yaml_str = File.open(@conf_path, "r") { |f| f.read }
+        @conf = YAML.load(yaml_str)
+      else
+        @conf.merge(DEFAULT_VALUES)
+      end
+      self
+    end
+
+    def_delegators(:@conf,
+                   :empyt?, :keys, :values,
+                   :has_key?, :include?, :key?, :member?,
+                   :length, :size,
+                   :to_s,
+                   :each, :each_pair)
+
+    ##
+    # Retrieves the value for the given key.
+    #
+    # :call-seq:
+    #     self[sym] -> value
+
+    def [](sym)
+      mode = @conf[:run_mode] || :production
+      value = @conf[sym] || DEFAULT_VALUES[sym]
+      if [:repository_name].include?(sym)
+        value += MODE_POSTFIX[mode]
+      end
+      value
+    end
+
+    # :stopdoc:
+
+    def initialize_copy(_)
+      @conf = @conf.dup
+    end
+
+    def freeze;  @conf.freeze;  super; end
+    def taint;   @conf.taint;   super; end
+    def untaint; @conf.untaint; super; end
+
+    private
+    DEFAULT_VALUES = {
+      :repository_type => :file_system,
+      :repository_name => "notes",
+      :repository_base => "~",
+    }
+
+    MODE_POSTFIX = {
+      :production => "",
+      :development => "_deve",
+      :test => "_test",
+    }
+
+    def base_path
+      path = nil
+      xdg, user = ["XDG_CONFIG_HOME", "HOME"].map{|n| ENV[n]}
+      if xdg
+        path = File.join(File.expand_path(xdg), DIRNAME_RBNOTES)
+      else
+        path = File.join(user, DIRNAME_COMMON_CONF, DIRNAME_RBNOTES)
+      end
+      return path
+    end
+  end
+
+  # :startdoc:
+
+  class << self
+    ##
+    # Gets the instance of Rbnotes::Conf.  An optional argument is to
+    # specify the absolute path for the configuration file.
+    #
+    # :call-seq:
+    #     conf(String) => Rbnotes::Conf
+
+    def conf(conf_path = nil)
+      Conf.new(conf_path)
+    end
+  end
+end

data/lib/rbnotes/error.rb

@@ -0,0 +1,54 @@
+module Rbnotes
+  ##
+  # A base class for each error class of rbnotes.
+  #
+  class Error < StandardError; end
+
+  # :stopdoc:
+  module ErrMsg
+    MISSING_ARGUMENT  = "missing argument: %s"
+    MISSING_TIMESTAMP = "missing timestamp: %s"
+    NO_EDITOR         = "No editor is available: %s"
+    PROGRAM_ABORT     = "External program was aborted: %s"
+  end
+
+  # :startdoc:
+
+  ##
+  # An error raised if an essential argument was missing.
+  #
+  class MissingArgumentError < Error
+    def initialize(args)
+      super(ErrMsg::MISSING_ARGUMENT % args.to_s)
+    end
+  end
+
+  ##
+  # An error raised if a given timestamp was not found in the
+  # repository.
+  #
+  class MissingTimestampError < Error
+    def initialize(timestamp)
+      super(ErrMsg::MISSING_TIMESTAMP % timestamp)
+    end
+  end
+
+  ##
+  # An error raised if no external editor is available to edit a note,
+  # even "nano" or "vi".
+  #
+  class NoEditorError < Error
+    def initialize(names)
+      super(ErrMsg::NO_EDITOR % names.to_s)
+    end
+  end
+
+  ##
+  # An error raised when a external program such an editor was aborted
+  # during its execution.
+  class ProgramAbortError < Error
+    def initialize(cmdline)
+      super(ErrMsg::PROGRAM_ABORT % cmdline.join(" "))
+    end
+  end
+end

data/lib/rbnotes/utils.rb

@@ -0,0 +1,107 @@
+require "pathname"
+require "tmpdir"
+
+module Rbnotes
+  ##
+  # Defines several utility methods those are intended to be used in
+  # Rbnotes classes.
+  #
+  module Utils
+
+    ##
+    # Finds a external editor program which is specified with the
+    # argument, then returns the absolute path of the editor.  If the
+    # specified editor was not found, then search default editors in
+    # the command search paths (i.e. `ENV["PATH"]).  See also the
+    # document for `find_program`.
+    #
+    # The default editors to search in the search paths are:
+    #
+    # 1. ENV["EDITOR"]
+    # 2. "nano"
+    # 3. "vi"
+    #
+    # When all the default editors were not found, returns `nil`.
+    #
+    def find_editor(preferred_editor)
+      find_program([preferred_editor, ENV["EDITOR"], "nano", "vi"].compact)
+    end
+    module_function :find_editor
+
+    ##
+    # Finds a executable program in given names.  When the executable
+    # was found, it stops searching then returns an absolute path of
+    # the executable.
+    #
+    # The actual searching is done in 2 cases.  That is, a given name is:
+    #
+    # 1. an absolute path:
+    #    returns the path itself if it exists and is executable.
+    # 2. just a program name:
+    #    searchs the name in the search paths (ENV["PATH"]);
+    #    if it is found in a path, construct an absolute path from
+    #    the name and the path, then returns the path.
+    #
+    # :call-seq:
+    #   ["nano", "vi"]                 -> "/usr/bin/nano"
+    #   ["vi", "/usr/local/bin/emacs"] -> "/usr/bin/vi"
+    #   ["/usr/local/bin/emacs", "vi"] -> "/usr/bin/vi" (if emacs doesn't exist)
+    #   ["/usr/local/bin/emacs", "vi"] -> "/usr/local/bin/emacs" (if exists)
+    #
+    def find_program(names)
+      names.each { |name|
+        pathname = Pathname.new(name)
+        if pathname.absolute?
+          return pathname.to_path if pathname.exist? && pathname.executable?
+        else
+          abs = search_in_path(name)
+          return abs unless abs.nil?
+        end
+      }
+      nil
+    end
+    module_function :find_program
+
+    ##
+    # Executes the program with passing the given filename as argument.
+    # The file will be created into `Dir.tmpdir`.
+    #
+    # If initial_content is not nil, it must be an array of strings
+    # then it provides the initial content of a temporary file.
+    #
+    # :call-seq:
+    #     "/usr/bin/nano", "20201021131300.md", nil -> "/somewhere/tmpdir/20201021131300.md"
+    #     "/usr/bin/vi", "20201021131301.md", ["apple\n", "orange\n"] -> "/somewhere/tmpdir/20201021131301.md"
+    #
+    def run_with_tmpfile(prog, filename, initial_content = nil)
+      tmpfile = File.expand_path(add_extension(filename), Dir.tmpdir)
+
+      unless initial_content.nil?
+        File.open(tmpfile, "w") {|f| f.print(initial_content.join("\n"))}
+      end
+
+      rc = system(prog, tmpfile)
+      raise ProgramAbortError, [prog, tmpfile] unless rc
+      tmpfile
+    end
+    module_function :run_with_tmpfile
+
+    # :stopdoc:
+
+    private
+    def search_in_path(name)
+      search_paths = ENV["PATH"].split(":")
+      found = search_paths.map { |path|
+        abs = File.expand_path(name, path)
+        FileTest.exist?(abs) ? abs : nil
+      }
+      found.compact[0]
+    end
+    module_function :search_in_path
+
+    def add_extension(basename)
+      "#{basename}.md"
+    end
+    module_function :add_extension
+  end
+end

data/lib/rbnotes/version.rb

@@ -0,0 +1,4 @@
+module Rbnotes
+  VERSION = "0.2.1"
+  RELEASE = '2020-10-25'
+end

data/rbnotes.gemspec

@@ -0,0 +1,30 @@
+require_relative 'lib/rbnotes/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rbnotes"
+  spec.version       = Rbnotes::VERSION
+  spec.authors       = ["mnbi"]
+  spec.email         = ["mnbi@users.noreply.github.com"]
+
+  spec.summary       = %q{A simple utility to write a note.}
+  spec.description   = %q{Rbnotes allows you to write a note into a single repository.}
+  spec.homepage      = "https://github.com/mnbi/rbnotes"
+  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/rbnotes"
+  spec.metadata["changelog_uri"] = "https://github.com/mnbi/rbnotes/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_dependency "textrepo", "~> 0.4"
+  spec.add_dependency "unicode-display_width", "~> 1.7"
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: rbnotes
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- mnbi
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-10-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: textrepo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: unicode-display_width
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: Rbnotes allows you to write a note into a single repository.
+email:
+- mnbi@users.noreply.github.com
+executables:
+- rbnotes
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/rbnotes
+- lib/rbnotes.rb
+- lib/rbnotes/commands.rb
+- lib/rbnotes/commands/add.rb
+- lib/rbnotes/commands/delete.rb
+- lib/rbnotes/commands/import.rb
+- lib/rbnotes/commands/list.rb
+- lib/rbnotes/commands/show.rb
+- lib/rbnotes/commands/update.rb
+- lib/rbnotes/conf.rb
+- lib/rbnotes/error.rb
+- lib/rbnotes/utils.rb
+- lib/rbnotes/version.rb
+- rbnotes.gemspec
+homepage: https://github.com/mnbi/rbnotes
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/mnbi/rbnotes
+  source_code_uri: https://github.com/mnbi/rbnotes
+  changelog_uri: https://github.com/mnbi/rbnotes/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 simple utility to write a note.
+test_files: []