rbnotes 0.4.2 → 0.4.7

data/lib/rbnotes/commands/pick.rb

@@ -0,0 +1,47 @@
+module Rbnotes::Commands
+
+  ##
+  # Picks a timestamp with a picker program, like `fzf`.
+
+  class Pick < Command
+
+    def description             # :nodoc:
+      "Pick a timestamp with a picker program"
+    end
+
+    def execute(args, conf)
+      patterns = Rbnotes.utils.expand_keyword_in_args(args)
+      @repo = Textrepo.init(conf)
+
+      list = []
+      Rbnotes.utils.find_notes(patterns, @repo).each { |timestamp|
+        list << Rbnotes.utils.make_headline(timestamp, @repo.read(timestamp))
+      }
+
+      picker = conf[:picker]
+      unless picker.nil?
+        require 'open3'
+        result = Open3.pipeline_rw(picker) { |stdin, stdout, _|
+          stdin.puts list
+          stdin.close
+          stdout.read
+        }
+        puts result
+      else
+        puts list
+      end
+    end
+
+    def help                    # :nodoc:
+      puts <<HELP
+usage:
+    #{Rbnotes::NAME} pick
+
+Pick a timestamp with a picker program, like `fzf`.  This command
+refers the configuration setting of ":picker".  If no picker program
+is specified, it will behave as same as "list" command.
+
+HELP
+    end
+  end
+end

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?
@@ -34,11 +39,68 @@ module Rbnotes
         result = repo.search(pattern, timestamp_pattern)
       rescue Textrepo::InvalidSearchResultError => e
         puts e.message
-      else
-        result.each { |stamp, num, match|
-          puts "#{stamp}:#{num}:#{match}"
-        }
       end
+      print_search_result(result.map{ |e| SearchEntry.new(*e) })
+    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
+
+    private
+
+    # Each entry of search result is:
+    #
+    #   [<timestamp>, <line_number>, <matched_text>]
+    #
+    # The sort must be done in;
+    #
+    #   - descending order for <timestamp>,
+    #   - ascending ordier for <line_number>.
+    #
+
+    SearchEntry = Struct.new(:timestamp, :line_number, :matched_text) {
+      def timestamp_size
+        timestamp.to_s.size
+      end
+    }
+
+    def print_search_result(entries)
+      maxcol_stamp = entries.map(&:timestamp_size).max
+      maxcol_num = entries.map(&:line_number).max
+
+      sort(entries).each { |e|
+        stamp_display = "%- *s" % [maxcol_stamp, e.timestamp]
+        num_display = "%*d" % [maxcol_num, e.line_number]
+
+        puts "#{stamp_display}: #{num_display}: #{e.matched_text}"
+      }
+    end
+
+    def sort(search_result)
+      search_result.sort { |a, b|
+        stamp_comparison = (b.timestamp <=> a.timestamp)
+        if stamp_comparison == 0
+          a.line_number <=> b.line_number
+        else
+          stamp_comparison
+        end
+      }
+    end
+
   end
 end

data/lib/rbnotes/commands/show.rb

@@ -1,7 +1,25 @@
-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)
+      stamp = Rbnotes.utils.read_timestamp(args)
 
       repo = Textrepo.init(conf)
       content = repo.read(stamp)
@@ -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,31 @@
 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"
@@ -47,8 +43,8 @@ module Rbnotes::Commands
         end
       end
 
-      target_stamp = Rbnotes::Utils.read_timestamp(args)
-      editor = find_editor(conf[:editor])
+      target_stamp = Rbnotes.utils.read_timestamp(args)
+      editor = Rbnotes.utils.find_editor(conf[:editor])
       repo = Textrepo.init(conf)
 
       text = nil
@@ -58,7 +54,7 @@ module Rbnotes::Commands
         raise Rbnotes::MissingTimestampError, target_stamp
       end
 
-      tmpfile = run_with_tmpfile(editor, target_stamp.to_s, text)
+      tmpfile = Rbnotes.utils.run_with_tmpfile(editor, target_stamp.to_s, text)
       text = File.readlines(tmpfile, :chomp => true)
 
       unless text.empty?
@@ -82,5 +78,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/error.rb

@@ -11,6 +11,7 @@ module Rbnotes
     MISSING_TIMESTAMP = "missing timestamp: %s"
     NO_EDITOR         = "No editor is available: %s"
     PROGRAM_ABORT     = "External program was aborted: %s"
+    UNKNOWN_KEYWORD   = "Unknown keyword: %s"
   end
 
   # :startdoc:
@@ -53,4 +54,14 @@ module Rbnotes
       super(ErrMsg::PROGRAM_ABORT % cmdline.join(" "))
     end
   end
+
+  ##
+  # An eeror raised when an unknown keyword was specified as a
+  # timestamp string pattern.
+
+  class UnknownKeywordError < Error
+    def initialize(keyword)
+      super(ErrMsg::UNKNOWN_KEYWORD % keyword)
+    end
+  end
 end

data/lib/rbnotes/utils.rb

@@ -1,12 +1,18 @@
+require "singleton"
 require "pathname"
 require "tmpdir"
+require "date"
+require "io/console/size"
+
+require "unicode/display_width"
 
 module Rbnotes
   ##
   # Defines several utility methods those are intended to be used in
   # Rbnotes classes.
   #
-  module Utils
+  class Utils
+    include Singleton
 
     ##
     # Finds a external editor program which is specified with the
@@ -26,7 +32,6 @@ module Rbnotes
     def find_editor(preferred_editor)
       find_program([preferred_editor, ENV["EDITOR"], "nano", "vi"].compact)
     end
