rbnotes 0.3.1 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cb54d2116edee3136979232f749434f0b4c068fa5162321bd02dfc96fcd8ece
-  data.tar.gz: 1d3d61b2cafa2d7a2825deb764ee232729e0a7bc8afa51868dbd98db2b7c016f
+  metadata.gz: a04bd4d45d7c2f4227f355672baa860602ae3b9e481e7a384daf4283f4ad6754
+  data.tar.gz: bc707b20ea91ab655f6e355026164c01844c82ea3869c18fd5ca1040c968934d
 SHA512:
-  metadata.gz: 07a40884e1f0a73bc4b3d70104d98d56814084ce643b86715cf739ece89124da45236cccc4ba881f78e176b8ee318eceaa5974811e4f990d81dce17a018b8a74
-  data.tar.gz: fd70d8ed8d461610cf0f60fe506588414abbd2f9a6fe9deabe8de49ca7a3146d49efcb799b25bb4f66158afc4298643993f1d2a3a7e21d095efe2e7462d8792f
+  metadata.gz: d93df0df9e002a8bae26b7d9e1e89acf19d84551635d58f3ec747c78f3764ac004a784977a3d9940783a8b4661b2caafd2b55502644bca4bb69947d91593bd79
+  data.tar.gz: 913c240b04215cb5502146f4d1edcd5c1ddc273de31baace3f0d8dff600dcf759e5983aee5cce72fb5079dc26e1a22b43c0aad46e1cc766c4127697090fb0037

data/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 ## [Unreleased]
 Nothing to record here.
 
