rbnotes 0.4.11 → 0.4.16

data/lib/rbnotes/commands/pick.rb

@@ -9,19 +9,35 @@ module Rbnotes::Commands
       "Pick a timestamp with a picker program"
     end
 
+    DEFAULT_BEHAVIOR = "today"  # :nodoc:
+
     def execute(args, conf)
-      patterns = Rbnotes.utils.expand_keyword_in_args(args)
+      @opts = {}
+      parse_opts(args)
+
+      if args.empty?
+        default_behavior = conf[:list_default] || DEFAULT_BEHAVIOR
+        args << default_behavior
+      end
+
+      utils = Rbnotes.utils
+      patterns = utils.read_timestamp_patterns(args, enum_week: @opts[:enum_week])
+
       @repo = Textrepo.init(conf)
 
       list = []
-      Rbnotes.utils.find_notes(patterns, @repo).each { |timestamp|
-        list << Rbnotes.utils.make_headline(timestamp, @repo.read(timestamp))
+      utils.find_notes(patterns, @repo).each { |timestamp|
+        list << utils.make_headline(timestamp, @repo.read(timestamp))
       }
 
       picker = conf[:picker]
       unless picker.nil?
+        picker_opts = conf[:picker_option]
+        cmds = [picker]
+        cmds.concat(picker_opts.split) unless picker_opts.nil?
+
         require 'open3'
-        result = Open3.pipeline_rw(picker) { |stdin, stdout, _|
+        result = Open3.pipeline_rw(cmds) { |stdin, stdout, _|
           stdin.puts list
           stdin.close
           stdout.read
@@ -43,5 +59,25 @@ is specified, it will behave as same as "list" command.
 
 HELP
     end
+
+    # :stopdoc:
+
+    private
+
+    def parse_opts(args)
+      while args.size > 0
+        arg = args.shift
+        case arg
+        when "-w", "--week"
+          @opts[:enum_week] = true
+        else
+          args.unshift(arg)
+          break
+        end
+      end
+    end
+
+    # :startdoc:
+
   end
 end

data/lib/rbnotes/commands/show.rb

@@ -5,13 +5,17 @@ module Rbnotes::Commands
   # argument must be a string which can be converted into
   # Textrepo::Timestamp object.
   #
+  # Accepts an option with `-n NUMBER` (or `--num-of-lines`), to show
+  # the first NUMBER lines of the content of each note.
+  #
   # A string for Textrepo::Timestamp must be:
   #
   #     "20201106112600"     : year, date, time and sec
   #     "20201106112600_012" : with suffix
   #
   # If no argument is passed, reads the standard input for arguments.
-
+  # If a specified timestamp does not exist in the repository as a key,
+  # Rbnotes::MissingTimestampError will occur.
   class Show < Command
 
     def description             # :nodoc:
@@ -19,10 +23,26 @@ module Rbnotes::Commands
     end
 
     def execute(args, conf)
+      @opts = {}
+      parse_opts(args)
+
       stamps = Rbnotes.utils.read_multiple_timestamps(args)
       repo = Textrepo.init(conf)
 
-      content = stamps.map { |stamp| [stamp, repo.read(stamp)] }.to_h
+      content = stamps.map { |stamp|
+        begin
+          text = repo.read(stamp)
+        rescue Textrepo::MissingTimestampError => _
+          raise Rbnotes::MissingTimestampError, stamp
+        end
+
+        lines = text.size
+        if @opts[:num_of_lines].to_i > 0
+          lines = [@opts[:num_of_lines], lines].min
+        end
+
+        [stamp, text[0, lines]]
+      }.to_h
 
       pager = conf[:pager]
       unless pager.nil?
@@ -35,11 +55,14 @@ module Rbnotes::Commands
     def help                    # :nodoc:
       puts <<HELP
 usage:
-    #{Rbnotes::NAME} show [TIMESTAMP...]
+    #{Rbnotes::NAME} show [(-n|--num-of-lines) NUMBER] [TIMESTAMP...]
 
 Show the content of given notes.  TIMESTAMP must be a fully qualified
 one, such "20201016165130" or "20201016165130_012" if it has a suffix.
 
+Accept an option with `-n NUMBER` (or `--num-of-lines`), to show the
+first NUMBER lines of the content of each note.
+
 The command try to read its argument from the standard input when no
 argument was passed in the command line.
 HELP
@@ -49,6 +72,25 @@ HELP
 
     private
 
+    def parse_opts(args)
+      while args.size > 0
+        arg = args.shift
+        case arg
+        when "-n", "--num-of-lines"
+          num_of_lines = args.shift
+          raise ArgumentError, "missing number: %s" % args.unshift(arg) if num_of_lines.nil?
+
+          num_of_lines = num_of_lines.to_i
+          raise ArgumentError, "illegal number (must be greater than 0): %d" % num_of_lines unless num_of_lines > 0
+
+          @opts[:num_of_lines] = num_of_lines
+        else
+          args.unshift(arg)
+          break
+        end
+      end
+    end
+
     def puts_with_pager(pager, output)
       require "open3"
       Open3.pipeline_w(pager) { |stdin|

data/lib/rbnotes/commands/statistics.rb

@@ -9,20 +9,14 @@ module Rbnotes::Commands
     end
 
     def execute(args, conf)
+      @opts = {}
+      parse_opts(args)
+
       report = :total
-      while args.size > 0
-        arg = args.shift
-        case arg
-        when "-y", "--yearly"
-          report = :yearly
-          break
-        when "-m", "--monthly"
-          report = :monthly
-          break
-        else
-          args.unshift(arg)
-          raise ArgumentError, "invalid option or argument: %s" % args.join(" ")
-        end
+      if @opts[:yearly]
+        report = :yearly
+      elsif @opts[:monthly]
+        report = :monthly
       end
 
       stats = Rbnotes::Statistics.new(conf)
@@ -51,5 +45,30 @@ In the version #{Rbnotes::VERSION}, only number of notes is supported.
 HELP
     end
 
+    # :stopdoc:
+
+    private
+
+    def parse_opts(args)
+      while args.size > 0
+        arg = args.shift
+        case arg
+        when "-y", "--yearly"
+          @opts[:yearly] = true
+          @opts[:monthly] = false
+          break
+        when "-m", "--monthly"
+          @opts[:yearly] = false
+          @opts[:monthly] = true
+          break
+        else
+          args.unshift(arg)
+          raise ArgumentError, "invalid option or argument: %s" % args.join(" ")
+        end
+      end
+    end
+
+    # :startdoc:
+
   end
 end

data/lib/rbnotes/commands/update.rb

@@ -32,16 +32,7 @@ module Rbnotes::Commands
 
     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
+      parse_opts(args)
 
       target_stamp = Rbnotes.utils.read_timestamp(args)
       editor = Rbnotes.utils.find_editor(conf[:editor])
@@ -100,5 +91,25 @@ editor program will be searched as same as add command.  If none of
 editors is available, the execution fails.
 HELP
     end
+
+    # :stopdoc:
+
+    private
+
+    def parse_opts(args)
+      while args.size > 0
+        arg = args.shift
+        case arg
+        when "-k", "--keep"
+          @opts[:keep_timestamp] = true
+        else
+          args.unshift(arg)
+          break
+        end
+      end
+    end
+
+    # :startdoc:
+
   end
 end

data/lib/rbnotes/conf.rb

@@ -31,19 +31,26 @@ module Rbnotes
 
     DIRNAME_COMMON_CONF = ".config"
 
-    def initialize(conf_path = nil)   # :nodoc:
-      @conf_path = conf_path
+    def initialize(path = nil)   # :nodoc:
       @conf = {}
 
-      if use_default_values?
-        @conf.merge!(DEFAULT_VALUES)
+      unless path.nil?
+        abspath = File.expand_path(path)
+        raise NoConfFileError, path unless FileTest.exist?(abspath)
+        @conf[:path] = abspath
       else
-        @conf_path ||= default_conf_file
-        raise NoConfFileError, @conf_path unless File.exist?(@conf_path)
-
-        yaml_str = File.open(@conf_path, "r") { |f| f.read }
-        @conf = YAML.load(yaml_str)
+        @conf[:path] = default_conf_path
       end
+
+      values =
+        if FileTest.exist?(@conf[:path])
+          yaml_str = File.open(@conf[:path], "r") { |f| f.read }
+          YAML.load(yaml_str)
+        else
+          DEFAULT_VALUES
+        end
+      @conf.merge!(values)
+      @conf[:config_home] = config_home
     end
 
     def_delegators(:@conf,
@@ -91,7 +98,7 @@ module Rbnotes
       :test => "_test",
     }
 
-    def base_path
+    def config_home
       path = nil
       xdg, user = ["XDG_CONFIG_HOME", "HOME"].map{|n| ENV[n]}
       if xdg
@@ -99,15 +106,11 @@ module Rbnotes
       else
         path = File.join(user, DIRNAME_COMMON_CONF, DIRNAME_RBNOTES)
       end
-      return path
-    end
-
-    def default_conf_file
-      File.join(base_path, FILENAME_CONF)
+      path
     end
 
-    def use_default_values?
-      @conf_path.nil? && !File.exist?(default_conf_file)
+    def default_conf_path
+      File.join(config_home, FILENAME_CONF)
     end
 
   # :startdoc:

data/lib/rbnotes/error.rb

@@ -7,13 +7,15 @@ module Rbnotes
   # :stopdoc:
 
   module ErrMsg
-    MISSING_ARGUMENT  = "Missing argument: %s"
-    MISSING_TIMESTAMP = "Missing timestamp: %s"
-    NO_EDITOR         = "No editor is available: %s"
-    PROGRAM_ABORT     = "External program was aborted: %s"
-    UNKNOWN_KEYWORD   = "Unknown keyword: %s"
-    INVALID_TIMESTAMP_PATTERN = "Invalid timestamp pattern: %s"
-    NO_CONF_FILE      = "No configuration file: %s"
+    MISSING_ARGUMENT  = "missing argument: %s"
+    MISSING_TIMESTAMP = "missing timestamp: %s"
+    NO_EDITOR         = "no editor is available: %s"
+    PROGRAM_ABORT     = "external program was aborted: %s"
+    UNKNOWN_KEYWORD   = "unknown keyword: %s"
+    INVALID_TIMESTAMP_PATTERN = "invalid timestamp pattern: %s"
+    NO_CONF_FILE      = "no configuration file: %s"
+    NO_TEMPLATE_FILE  = "no template file: %s"
+    INVALID_TIMESTAMP_PATTERN_AS_DATE = "invalid timestamp pattern as date: %s"
   end
 
   # :startdoc:
@@ -86,4 +88,32 @@ module Rbnotes
     end
   end
 
+  ##
+  # An error raised when no arguments is spcified.
+
+  class NoArgumentError < Error
+    def initialize
+      super
+    end
+  end
+
+  ##
+  # An error raised when the specified template files does not exist.
+  #
+  class NoTemplateFileError < Error
+    def initialize(filepath)
+      super(ErrMsg::NO_TEMPLATE_FILE % filepath)
+    end
+  end
+
+  ##
+  # An error raised when the specified pattern cannot be converted
+  # into a date.
+  #
+  class InvalidTimestampPatternAsDateError < Error
+    def initialize(pattern)
+      super(ErrMsg::INVALID_TIMESTAMP_PATTERN_AS_DATE % pattern)
+    end
+  end
+
 end

data/lib/rbnotes/utils.rb

@@ -7,6 +7,20 @@ require "io/console/size"
 require "unicode/display_width"
 
 module Rbnotes
+
+  class << self
+
+    ##
+    # Retrieves the singleton instance of Rbnotes::Utils class.
+    # Typical usage is as follows:
+    #
+    #   Rbnotes.utils.find_editor("emacsclient")
+    #
+    def utils
+      Utils.instance
+    end
+  end
+
   ##
   # Defines several utility methods those are intended to be used in
   # Rbnotes classes.
@@ -89,6 +103,19 @@ module Rbnotes
       tmpfile
     end
 
+    # Acceptable delimiters to separate a timestamp string for human
+    # being to read and input easily.
+    #
+    # Here is some examples:
+    #
+    #   - "2021-04-15 15:34:56" -> "20210415153456" (a timestamp string)
+    #   - "2020-04-15_15:34:56" -> (same as above)
+    #   - "2020-04-15-15-34-56" -> (same as above)
+    #   - "2020 04 15 15 34 56" -> (same as above)
+    #   - "2020-04-15" -> "20200415" (a timestamp pattern)
+
+    TIMESTAMP_DELIMITERS = /[-:_\s]/
+
     ##
     # Generates a Textrepo::Timestamp object from a String which comes
     # from the command line arguments.  When no argument is given,
@@ -99,6 +126,9 @@ module Rbnotes
 
     def read_timestamp(args)
       str = args.shift || read_arg($stdin)
+      raise NoArgumentError if str.nil?
+
+      str = remove_delimiters_from_timestamp_string(str)
       Textrepo::Timestamp.parse_s(str)
     end
 
@@ -107,12 +137,91 @@ module Rbnotes
     # line arguments.  When no argument is given, try to read from
     # STDIN.
     #
+    # When multiple strings those point the identical time are
+    # included the arguments (passed or read form STDIN), the
+    # redundant strings will be removed.
+    #
+    # The order of the arguments will be preserved into the return
+    # value, even if the redundant strings were removed.
+    #
     # :call-seq:
     #   read_multiple_timestamps(args) -> [String]
 
     def read_multiple_timestamps(args)
       strings = args.size < 1 ? read_multiple_args($stdin) : args
-      strings.map { |str| Textrepo::Timestamp.parse_s(str) }
+      raise NoArgumentError if (strings.nil? || strings.empty?)
+      strings.uniq.map { |str|
+        str = remove_delimiters_from_timestamp_string(str)
+        Textrepo::Timestamp.parse_s(str)
+      }
+    end
+
+    ##
+    # Reads timestamp patterns in an array of arguments.  It supports
+    # keywords expansion and enumeration of week.  The function is
+    # intended to be used from Commands::List#execute and
+    # Commands::Pick#execute.
+    #
+    def read_timestamp_patterns(args, enum_week: false)
+      patterns = nil
+      if enum_week
+        patterns = []
+        while args.size > 0
+          arg = args.shift
+          begin
+            patterns.concat(timestamp_patterns_in_week(arg.dup))
+          rescue InvalidTimestampPatternAsDateError => _e
+            raise InvalidTimestampPatternAsDateError, args.unshift(arg)
+          end
+        end
+      else
+        patterns = expand_keyword_in_args(args)
+      end
+      patterns
+    end
+
+    ##
+    # Enumerates all timestamp patterns in a week which contains a
+    # given timestamp as a day of the week.
+    #
+    # The argument must be one of the followings:
+    #   - "yyyymodd" (eg. "20201220")
+    #   - "yymoddhhmiss" (eg. "20201220120048")
+    #   - "yymoddhhmiss_sfx" (eg. "20201220120048_012")
+    #   - "modd" (eg. "1220") (assums in the current year)
+    #   - nil (assumes today)
+    #
+    # :call-seq:
+    #     timestamp_patterns_in_week(String) -> [Array of Strings]
+    #
+    def timestamp_patterns_in_week(arg)
+      date_str = nil
+
+      if arg
+        date_str = remove_delimiters_from_timestamp_string(arg)
+      else
+        date_str = Textrepo::Timestamp.now[0, 8]
+      end
+
+      case date_str.size
+      when "yyyymodd".size
+        # nothing to do
+      when "yyyymoddhhmiss".size, "yyyymoddhhmiss_sfx".size
+        date_str = date_str[0, 8]
+      when "modd".size
+        this_year = Time.now.year.to_s
+        date_str = "#{this_year}#{date_str}"
+      else
+        raise InvalidTimestampPatternAsDateError, arg
+      end
+
+      begin
+        date = Date.parse(date_str)
+      rescue Date::Error => _e
+        raise InvalidTimestampPatternAsDateError, arg
+      end
+
+      dates_in_week(date).map { |date| timestamp_pattern(date) }
     end
 
     ##
@@ -136,72 +245,54 @@ module Rbnotes
     #   - "yeasterday" (or "ye")
     #   - "this_week"  (or "tw")
     #   - "last_week"  (or "lw")
+    #   - "this_month" (or "tm")
+    #   - "last_month" (or "lm")
+    #   - "all"
     #
     # :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))
+        if arg == "all"
+          return [nil]
+        elsif KEYWORDS.include?(arg)
+          patterns.concat(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
+      patterns.uniq.sort
     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)
+    #   |<--------------- console column size -------------------->|
+    #   |   |+-- timestamp ---+  +-subject (the 1st line of note) -+
+    #   |                     |  |                                 |
+    #   |   |20101010001000_123: I love Macintosh.                 [EOL]
+    #   |   |20100909090909_999: This is very very long looong subj[EOL]
+    #   |<->|                 |  |
+    #     ^--- pad             ++
+    #                          ^--- delimiter (2 characters)
     #
     # The subject part will truncate when it is long.
 
-    def make_headline(timestamp, text)
+    def make_headline(timestamp, text, pad = nil)
       _, column = IO.console_size
       delimiter = ": "
       timestamp_width = timestamp.to_s.size
       subject_width = column - timestamp_width - delimiter.size - 1
+      subject_width -= pad.size unless pad.nil?
 
       subject = remove_heading_markup(text[0])
 
       ts_part = "#{timestamp.to_s}    "[0..(timestamp_width - 1)]
+      ts_part.prepend(pad) unless pad.nil?
       sj_part = truncate_str(subject, subject_width)
 
       ts_part + delimiter + sj_part
@@ -210,6 +301,7 @@ module Rbnotes
     ##
     # Finds all notes those timestamps match to given patterns in the
     # given repository.  Returns an Array contains Timestamp objects.
+    # The returned Array is sorted by Timestamp.
     #
     # :call-seq:
     #     find_notes(Array of timestamp patterns, Textrepo::Repository)
@@ -220,17 +312,6 @@ module Rbnotes
       }.flatten.sort{ |a, b| b <=> a }.uniq
     end
 
-    ##
-    # Enumerates all timestamp patterns in a week which contains a
-    # given timestamp as a day of the week.
-    #
-    # :call-seq:
-    #     timestamp_patterns_in_week(timestamp) -> [Array of Strings]
-
-    def timestamp_patterns_in_week(timestamp)
-      dates_in_week(start_date_in_the_week(timestamp.time)).map { |date| timestamp_pattern(date) }
-    end
-
     # :stopdoc:
 
     private
@@ -269,6 +350,48 @@ module Rbnotes
       }.compact
     end
 
+    def remove_delimiters_from_timestamp_string(stamp_str) # :nodoc:
+      str = stamp_str.gsub(TIMESTAMP_DELIMITERS, "")
+      base_size = "yyyymiddhhmoss".size
+      if str.size > base_size   # when suffix is specified
+        str = str[0...base_size] + "_" + str[base_size..-1]
+      end
+      str
+    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.today)
+      when "yesterday", "ye"
+        patterns << timestamp_pattern(Date.today.prev_day)
+      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) })
+      when "this_month", "tm"
+        patterns.concat(dates_in_this_month.map { |d| timestamp_pattern(d) })
+      when "last_month", "lm"
+        patterns.concat(dates_in_last_month.map { |d| timestamp_pattern(d) })
+      else
+        raise UnknownKeywordError, keyword
+      end
+      patterns
+    end
+
+    KEYWORDS = %w(
+      today to yesterday ye
+      this_week tw last_week lw
+      this_month tm last_month lm
+    )
+
     def search_in_path(name)
       search_paths = ENV["PATH"].split(":")
       found = search_paths.map { |path|
@@ -286,49 +409,61 @@ module Rbnotes
       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)