-    module_function :find_editor
 
     ##
     # Finds a executable program in given names.  When the executable
@@ -60,7 +65,6 @@ module Rbnotes
       }
       nil
     end
-    module_function :find_program
 
     ##
     # Executes the program with passing the given filename as argument.
@@ -84,7 +88,6 @@ module Rbnotes
       raise ProgramAbortError, [prog, tmpfile] unless rc
       tmpfile
     end
-    module_function :run_with_tmpfile
 
     ##
     # Generates a Textrepo::Timestamp object from a String which comes
@@ -98,7 +101,6 @@ module Rbnotes
       str = args.shift || read_arg($stdin)
       Textrepo::Timestamp.parse_s(str)
     end
-    module_function :read_timestamp
 
     ##
     # Reads an argument from the IO object.  Typically, it is intended
@@ -119,7 +121,111 @@ module Rbnotes
         nil
       end
     end
-    module_function :read_arg
+
+    ##
+    # Parses the given arguments and expand keywords if found.  Each
+    # of the arguments is assumed to represent a timestamp pattern (or
+    # a keyword to be expand into several timestamp pattern).  Returns
+    # an Array of timestamp partterns (each pattern is a String
+    # object).
+    #
+    # A timestamp pattern looks like:
+    #
+    #   (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")
+    #
+    # :call-seq:
+    #   expand_keyword_in_args(Array of Strings) -> Array of Strings
+
+    def expand_keyword_in_args(args)
+      return [nil] if args.empty?
+
+      patterns = []
+      while args.size > 0
+        arg = args.shift
+        if ["today", "to", "yesterday", "ye",
+            "this_week", "tw", "last_week", "lw"].include?(arg)
+          patterns.concat(Rbnotes.utils.expand_keyword(arg))
+        else
+          patterns << arg
+        end
+      end
+      patterns.sort.uniq
+    end
+
+    ##
+    # Expands a keyword to timestamp strings.
+    #
+    # :call-seq:
+    #     expand_keyword(keyword as String) -> Array of timestamp Strings
+
+    def expand_keyword(keyword)
+      patterns = []
+      case keyword
+      when "today", "to"
+        patterns << timestamp_pattern(date_of_today)
+      when "yesterday", "ye"
+        patterns << timestamp_pattern(date_of_yesterday)
+      when "this_week", "tw"
+        patterns.concat(dates_in_this_week.map { |d| timestamp_pattern(d) })
+      when "last_week", "lw"
+        patterns.concat(dates_in_last_week.map { |d| timestamp_pattern(d) })
+      else
+        raise UnknownKeywordError, keyword
+      end
+      patterns
+    end
+
+    ##
+    # Makes a headline with the timestamp and subject of the notes, it
+    # looks like as follows:
+    #
+    #   |<------------------ console column size ------------------->|
+    #   +-- timestamp ---+  +-  subject (the 1st line of each note) -+
+    #   |                |  |                                        |
+    #   20101010001000_123: I love Macintosh.                        [EOL]
+    #   20100909090909_999: This is very very long long loooong subje[EOL]
+    #                     ++
+    #                      ^--- delimiter (2 characters)
+    #
+    # The subject part will truncate when it is long.
+
+    def make_headline(timestamp, text)
+      _, column = IO.console_size
+      delimiter = ": "
+      timestamp_width = timestamp.to_s.size
+      subject_width = column - timestamp_width - delimiter.size - 1
+
+      subject = remove_heading_markup(text[0])
+
+      ts_part = "#{timestamp.to_s}    "[0..(timestamp_width - 1)]
+      sj_part = truncate_str(subject, subject_width)
+
+      ts_part + delimiter + sj_part
+    end
+
+    ##
+    # Finds all notes those timestamps match to given patterns in the
+    # given repository.  Returns an Array contains Timestamp objects.
+    #
+    # :call-seq:
+    #     find_notes(Array of timestamp patterns, Textrepo::Repository)
+
+    def find_notes(timestamp_patterns, repo)
+      timestamp_patterns.map { |pat|
+        repo.entries(pat)
+      }.flatten.sort{ |a, b| b <=> a }.uniq
+    end
 
     # :stopdoc:
 
@@ -132,11 +238,70 @@ module Rbnotes
       }
       found.compact[0]
     end
-    module_function :search_in_path
 
     def add_extension(basename)
       "#{basename}.md"
     end
-    module_function :add_extension
+
+    def timestamp_pattern(date)
+      date.strftime("%Y%m%d")
+    end
+
+    def date_of_today
+      date(Time.now)
+    end
+
+    def date_of_yesterday
+      date(Time.now).prev_day
+    end
+
+    def date(time)
+      Date.new(time.year, time.mon, time.day)
+    end
+
+    def dates_in_this_week
+      dates_in_week(start_date_in_this_week)
+    end
+
+    def dates_in_last_week
+      dates_in_week(start_date_in_last_week)
+    end
+
+    def start_date_in_this_week
+      today = Time.now
+      Date.new(today.year, today.mon, today.day).prev_day(wday(today))
+    end
+
+    def start_date_in_last_week
+      start_date_in_this_week.prev_day(7)
+    end
+
+    def wday(time)
+      (time.wday - 1) % 7
+    end
+
+    def dates_in_week(start_date)
+      dates = [start_date]
+      1.upto(6) { |i| dates << start_date.next_day(i) }
+      dates
+    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
+
+    def remove_heading_markup(str)
+      str.sub(/^#+ +/, '')
+    end
+
+    # :startdoc:
+
   end
 end