rbnotes 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a43f87f2f4b03c9f8e27d06eb4fc426abb6dafbd420d5bbbcdb4ec2ea38d497
-  data.tar.gz: 0f9c060bfefde2e6c3f611d7d7e683fdd5ced20327b3ae6a3cbfcac39cdaf5a3
+  metadata.gz: f48ac5666d917964e9c103c11be86b12736b81ced6e072be4707e1e943b6ff76
+  data.tar.gz: d29b9b68d6ebfcfdc7289962405a0390daed2705cd80b3beb50e036d2f8d9e85
 SHA512:
-  metadata.gz: e28ed07cde6f385945a9ed3b92ff6402b8ec2dcdd2a75f6d1d0a8e391a2bf5e000245d708903fa815ec5faecfb2cfc39034240ef83a44818bd9a9ccb39c326ed
-  data.tar.gz: 0e2a87a92c5b5a674d143c3d4461577976e5f62508d67ebbdb5202bfbc771c04aacaab520f8860e29429411f50677351f059e01a919e0836fc889b6285507fbd
+  metadata.gz: f5be0687fc189a5dad6178104a05af0f64e35fc44dd1a73bf677a232038b81b4f88e5562ca9f9e8f098152136c005ebdc334158d34652c0fe7a2bea8e13c4056
+  data.tar.gz: a1e5d671d93ff9efdbe33e7c6751984f851c39756304df7c874fe82df558b18b7f4f716d82253e99b2d8e21cc1d795d6b81c0f1ba665f8f3e99e38c30e4d19d8

data/CHANGELOG.md

@@ -7,11 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 ## [Unreleased]
 Nothing to record here.
 