+      dates_in_week(Date.today)
     end
 
     def dates_in_last_week
-      dates_in_week(start_date_in_last_week)
+      dates_in_week(Date.today.prev_day(7))
+    end
+
+    def dates_in_week(date)
+      start_date = start_date_of_week(date)
+      dates = [start_date]
+      1.upto(6) { |i| dates << start_date.next_day(i) }
+      dates
     end
 
-    def start_date_in_this_week
-      start_date_in_the_week(Time.now)
+    def start_date_of_week(date)
+      # week day in monday start calendar
+      date.prev_day((date.wday - 1) % 7)
     end
 
-    def start_date_in_last_week
-      start_date_in_this_week.prev_day(7)
+    def first_date_of_this_month
+      today = Time.now
+      date(Time.new(today.year, today.mon, 1))
     end
 
-    def start_date_in_the_week(time)
-      parts = [:year, :mon, :day].map { |sym| time.send(sym) }
-      Date.new(*parts).prev_day(wday(time))
+    def dates_in_this_month
+      dates_in_month(first_date_of_this_month)
     end
 
-    def wday(time)
-      (time.wday - 1) % 7
+    def dates_in_last_month
+      dates_in_month(first_date_of_this_month.prev_month)
     end
 
-    def dates_in_week(start_date)
-      dates = [start_date]
-      1.upto(6) { |i| dates << start_date.next_day(i) }
+    def dates_in_month(first_date)
+      days = days_in_month(first_date.mon, leap: first_date.leap?)
+      dates = [first_date]
+      1.upto(days - 1) { |i| dates << first_date.next_day(i) }
       dates
     end
 
+    DAYS = {
+      #             1   2   3   4   5   6   7   8   9  10  11  12
+      #            Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
+      false => [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
+      true  => [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
+    }
+
+    def days_in_month(mon, leap: false)
+      DAYS[leap][mon]
+    end
+
     def truncate_str(str, size)
       count = 0
       result = ""