rbnotes 0.4.1 → 0.4.6

data/lib/rbnotes/commands/add.rb

@@ -27,7 +27,10 @@ module Rbnotes::Commands
   # 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)
       @opts = {}
@@ -41,16 +44,23 @@ module Rbnotes::Commands
           @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)
+      editor = Rbnotes.utils.find_program(candidates)
       raise Rbnotes::NoEditorError, candidates if editor.nil?
 
-      tmpfile = run_with_tmpfile(editor, stamp.to_s)
+      tmpfile = Rbnotes.utils.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)
@@ -71,6 +81,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,20 +1,19 @@
-# :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)
+      stamp = Rbnotes.utils.read_timestamp(args)
 
       repo = Textrepo.init(conf)
       begin
@@ -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,35 @@
-require "unicode/display_width"
-require "io/console/size"
+module Rbnotes::Commands
 
-module Rbnotes
   ##
   # 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
-    # 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.
+    # Shows a list of notes in the repository.  Arguments are
+    # optional.  If several args are passed, each of them must be a
+    # timestamp pattern or a keyword.
+    #
+    # Any order of timestamp patterns and keywords mixture is
+    # acceptable.  The redundant patterns are just ignored.
+    #
+    # A timestamp pattern is a string which would match several
+    # Timestamp objects.  A timestamp is an instance of
+    # Textrepo::Timestamp class.
     #
-    # Here is
-    # several examples of timestamp patterns.
+    # A keyword must be one of them:
+    #
+    # - "today"      (or "to")
+    # - "yeasterday" (or "ye")
+    # - "this_week"  (or "tw")
+    # - "last_week"  (or "lw")
+    #
+    # Here is several examples of timestamp patterns.
     #
     #   "20201027093600_012": a complete string to represent a timestamp
     #   - this pattern would match exactly one Timestamp object
@@ -38,63 +51,41 @@ module Rbnotes
     #     execute(Array, Rbnotes::Conf or Hash) -> nil
 
     def execute(args, conf)
-      pattern = args.shift      # `nil` is acceptable
-
+      patterns = Rbnotes.utils.expand_keyword_in_args(args)
       @repo = Textrepo.init(conf)
       # newer stamp shoud be above
-      stamps = @repo.entries(pattern).sort{|a, b| b <=> a}
-      stamps.each { |timestamp|
-        puts make_headline(timestamp)
+      Rbnotes.utils.find_notes(patterns, @repo).each { |timestamp|
+        puts Rbnotes.utils.make_headline(timestamp, @repo.read(timestamp))
       }
     end
 
-    # :stopdoc:
+    def help                    # :nodoc:
+      puts <<HELP
+usage:
+    #{Rbnotes::NAME} list [STAMP_PATTERN|KEYWORD]
 
-    private
-    TIMESTAMP_STR_MAX_WIDTH = "yyyymoddhhmiss_sfx".size
+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.
 
-    ##
-    # 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.
+STAMP_PATTERN must be:
 
-    def make_headline(timestamp)
-      _, column = IO.console_size
-      delimiter = ": "
-      subject_width = column - TIMESTAMP_STR_MAX_WIDTH - delimiter.size - 1
+    (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"
 
-      subject = remove_heading_markup(@repo.read(timestamp)[0])
+KEYWORD:
 
-      ts_part = "#{timestamp.to_s}    "[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
+    - "today"      (or "to")
+    - "yeasterday" (or "ye")
+    - "this_week"  (or "tw")
+    - "last_week"  (or "lw")
 
-    def remove_heading_markup(str)
-      str.sub(/^#+ +/, '')
+HELP
     end
 
-    # :startdoc:
   end
 end