+## [0.4.4] - 2020-11-09
+###
+- Add a feature to use a keyword as an argument for `list`. (#47)
+
+## [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)
+
+### Fixed
+- Fix issue #45: hanging up of `add` command.
+
+## [0.4.1] - 2020-11-04
+### Added
+- Add a feature to accept a timestamp in `add` command. (#34)
+
+## [0.4.0] - 2020-11-03
+### Added
+- Add a new command `search` to perform full text search. (#33)
+
 ## [0.3.1] - 2020-10-30
 ### Added
 - Add feature to specify configuration file in the command line. (#21)

data/Gemfile

@@ -6,4 +6,4 @@ gemspec
 gem "rake", "~> 13.0"
 gem "minitest", "~> 5.0"
 
-gem 'textrepo', "~> 0.4"
+gem 'textrepo', "~> 0.5.4"

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    rbnotes (0.3.1)
-      textrepo (~> 0.4)
+    rbnotes (0.4.4)
+      textrepo (~> 0.5.4)
       unicode-display_width (~> 1.7)
 
 GEM
@@ -10,7 +10,7 @@ GEM
   specs:
     minitest (5.14.2)
     rake (13.0.1)
-    textrepo (0.4.5)
+    textrepo (0.5.4)
     unicode-display_width (1.7.0)
 
 PLATFORMS
@@ -20,7 +20,7 @@ DEPENDENCIES
   minitest (~> 5.0)
   rake (~> 13.0)
   rbnotes!
-  textrepo (~> 0.4)
+  textrepo (~> 0.5.4)
 
 BUNDLED WITH
    2.1.4

data/README.md

@@ -4,6 +4,9 @@
 
 Rbnotes is a simple utility to write a note in the single repository.
 
+This document provides the basic information to use rbnotes.
+You may find more useful information in [Wiki pages](https://github.com/mnbi/rbnotes/wiki).
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -39,6 +42,8 @@ rbnotes [global_opts] [command] [command_opts] [args]
   - imports existing files
 - list
   - lists notes in the repository with their timestamps and subject
+- search
+  - search a word (or words) in the repository
 - show
   - shows the content of a note
 - add
@@ -145,6 +150,38 @@ The short-hand notation of the home directory ("~") is usable.
 
 - :pager : specify a pager program
 - :editor : specify a editor program
+- :searcher: specify a program to perform search
+- :searcher_options: specify options to pass to the searcher program
+
+Be careful to set `:searcher` and `:searcher_options`. The searcher
+program must be expected to behave equivalent to `grep` with `-inRE`.
+At least, its output must be the same format and it must runs
+recursively to a directory.
+
+If your favorite searcher is one of the followings, see the default
+options which `textrepo` sets for those searchers.  In most cases, you
+don't have to set `:searcher_options` for them.
+
+| searcher | default options in `textrepo`                      |
+|:---------|:---------------------------------------------------|
+| `grep`   | `["-i", "-n", "-R", "-E"]`                         |
+| `egrep`  | `["-i", "-n", "-R"]`                               |
+| `ggrep`  | `["-i", "-n", "-R", "-E"]`                         |
+| `gegrep` | `["-i", "-n", "-R"]`                               |
+| `rg`     | `["-S", "-n", "--no-heading", "--color", "never"]` |
+
+Those searcher names are used in macOS (with Homebrew).  Any other OS
+might use different names.
+
+- `grep` and `egrep` -> BSD grep (macOS default)
+- `ggrep` and `gegrep` -> GNU grep
+- `rg` -> ripgrep
+
+If the name is different, `:searcher_options` should be set with the
+same value.  For example, if you system use the name `gnugrep` as GNU
+grep, and you want to use it as the searcher (that is, set `gnugrep`
+to `:searcher`), you should set `:searcher_options` value with `["-i",
+"-n", "-R", "-E"]`.
 
 ##### Default values for mandatory variables
 

data/exe/rbnotes

@@ -4,8 +4,6 @@ require "rbnotes"
 
 include Rbnotes
 
-DEBUG = true
-
 class App
   def initialize
     @gopts = {}
@@ -25,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
@@ -45,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,54 +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]
+      class Usage < Command
 
-command:
-    add            : create a new note
-    import FILE    : import a FILE into the repository
+        def description
+          "Print usage"
+        end
 
-    list PATTERN   : list notes those timestamp matches PATTERN
+        def execute(_, _)
+          puts <<USAGE
+Syntax:
+  #{Rbnotes::NAME} [-c| --conf CONF_FILE] [command] [args]
 
-    PATTERN must be:
-        (a) full qualified timestamp (with suffix): "20201030160200"
-        (b) year and date part: "20201030"
-        (c) year part only: "2020"
-        (d) date part only: "1030"
+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|KEYWORD]
+  #{Rbnotes::NAME} search PATTERN [STAMP_PATTERN]
+  #{Rbnotes::NAME} show [TIMESTAMP]
+  #{Rbnotes::NAME} update [TIMESTAMP]
 
-    show STAMP     : show the note specified with STAMP
-    update STAMP   : edit the note with external editor
-    delete STAMP   : delete the note specified with STAMP
+Further help for each command:
+  #{Rbnotes::NAME} help commands
+  #{Rbnotes::NAME} help [COMMAND]
 
-    STAMP must be a sequence of digits to represent year, date and
-    time (and suffix), such "20201030160200" or "20201030160200_012".
+Further information:
+  https://github.com/mnbi/rbnotes/wiki
 
-    show/update/delete reads its argument from the standard input when
-    no argument was passed in the command line.
+USAGE
+        end
 
-    version        : print version
-    help           : show help
+        def help
+          puts <<HELP_USAGE
+usage:
+    #{Rbnotes::NAME} usage
 
-commands for development purpose:
-    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
+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]
@@ -89,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?
@@ -111,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?
@@ -123,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
 
-    DEFAULT_CMD_NAME = "help"
+        def default_cmd
+          Usage
+        end
+
+        def command(name)
+          begin
+            const_defined?(name, false) ? const_get(name, false) : nil
+          rescue NameError => _
+            nil
+          end
+        end
+      end
+    end
 
     # :startdoc:
 
@@ -139,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

@@ -1,9 +1,20 @@
 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.
+  # Adds 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.  If the timestamp has already existed in the repository, the
+  # command fails.
+  #
+  # Accepts 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:
@@ -14,23 +25,48 @@ module Rbnotes::Commands
   # 4. "vi"
   #
   # If none of the above editor is available, the command fails.
-  #
+
   class Add < Command
     include ::Rbnotes::Utils
 
+    def description             # :nodoc:
+      "Add a new note"
+    end
+
     def execute(args, conf)
-      newstamp = Textrepo::Timestamp.new(Time.now)
+      @opts = {}
+      while args.size > 0
+        arg = args.shift
+        case arg
+        when "-t", "--timestamp"
+          stamp_str = args.shift
+          raise ArgumentError, "missing timestamp: %s" % args.unshift(arg) if stamp_str.nil?
+          stamp_str = complement_timestamp_pattern(stamp_str)
+          @opts[:timestamp] = Textrepo::Timestamp.parse_s(stamp_str)
+        else
+          args.unshift(arg)
+          break
+        end
+      end
+
+      stamp = @opts[:timestamp] || 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)
+      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)
       begin