+## [0.4.3] - 2020-11-08
+### Added
+- Add a new command `export` to write out a note into a file (#51)
+- Add individual help for each command. (#42)
+
+### Fixed
+- Fix `add` fails without modification (#48)
+
 ## [0.4.2] - 2020-11-05
 ### Added
 - Add a feature to keep the timestamp in `update` command. (#44)
 
-### Changed
+### Fixed
 - Fix issue #45: hanging up of `add` command.
 
 ## [0.4.1] - 2020-11-04

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rbnotes (0.4.2)
+    rbnotes (0.4.3)
       textrepo (~> 0.5.4)
       unicode-display_width (~> 1.7)
 

data/exe/rbnotes

@@ -23,6 +23,14 @@ class App
         file = File.expand_path(file)
         raise ArgumentError, "no such file: %s" % file unless FileTest.exist?(file) 
         @gopts[:conf_file] = file
+      when "-v", "--version"
+        args.clear
+        args.unshift("version")
+        break
+      when "-h", "--help"
+        args.clear
+        args.unshift("help")
+        break
       else
         args.unshift(arg)
         break
@@ -43,7 +51,8 @@ begin
 rescue MissingArgumentError, MissingTimestampError,
        NoEditorError, ProgramAbortError,
        Textrepo::InvalidTimestampStringError,
-       ArgumentError => e
+       ArgumentError,
+       Errno::EACCES => e
   puts e.message
   exit 1
 end

data/lib/rbnotes.rb

@@ -1,6 +1,8 @@
 require "textrepo"
 
 module Rbnotes
+  NAME = File.basename($PROGRAM_NAME) # :nodoc:
+
   require_relative "rbnotes/version"
   require_relative "rbnotes/error"
   require_relative "rbnotes/conf"

data/lib/rbnotes/commands.rb

@@ -1,14 +1,21 @@
 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
 
+      ##
+      # Short description of each command.
+
+      def description; nil; end
+
       ##
       # :call-seq:
       #   execute(Array, Hash) -> nil
@@ -17,8 +24,17 @@ module Rbnotes
       #   - Hash : rbnotes configuration
 
       def execute(args, conf)
-        Builtins::DEFAULT_CMD.new.execute(args, conf)
+        Builtins.default_cmd.new.execute(args, conf)
       end
+
+      ##
+      # Shows the help message for the command.
+      #
+
+      def help
+        Builtins::Usage.new.execute(nil, nil)
+      end
+
     end
 
     # :stopdoc:
@@ -29,71 +45,73 @@ module Rbnotes
     # - 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 [-c|--conf CONF_FILE] [command] [args]
-
-option:
-    -c, --conf [CONF_FILE] : specifiy the configuration file
-
-    CONF_FILE must be written in YAML.  To know about details of the
-    configuration file, see README.md or Wiki page.
-
-command:
-    add            : create a new note
-    import FILE    : import a FILE into the repository
+      class Usage < Command
 
-    list [STAMP_PATTERN] : list notes those timestamp matches PATTERN
-    search PATTERN [STAMP_PATTERN] : search PATTERN
-
-    STAMP_PATTERN must be:
-
-        (a) full qualified timestamp (with suffix): "20201030160200"
-        (b) year and date part: "20201030"
-        (c) year and month part: "202010"
-        (d) year part only: "2020"
-        (e) date part only: "1030"
-
-    PATTERN is a word (or words) to search, it may also be a regular
-    expression.
-
-    show   [STAMP] : show the note specified with STAMP
-    update [STAMP] : edit the note with external editor
-    delete [STAMP] : delete the note specified with STAMP
-
-    STAMP must be a sequence of digits to represent year, date and
-    time (and suffix), such "20201030160200" or "20201030160200_012".
-
-    show/update/delete reads its argument from the standard input when
-    no argument was passed in the command line.
+        def description
+          "Print usage"
+        end
 
-    version        : print version
-    help           : show help
+        def execute(_, _)
+          puts <<USAGE
+Syntax:
+  #{Rbnotes::NAME} [-c| --conf CONF_FILE] [command] [args]
+
+Example usage:
+  #{Rbnotes::NAME} add [-t STAMP_PATTERN]
+  #{Rbnotes::NAME} delete [TIMESTAMP]
+  #{Rbnotes::NAME} export [TIMESTAMP [FILENAME]]
+  #{Rbnotes::NAME} import FILE
+  #{Rbnotes::NAME} list [STAMP_PATTERN]
+  #{Rbnotes::NAME} search PATTERN [STAMP_PATTERN]
+  #{Rbnotes::NAME} show [TIMESTAMP]
+  #{Rbnotes::NAME} update [TIMESTAMP]
+
+Further help for each command:
+  #{Rbnotes::NAME} help commands
+  #{Rbnotes::NAME} help [COMMAND]
+
+Further information:
+  https://github.com/mnbi/rbnotes/wiki
 
-command for development:
-    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
+USAGE
+        end
 
-For more information, see Wiki page.
-    - https://github.com/mnbi/rbnotes/wiki
+        def help
+          puts <<HELP_USAGE
+usage:
+    #{Rbnotes::NAME} usage
 
-USAGE
+Print a short example of usage.
+HELP_USAGE
         end
       end
 
       class Version < Command
+        def description
+          "Print version"
+        end
+
         def execute(_, _)
-          rbnotes_version = "rbnotes #{Rbnotes::VERSION} (#{Rbnotes::RELEASE})"
+          rbnotes_version = "#{Rbnotes::NAME} #{Rbnotes::VERSION} (#{Rbnotes::RELEASE})"
           textrepo_version = "textrepo #{Textrepo::VERSION}"
           puts "#{rbnotes_version} [#{textrepo_version}]"
         end
+
+        def help
+          puts <<VERSION
+usage:
+    #{Rbnotes::NAME} version
+
+Print version of #{Rbnotes::NAME} and release date.
+VERSION
+        end
       end
 
       class Repo < Command
+        def description
+          "Print repository path"
+        end
+
         def execute(_, conf)
           name = conf[:repository_name]
           base = conf[:repository_base]
@@ -106,19 +124,49 @@ USAGE
                  File.join(base, name)
                end
         end
+
+        def help
+          puts <<REPO
+usage:
+    #{Rbnotes::NAME} repo
+
+Print the path of the repository.  The type of the path entity depends
+on what type is specified to the repository type in the configuration.
+When ":file_system" is set to "repository_type", the path is a
+directory which contains all note files.  The structure of the
+directory depends on the implementation of `textrepo`.
+REPO
+        end
       end
 
       class Conf < Command
+        def description
+          "Print the current configuration"
+        end
+
         def execute(_, conf)
           conf.keys.sort.each { |k|
             puts "#{k}=#{conf[k]}"
           }
         end
+
+        def help
+          puts <<CONF
+usage:
+    #{Rbnotes::NAME} conf
+
+Print the current configuration values.
+CONF
+        end
       end
 
       require "time"
 
       class Stamp < Command
+        def description
+          "Convert a time string into a timestamp string"
+        end
+
         def execute(args, _)
           time_str = args.shift
           unless time_str.nil?
@@ -128,9 +176,30 @@ USAGE
             super
           end
         end
+
+        def help
+          puts <<STAMP
+usage:
+    #{Rbnotes::NAME} stamp
+
+Convert a given time string into a timestamp string.  The timestamp
+string could be used as an argument of some rbnotes commands, such
+"show".  Here is short example of conversion:
+
+    "2020-11-06 16:51:15" -> "20201106165115"
+    "2020-11-06"          -> "20201106000000"
+    "20201106"            -> "20201106000000"
+    "2020-11-06 16"       -> "20201106160000"
+    "2020-11-06 16:51"    -> "20201106165100" 
+STAMP
+        end
       end
 
       class Time < Command
+        def description
+          "Convert a timestamp into a time string"
+        end
+
         def execute(args, _)
           stamp = args.shift
           unless stamp.nil?
@@ -140,12 +209,41 @@ USAGE
             super
           end
         end
+
+        def help
+          puts <<TIME
+usage:
+    #{Rbnotes::NAME} time
+
+Convert a given timestamp string into a time string.  Here is short
+example of conversion:
+
+    "20201106165115" -> "2020-11-06 16:51:15 +0900"
+    "202011061651"   -> "2020-11-06 16:51:00 +0900"
+    "2020110616"     -> "2020-11-06 16:00:00 +0900"
+    "20201106"       -> "2020-11-06 00:00:00 +0900"
+TIME
+        end
       end
 
-      DEFAULT_CMD = Help
-    end
+      class << self
+        def default_cmd_name
+          "usage"
+        end
+
+        def default_cmd
+          Usage
+        end
 
-    DEFAULT_CMD_NAME = "help"
+        def command(name)
+          begin
+            const_defined?(name, false) ? const_get(name, false) : nil
+          rescue NameError => _
+            nil
+          end
+        end
+      end
+    end
 
     # :startdoc:
 
@@ -156,24 +254,28 @@ USAGE
       # of the class.
       #
       # :call-seq:
+      #   load("add")    -> Rbnotes::Commands::Add
+      #   load("delete") -> Rbnotes::Commands::Delete
+      #   load("export") -> Rbnotes::Commands::Export
+      #   load("help")   -> Rbnotes::Commands::Help
       #   load("import") -> Rbnotes::Commnads::Import
       #   load("list")   -> Rbnotes::Commands::List
+      #   load("search") -> Rbnotes::Commands::Search
       #   load("show")   -> Rbnotes::Commands::Show
+      #   load("update") -> Rbnotes::Commands::Update
 
       def load(cmd_name)
-        cmd_name ||= DEFAULT_CMD_NAME
+        cmd_name ||= Builtins.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
+        klass = Builtins.command(klass_name)
+        if klass.nil?
           begin
             require_relative "commands/#{cmd_name}"
             klass = const_get(klass_name, false)
           rescue LoadError => _
             STDERR.puts "unknown command: #{cmd_name}"
-            klass = Builtins::DEFAULT_CMD
+            klass = Builtins.default_cmd
           end
         end
         klass.new

data/lib/rbnotes/commands/add.rb

@@ -29,6 +29,10 @@ module Rbnotes::Commands
   class Add < Command
     include ::Rbnotes::Utils
 
+    def description             # :nodoc:
+      "Add a new note"
+    end
+
     def execute(args, conf)
       @opts = {}
       while args.size > 0
@@ -52,6 +56,12 @@ module Rbnotes::Commands
       raise Rbnotes::NoEditorError, candidates if editor.nil?
 
       tmpfile = run_with_tmpfile(editor, stamp.to_s)
+
+      unless FileTest.exist?(tmpfile)
+        puts "Cancel adding, since nothing to store"
+        return
+      end
+
       text = File.readlines(tmpfile)
 
       repo = Textrepo.init(conf)
@@ -72,6 +82,36 @@ module Rbnotes::Commands
       end
     end
 
+    def help                    # :nodoc:
+      puts <<HELP
+usage:
+    #{Rbnotes::NAME} add [(-t|--timestamp) STAMP_PATTERN]
+
+Add a new note to the repository.  If no options, a new timestamp is
+generated at the execution time, then it is attached to the note.
+
+Accept an option with `-t STAMP_PATTERN` (or `--timestamp`), a
+timestamp is generated according to `STAMP_PATTERN`.
+
+STAMP_PATTERN could be one of followings:
+
+    "20201104172230_078" : full qualified timestamp string
+    "20201104172230"     : full qualified timestamp string (no suffix)
+    "202011041722"       : year, date and time (omit second part)
+    "11041722"           : date and time (omit year and second part)
+
+This command starts the external editor program to prepare text to
+store.  The editor program will be searched in the following order:
+
+    1. configuration setting of ":editor"
+    2. ENV["EDITOR"]
+    3. "nano"
+    4. "vi"
+
+If none of the above editor is available, the execution fails.
+HELP
+    end
+
     # :stopdoc:
     private
     def complement_timestamp_pattern(pattern)

data/lib/rbnotes/commands/delete.rb

@@ -1,18 +1,17 @@
-# :markup: markdown
+module Rbnotes::Commands
 
-# 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.
+  # Deletes a given note in the repository.  The timestamp string must
+  # be a fully qualified one, like "20201016165130".  If no argument
+  # was passed, it would try to read from the standard input.
+  #
+  # It does nothing to change the repository when the specified note
+  # does not exist.
 
-# :stopdoc: 
+  class Delete < Command
+    def description             # :nodoc:
+      "Delete a note"
+    end
 
-module Rbnotes
-  class Commands::Delete < Commands::Command
     def execute(args, conf)
       stamp = Rbnotes::Utils.read_timestamp(args)
 
@@ -27,5 +26,18 @@ module Rbnotes
         puts "Delete [%s]" % stamp.to_s
       end
     end
+
+    def help                    # :nodoc:
+      puts <<HELP
+usage:
+    #{Rbnotes::NAME} delete [TIMESTAMP]
+
+Delete a given note.  TIMESTAMP must be a fully qualified one, such
+"20201016165130" or "20201016165130_012" if it has a suffix.
+
+Delete reads its argument from the standard input when no argument was
+passed in the command line.
+HELP
+    end
   end
 end

data/lib/rbnotes/commands/export.rb

@@ -0,0 +1,58 @@
+require "pathname"
+
+module Rbnotes::Commands
+
+  ##
+  # Writes out a given note into a specified file.  The file will be
+  # created in the current working directory unless an absolute path
+  # is specified as a filename.
+  #
+  # When no argument was passed, would try to read a timestamp string
+  # from the standard input.
+
+  class Export < Command
+
+    def description             # :nodoc:
+      "Write out a note into a file"
+    end
+
+    #
+    # :call-seq:
+    #     execute([a String as timestring], Rbnotes::Conf or Hash) -> nil
+
+    def execute(args, conf)
+      stamp = Rbnotes::Utils.read_timestamp(args)
+
+      repo = Textrepo.init(conf)
+      begin
+        content = repo.read(stamp)
+      rescue Textrepo::MissingTimestampError => _
+        raise MissingTimestampError, stamp
+      end
+
+      pathname = Pathname.new(args.shift || "#{stamp}.md")
+      pathname.parent.mkpath
+      pathname.open("w"){ |f| f.puts content }
+      puts "Export a note [%s] into a file [%s]" % [stamp, pathname]
+    end
+
+    def help                    # :nodoc:
+      puts <<HELP
+usage:
+    #{Rbnotes::NAME} export [TIMESTAMP [FILENAME]]
+
+Write out a given note into a specified file.  TIMESTAMP must be a
+fully qualified one, such "20201108141600", or "20201108141600_012" if
+it has a suffix.  FILENAME is optional.  When it omitted, the filename
+would be a timestamp string with ".md" as its extension, such
+"20201108141600.md"
+
+The file will be created into the current working directory unless an
+absolute path is specified as FILENAME.
+
+When no argument was passed, it would try to read a timestamp string
+from the standard input.  Then, FILENAME would be regarded as omitted.
+HELP
+    end
+  end
+end

data/lib/rbnotes/commands/help.rb

@@ -0,0 +1,98 @@
+module Rbnotes::Commands
+
+  ##
+  # Shows help message for the command which specifies with the
+  # argument.
+
+  class Help < Command
+
+    def description             # :nodoc:
+      "Provide help on each command"
+    end
+
+    ##
+    # :call-seq:
+    #     execute(["add"], Rbnotes::Conf or Hash) -> nil
+    #     execute(["delete"], Rbnotes::Conf or Hash) -> nil
+
+    def execute(args, conf)
+      cmd_name = args.shift
+      case cmd_name
+      when nil
+        self.help
+      when "commands"
+        print_commands
+      else
+        Commands.load(cmd_name).help
+      end
+    end
+
+    def help                    # :nodoc:
+      puts <<HELP
+#{Rbnotes::NAME.capitalize} is a simple tool to write a note into a single repository.
+
+When creates a new note, a timestamp is attached to the note.  #{Rbnotes::NAME.capitalize}
+manages notes with those timestamps, such update, delete, ...etc.
+
+Timestamp is a series of digits which represents year, date, and time.
+It looks like "20201106121100", means "2020-11-06 12:11:00".  It is
+generated in the local time.
+
+usage:
+    #{Rbnotes::NAME} [option] [command] [args]
+
+option:
+    -c, --conf [CONF_FILE] : specifiy the configuration file
+    -v, --version          : print version
+    -h, --help             : show this message
+
+    CONF_FILE must be written in YAML.  To know about details of the
+    configuration file, see README.md or Wiki page.
+
+Further help:
+    #{Rbnotes::NAME} help commands
+    #{Rbnotes::NAME} help COMMAND
+    #{Rbnotes::NAME} usage
+
+Further information:
+    https://github.com/mnbi/rbnotes/wiki
+HELP
+    end
+
+    # :stopdoc:
+    private
+
+    def print_commands
+      Dir.glob("*.rb", :base => __dir__) { |rb|
+        next if rb == "help.rb"
+        require_relative rb
+      }
+      commands = Commands.constants.difference([:Builtins, :Command])
+      builtins = Commands::Builtins.constants
+
+      puts "#{Rbnotes::NAME.capitalize} Commands:"
+      print_commands_desc(commands.sort)
+      puts
+      puts "for development purpose"
+      print_builtins_desc(builtins.sort)
+    end
+
+    def print_commands_desc(commands)
+      print_desc(Commands, commands)
+    end
+
+    def print_builtins_desc(builtins)
+      print_desc(Commands::Builtins, builtins)
+    end
+
+    def print_desc(mod, commands)
+      commands.map { |cmd|
+        name = "#{cmd.to_s.downcase}        "[0, 8]
+        desc = mod.const_get(cmd, false).new.description
+        puts "    #{name} #{desc}"
+      }
+    end
+
+    # :startdoc:
+  end
+end

data/lib/rbnotes/commands/import.rb

@@ -1,5 +1,29 @@
-module Rbnotes
-  class Commands::Import < Commands::Command
+module Rbnotes::Commands
+
+  ##
+  # Imports a existing file which specified by the argument as a note.
+  #
+  # A timestamp is generated referring to the birthtime of the given
+  # file.  If birthtime is not available on the system, use mtime
+  # (modification time).
+  #
+  # Occasionally, there is another note which has the same timestmap
+  # in the repository.  Then, tries to create a new timestamp with a
+  # suffix.  Unluckily, when such timestamp with a suffix already
+  # exists, tries to create a new one with increasing suffix.  Suffix
+  # will be "001", "002", ..., or "999".  In worst case, all suffix
+  # might have been already used.  Then, abandons to import.
+
+  class Import < Command
+
+    def description             # :nodoc:
+      "Import a file as a note"
+    end
+
+    ##
+    # :call-seq:
+    #     execute([PATHNAME], Rbnotes::Conf or Hash) -> nil
+
     def execute(args, conf)
       file = args.shift
       unless file.nil?
@@ -58,5 +82,18 @@ module Rbnotes
         super
       end
     end
+
+    def help                    # :nodoc:
+      puts <<HELP
+usage:
+    #{Rbnotes::NAME} import FILE
+
+Imports a existing file which specified by the argument as a note.
+
+A timestamp is generated referring to the birthtime of the given file.
+If birthtime is not available on the system, use mtime (modification
+time).
+HELP
+    end
   end
 end

data/lib/rbnotes/commands/list.rb

@@ -1,15 +1,20 @@
 require "unicode/display_width"
 require "io/console/size"
 
-module Rbnotes
+module Rbnotes::Commands
+
   ##
   # Defines `list` command for `rbnotes`.  See the document of execute
   # method to know about the behavior of this command.
 
-  class Commands::List < Commands::Command
+  class List < Command
+
+    def description             # :nodoc:
+      "List notes"
+    end
 
     ##
-    # Shows the list of notes in the repository.  The only argument is
+    # Shows a list of notes in the repository.  The only argument is
     # optional.  If it passed, it must be an timestamp pattern.  A
     # timestamp is an instance of Textrepo::Timestamp class.  A
     # timestamp pattern is a string which would match several
@@ -48,6 +53,25 @@ module Rbnotes
       }
     end
 
+    def help                    # :nodoc:
+      puts <<HELP
+usage:
+    #{Rbnotes::NAME} list [STAMP_PATTERN]
+
+Show a list of notes.  When no arguments, make a list with all notes
+in the repository.  When specified STAMP_PATTERN, only those match the
+pattern are listed.
+
+STAMP_PATTERN must be:
+
+    (a) full qualified timestamp (with suffix): "20201030160200"
+    (b) year and date part: "20201030"
+    (c) year and month part: "202010"
+    (d) year part only: "2020"
+    (e) date part only: "1030"
+HELP
+    end
+
     # :stopdoc:
 
     private

data/lib/rbnotes/commands/search.rb

@@ -1,4 +1,4 @@
-module Rbnotes
+module Rbnotes::Commands
 
   ##
   # Searches a given pattern in notes those have timestamps match a
@@ -22,7 +22,12 @@ module Rbnotes
   # See the document of `Rbnotes::Commands::List#execute` to know about
   # a timestamp pattern.
 
-  class Commands::Search < Commands::Command
+  class Search < Command
+
+    def description             # :nodoc:
+      "Search a given pattern in notes"
+    end
+
     def execute(args, conf)
       pattern = args.shift
       raise MissingArgumentError, args if pattern.nil?
@@ -40,5 +45,23 @@ module Rbnotes
         }
       end
     end
+
+    def help                    # :nodoc:
+      puts <<HELP
+usage:
+    #{Rbnotes::NAME} search PATTERN [STAMP_PATTERN]
+
+PATTERN is a word (or words) to search, it may also be a regular
+expression.
+
+STAMP_PATTERN must be:
+
+    (a) full qualified timestamp (with suffix): "20201030160200"
+    (b) year and date part: "20201030"
+    (c) year and month part: "202010"
+    (d) year part only: "2020"
+    (e) date part only: "1030"
+HELP
+    end
   end
 end

data/lib/rbnotes/commands/show.rb

@@ -1,5 +1,23 @@
-module Rbnotes
-  class Commands::Show < Commands::Command
+module Rbnotes::Commands
+
+  ##
+  # Shows the content of the note specified by the argument.  The
+  # argument must be a string which can be converted into
+  # Textrepo::Timestamp object.
+  #
+  # A string for Timestamp must be:
+  #
+  #     "20201106112600"     : year, date, time and sec
+  #     "20201106112600_012" : with suffix
+  #
+  # If no argument is passed, reads the standard input for an argument.
+
+  class Show < Command
+
+    def description             # :nodoc:
+      "Show the content of a note"
+    end
+
     def execute(args, conf)
       stamp = Rbnotes::Utils.read_timestamp(args)
 
@@ -17,5 +35,18 @@ module Rbnotes
         puts content
       end
     end
+
+    def help                    # :nodoc:
+      puts <<HELP
+usage:
+    #{Rbnotes::NAME} show [TIMESTAMP]
+
+Show the content of given note.  TIMESTAMP must be a fully qualified
+one, such "20201016165130" or "20201016165130_012" if it has a suffix.
+
+The command try to read its argument from the standard input when no
+argument was passed in the command line.
+HELP
+    end
   end
 end

data/lib/rbnotes/commands/update.rb

@@ -1,35 +1,32 @@
 module Rbnotes::Commands
+
   ##
   # Updates the content of the note associated with given timestamp.
-  # Actual modification is done interactively by the external editor.
+  #
+  # Reads its argument from the standard input when no argument was
+  # passed in the command line.
+  #
   # The timestamp associated with the note will be updated to new one,
   # which is generated while the command exection.
   #
   # When "-k" (or "--keep") option is specified, the timestamp will
   # remain unchanged.
   #
-  # 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.
+  # Actual modification is done interactively by the external editor.
   #
-  # If none of editors is available, the command fails.
+  # The editor program will be searched as same as add command.  If
+  # none of editors is available, the execution fails.
 
   class Update < Command
     include ::Rbnotes::Utils
 
+    def description             # :nodoc:
+      "Update the content of a note"
+    end
+
     ##
     # 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.
+    # note to update.
     #
     # :call-seq:
     #     "20201020112233" -> "20201021123400"
@@ -82,5 +79,27 @@ module Rbnotes::Commands
         puts "Nothing is updated, since the specified content is empty."
       end
     end
+
+    def help                    # :nodoc:
+      puts <<HELP
+usage:
+    #{Rbnotes::NAME} update [TIMESTAMP]
+
+Updates the content of the note associated with given timestamp.
+
+Reads its argument from the standard input when no argument was passed
+in the command line.
+
+The timestamp associated with the note will be updated to new one,
+which is generated while the command exection.
+
+When "-k" (or "--keep") option is specified, the timestamp will remain
+unchanged.
+
+Actual modification is done interactively by the external editor.  The
+editor program will be searched as same as add command.  If none of
+editors is available, the execution fails.
+HELP
+    end
   end
 end

data/lib/rbnotes/version.rb

@@ -1,4 +1,4 @@
 module Rbnotes
-  VERSION = "0.4.2"
-  RELEASE = "2020-11-05"
+  VERSION = "0.4.3"
+  RELEASE = "2020-11-08"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbnotes
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - mnbi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-05 00:00:00.000000000 Z
+date: 2020-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: textrepo
@@ -64,6 +64,8 @@ files:
 - lib/rbnotes/commands.rb
 - lib/rbnotes/commands/add.rb
 - lib/rbnotes/commands/delete.rb
+- lib/rbnotes/commands/export.rb
+- lib/rbnotes/commands/help.rb
 - lib/rbnotes/commands/import.rb
 - lib/rbnotes/commands/list.rb
 - lib/rbnotes/commands/search.rb