rbnotes 0.3.0 → 0.4.3

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,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
@@ -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
     #
@@ -45,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