-        repo.create(newstamp, text)
+        repo.create(stamp, text)
       rescue Textrepo::DuplicateTimestampError => e
         puts e.message
         puts "Just wait a second, then retry."
@@ -39,11 +75,58 @@ module Rbnotes::Commands
       rescue StandardError => e
         puts e.message
       else
-        puts "Add a note [%s]" % newstamp.to_s
+        puts "Add a note [%s]" % stamp.to_s
       ensure
         # Don't forget to remove the temporary file.
         File.delete(tmpfile)
       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)
+      stamp_str = nil
+      case pattern.to_s.size
+      when "yyyymoddhhmiss_lll".size, "yyyymoddhhmiss".size
+        stamp_str = pattern.dup
+      when "yyyymoddhhmi".size  # omit sec part
+        stamp_str = "#{pattern}00"
+      when "moddhhmi".size      # omit year and sec part
+        stamp_str = "#{Time.now.year}#{pattern}00"
+      else
+        raise Textrepo::InvalidTimestampStringError, pattern
+      end
+      stamp_str
+    end
   end
 end

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,22 +1,27 @@
+require "date"
 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
     # Timestamp objects.
     #
-    # Here is
-    # several examples of timestamp patterns.
+    # Here is several examples of timestamp patterns.
     #
     #   "20201027093600_012": a complete string to represent a timestamp
     #   - this pattern would match exactly one Timestamp object
@@ -24,6 +29,9 @@ module Rbnotes
     #   "20201027": specifies year and date
     #   - all Timestamps those have the same year and date would match
     #
+    #   "202011": specifies year and month
+    #   - all Timestamps those have the same year and month would match
+    #
     #   "2020": specifies year only
     #   - all Timestamps those have the same year would match
     #
@@ -35,16 +43,61 @@ module Rbnotes
     #     execute(Array, Rbnotes::Conf or Hash) -> nil
 
     def execute(args, conf)
-      pattern = args.shift      # `nil` is acceptable
+      arg = args.shift
+      patterns = []
+
+      case arg.to_s
+      when "today", "to"
+        patterns << Textrepo::Timestamp.new(Time.now).to_s[0..7]
+      when "yesterday", "ye"
+        t = Time.now
+        patterns << Date.new(t.year, t.mon, t.day).prev_day.strftime("%Y%m%d")
+      when "this_week", "tw"
+        patterns.concat(dates_in_this_week)
+      when "last_week", "lw"
+        patterns.concat(dates_in_last_week)
+      else
+        patterns << arg
+      end
 
       @repo = Textrepo.init(conf)
+      stamps = patterns.map { |pat|
+        @repo.entries(pat).sort{|a, b| b <=> a}
+      }.flatten
       # newer stamp shoud be above
-      stamps = @repo.entries(pattern).sort{|a, b| b <=> a}
       stamps.each { |timestamp|
         puts make_headline(timestamp)
       }
     end
 
+    def help                    # :nodoc:
+      puts <<HELP
+usage:
+    #{Rbnotes::NAME} list [STAMP_PATTERN|KEYWORD]
+
+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.  Instead of STAMP_PATTERN, some KEYWORDs could be
+used.
+
+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"
+
+KEYWORD:
+
+    - "today"      (or "to")
+    - "yeasterday" (or "ye")
+    - "this_week"  (or "tw")
+    - "last_week"  (or "lw")
+
+HELP
+    end
+
     # :stopdoc:
 
     private
@@ -92,6 +145,29 @@ module Rbnotes
       str.sub(/^#+ +/, '')
     end
 
+    # week day for Monday start calendar
+    def wday(time)
+      (time.wday - 1) % 7
+    end
+
+    def dates_in_this_week
+      to = Time.now
+      start = Date.new(to.year, to.mon, to.day).prev_day(wday(to))
+      dates_in_week(start)
+    end
+
+    def dates_in_last_week
+      to = Time.now
+      start_of_this_week = Date.new(to.year, to.mon, to.day).prev_day(wday(to))
+      dates_in_week(start_of_this_week.prev_day(7))
+    end
+
+    def dates_in_week(start_date)
+      dates = [start_date]
+      1.upto(6) { |i| dates << start_date.next_day(i) }
+      dates.map { |d| d.strftime("%Y%m%d") }
+    end
+
     # :startdoc:
   end
 end

data/lib/rbnotes/commands/search.rb

@@ -0,0 +1,67 @@
+module Rbnotes::Commands
+
+  ##
+  # Searches a given pattern in notes those have timestamps match a
+  # given timestamp pattern.  The first argument is a pattern to search.
+  # It is a String object represents a portion of text or it may a
+  # String represents a regular expression.  The second argument is
+  # optional and it is a timestamp pattern to specify the search target.
+  #
+  # A pattern for search is mandatory.  If no pattern, raises
+  # Rbnotes::MissingArgumentError.
+  #
+  # Example of PATTERN for search:
+  #
+  #   "rbnotes" (a word)
+  #   "macOS Big Sur" (a few words)
+  #   "2[0-9]{3}(0[1-9]|1[0-2])(0[1-9]|[12][0-9]|3[01])" (a regular expression)
+  #
+  # A timestamp pattern is optional.  If no timestamp pattern, all notes
+  # in the repository would be target of search.
+  #
+  # See the document of `Rbnotes::Commands::List#execute` to know about
+  # a timestamp pattern.
+
+  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?
+
+      timestamp_pattern = args.shift # `nil` is acceptable
+
+      repo = Textrepo.init(conf)
+      begin
+        result = repo.search(pattern, timestamp_pattern)
+      rescue Textrepo::InvalidSearchResultError => e
+        puts e.message
+      else
+        result.each { |stamp, num, match|
+          puts "#{stamp}:#{num}:#{match}"
+        }
+      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,37 +1,49 @@
 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.
   #
-  # 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.
+  # When "-k" (or "--keep") option is specified, the timestamp will
+  # remain unchanged.
   #
-  # 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"
 
     def execute(args, conf)
+      @opts = {}
+      while args.size > 0
+        arg = args.shift
+        case arg
+        when "-k", "--keep"
+          @opts[:keep_timestamp] = true
+        else
+          args.unshift(arg)
+          break
+        end
+      end
+
       target_stamp = Rbnotes::Utils.read_timestamp(args)
       editor = find_editor(conf[:editor])
       repo = Textrepo.init(conf)
@@ -44,16 +56,21 @@ module Rbnotes::Commands
       end
 
       tmpfile = run_with_tmpfile(editor, target_stamp.to_s, text)
-      text = File.readlines(tmpfile)
+      text = File.readlines(tmpfile, :chomp => true)
 
       unless text.empty?
+        keep = @opts[:keep_timestamp] || false
         newstamp = nil
         begin
-          newstamp = repo.update(target_stamp, text)
+          newstamp = repo.update(target_stamp, text, keep)
         rescue StandardError => e
           puts e.message
         else
-          puts "Update the note [%s -> %s]" % [target_stamp, newstamp]
+          if keep
+            puts "Update the note content, the timestamp unchanged [%s]" % newstamp
+          else
+            puts "Update the note [%s -> %s]" % [target_stamp, newstamp] unless target_stamp == newstamp
+          end
         ensure
           # Don't forget to remove the temporary file.
           File.delete(tmpfile)
@@ -62,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/utils.rb

@@ -113,7 +113,11 @@ module Rbnotes
       #     foo bar baz ...
       #
       # then, only the first string is interested
-      io.gets.split(" ")[0]
+      begin
+        io.gets.split(":")[0].rstrip
+      rescue NoMethodError => _
+        nil
+      end
     end
     module_function :read_arg
 

data/lib/rbnotes/version.rb

@@ -1,4 +1,4 @@
 module Rbnotes
-  VERSION = "0.3.1"
-  RELEASE = '2020-10-30'
+  VERSION = "0.4.4"
+  RELEASE = "2020-11-09"
 end

data/rbnotes.gemspec

@@ -25,6 +25,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "textrepo", "~> 0.4"
+  spec.add_dependency "textrepo", "~> 0.5.4"
   spec.add_dependency "unicode-display_width", "~> 1.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbnotes
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.4
 platform: ruby
 authors:
 - mnbi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-10-30 00:00:00.000000000 Z
+date: 2020-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: textrepo
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.5.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.5.4
 - !ruby/object:Gem::Dependency
   name: unicode-display_width
   requirement: !ruby/object:Gem::Requirement
@@ -64,8 +64,11 @@ 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
 - lib/rbnotes/commands/show.rb
 - lib/rbnotes/commands/update.rb
 - lib/rbnotes/conf.rb